2019-07-24 19:01:14 +03:00
2016-04-21 15:57:02 +03:00
/ *
* Copyright 2011 - 2014 Xamarin Inc . All rights reserved .
* Copyright 2010 Novell Inc .
*
* Authors :
* Sebastien Pouliot < sebastien @xamarin . com >
* Aaron Bockover < abock @xamarin . com >
* Rolf Bjarne Kvinge < rolf @xamarin . com >
* Geoff Norton < gnorton @novell . com >
*
* Permission is hereby granted , free of charge , to any person obtaining a copy
* of this software and associated documentation files ( the "Software" ) , to deal
* in the Software without restriction , including without limitation the rights
* to use , copy , modify , merge , publish , distribute , sublicense , and / or sell
* copies of the Software , and to permit persons to whom the Software is
* furnished to do so , subject to the following conditions :
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software .
*
* THE SOFTWARE IS PROVIDED "AS IS" , WITHOUT WARRANTY OF ANY KIND , EXPRESS OR
* IMPLIED , INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY ,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT . IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM , DAMAGES OR OTHER
* LIABILITY , WHETHER IN AN ACTION OF CONTRACT , TORT OR OTHERWISE , ARISING FROM ,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE .
* /
using System ;
using System.Collections ;
using System.Globalization ;
using System.IO ;
using System.Linq ;
using System.Text ;
using System.Text.RegularExpressions ;
using System.ComponentModel ;
using System.Collections.Generic ;
using System.Runtime.InteropServices ;
using System.Xml ;
2017-01-11 23:10:39 +03:00
using System.Threading.Tasks ;
2016-04-21 15:57:02 +03:00
using Mono.Cecil ;
using Mono.Linker ;
using Mono.Options ;
using Mono.Tuner ;
using MonoMac.Tuner ;
using Xamarin.Utils ;
using Xamarin.Linker ;
2018-02-05 18:26:29 +03:00
using Registrar ;
using ObjCRuntime ;
2016-04-21 15:57:02 +03:00
namespace Xamarin.Bundler {
2016-12-01 19:18:30 +03:00
enum Action {
None ,
Help ,
Version ,
RunRegistrar ,
}
2016-04-21 15:57:02 +03:00
public static partial class Driver {
[mtouch/mmp] Fix tracking of whether the static registrar should run again or not. Fixes #641. (#3534)
* [tests] Improve debug spew for the RebuildTest_WithExtensions test.
* [mtouch/mmp] Store/load if the dynamic registrar is removed or not into the cached link results.
Store/load if the dynamic registrar is removed or not into the cached link
results, so that we generate the correct main.m even if cached linker results
are used.
* [mtouch/mmp] The static registrar must not execute if we're loading cached results from the linker.
The static registrar must not execute if we're loading cached results from the
linker, because the static registrar needs information from the linker that's
not restored from the cache.
* [mtouch/mmp] Share Touch code.
* [mtouch/mmp] Make it possible to touch inexistent files (to create them).
* [mtouch/mmp] Fix tracking of whether the static registrar should run again or not.
The recent changes to support optimizing away the dynamic registrar caused the
Xamarin.MTouch.RebuildTest_WithExtensions test to regress.
The problem
-----------
* The linker now collects and stores information the static registrar needs.
* This information is not restored from disk when the linker realizes that it
can reload previously linked assemblies instead of executing again.
* The static registrar runs again (for another reason).
* The information the static registrar needs isn't available, and incorrect
output follows.
So fix 1: show an error if the static registrar runs when the linker loaded
cached results.
The exact scenario the test ran into is this:
* 1st build: everything is new and everything is built.
* 2nd build: contents of .exe changes, the linker runs again, the static
registrar runs again, but sees that the generated output didn't change, so
it doesn't write the new content to disk (this is an optimization to avoid
compiling the registrar.m file again unless needed).
* 3rd build: only the .exe timestamp changes, the linker sees nothing changes
in the contents of the .exe and loads the previously linked assemblies from
disk, the static registrar sees that the .exe's timestamp is newer than
registrar.m's timestamp and run again, but doesn't produce the right result
because it doesn't have the information it needs.
Considered solutions
--------------------
1. Only track timestamps, not file contents. This is not ideal, since it will
result in more work done: in particular for the case above, it would add a
registrar.m compilation in build #2, and linker rerun + static registrar
rerun + registrar.m compilation + final native link in build #3.
2. Always write the output of the static registrar, even if it hasn't changed.
This is not ideal either, since it will also result in more work done: for
the case above, it would add a registrar.m compilation + final native link
in build #3.
3. Always write the output of the static registrar, but track if it changed or
not, and if it didn't, just touch registrar.o instead of recompiling it.
This only means the final native link in build #3 is added (see #5 for why
this is worse than it sounds).
4. Always write the output of the static registrar, but track it it changed or
not, and if it didn't, just touch registrar.o instead of recompiling it,
and track that too, so that the final native link in build #3 isn't needed
anymore. Unfortunately this may result in incorrect behavior, because now
the msbuild tasks will detect that the executable has changed, and may run
dsymutil + strip again. The executable didn't actually change, which means
it would be the previously stripped executable, and thus we'd end up with
an empty .dSYM because we ran dsymtil on an already stripped executable.
5. Idea #4, but write the output of the final link into a temporary directory
instead of the .app, so that we could track whether we should update the
executable in the .app or not. This is not optimal either, because
executables can be *big* (I've seen multi-GB tvOS bitcode executables), and
extra copies of such files should not be taken lightly.
6. Idea #4, but tell the MSBuild tasks that dsymutil/strip doesn't need to be
rerun even if the timestamp of the executable changed. This might actually
work, but now the solution's become quite complex.
Implemented solution
--------------------
Use stamp files to detect whether a file is up-to-date or not.
In particular:
* When we don't write to a file because the new contents are identical to the
old contents, we now touch a .stamp file. This stamp file means "the
accompanying file was determined to be up-to-date when the stamp was
touched."
* When checking whether a file is up-to-date, also check for the presence of a
.stamp file, and if it exists, use the highest timestamp between the stamp
file and the actual file.
Now the test scenario becomes:
* 1st build: everything is new and everything is built.
* 2nd build: contents of .exe changes, the linker runs again, the static
registrar runs again, but sees that the generated output didn't change, so
it doesn't write the new content to disk, but it creates a registrar.m.stamp
file to indicate the point in time when registrar.m was considered up-to-
date.
* 3rd build: only the .exe timestamp changes, the linker sees nothing changes
in the contents of the .exe and loads the previously linked assemblies from
disk, the static registrar sees that the .exe's timestamp is *older* than
registrar.m.stamp's timestamp and doesn't run again.
We only use the stamp file for source code (registrar.[m|h], main.[m|h],
pinvokes.[m|h]), since using it every time has too much potential for running
into other problems (for instance we should never create .stamp files inside
the .app).
Fixes these test failures:
1) Failed : Xamarin.MTouch.RebuildTest_WithExtensions("single","",False,System.String[])
single
Expected: <empty>
But was: < "/Users/builder/data/lanes/5746/4123bf7e/source/xamarin-macios/tests/mtouch/bin/Debug/tmp-test-dir/Xamarin.Tests.BundlerTool.CreateTemporaryDirectory371/testApp.app/testApp is modified, timestamp: 2/15/2018 3:04:11 PM > 2/15/2018 3:04:09 PM" >
2) Failed : Xamarin.MTouch.RebuildTest_WithExtensions("dual","armv7,arm64",False,System.String[])
dual
Expected: <empty>
But was: < "/Users/builder/data/lanes/5746/4123bf7e/source/xamarin-macios/tests/mtouch/bin/Debug/tmp-test-dir/Xamarin.Tests.BundlerTool.CreateTemporaryDirectory375/testApp.app/testApp is modified, timestamp: 2/15/2018 3:06:03 PM > 2/15/2018 3:06:00 PM" >
3) Failed : Xamarin.MTouch.RebuildTest_WithExtensions("llvm","armv7+llvm",False,System.String[])
llvm
Expected: <empty>
But was: < "/Users/builder/data/lanes/5746/4123bf7e/source/xamarin-macios/tests/mtouch/bin/Debug/tmp-test-dir/Xamarin.Tests.BundlerTool.CreateTemporaryDirectory379/testApp.app/testApp is modified, timestamp: 2/15/2018 3:07:14 PM > 2/15/2018 3:07:12 PM" >
4) Failed : Xamarin.MTouch.RebuildTest_WithExtensions("debug","",True,System.String[])
debug
Expected: <empty>
But was: < "/Users/builder/data/lanes/5746/4123bf7e/source/xamarin-macios/tests/mtouch/bin/Debug/tmp-test-dir/Xamarin.Tests.BundlerTool.CreateTemporaryDirectory383/testApp.app/testApp is modified, timestamp: 2/15/2018 3:08:16 PM > 2/15/2018 3:08:13 PM" >
5) Failed : Xamarin.MTouch.RebuildTest_WithExtensions("single-framework","",False,System.String[])
single-framework
Expected: <empty>
But was: < "/Users/builder/data/lanes/5746/4123bf7e/source/xamarin-macios/tests/mtouch/bin/Debug/tmp-test-dir/Xamarin.Tests.BundlerTool.CreateTemporaryDirectory387/testApp.app/testApp is modified, timestamp: 2/15/2018 3:09:18 PM > 2/15/2018 3:09:16 PM" >
Fixes https://github.com/xamarin/maccore/issues/641
2018-02-19 22:28:04 +03:00
internal const string NAME = "mmp" ;
2017-01-31 12:18:45 +03:00
internal static Application App = new Application ( Environment . GetCommandLineArgs ( ) ) ;
2019-04-25 19:08:10 +03:00
static Target BuildTarget ;
2016-04-21 15:57:02 +03:00
static List < string > resources = new List < string > ( ) ;
static List < string > resolved_assemblies = new List < string > ( ) ;
static List < string > ignored_assemblies = new List < string > ( ) ;
2018-12-12 17:55:57 +03:00
public static List < string > native_references = new List < string > ( ) ;
2016-04-21 15:57:02 +03:00
static List < string > native_libraries_copied_in = new List < string > ( ) ;
2016-12-01 19:18:30 +03:00
static Action action ;
2016-04-21 15:57:02 +03:00
static string output_dir ;
static string app_name ;
static bool generate_plist ;
static bool no_executable ;
static bool embed_mono = true ;
2019-10-14 17:18:46 +03:00
static List < string > link_flags ;
2016-10-13 18:42:05 +03:00
static string machine_config_path = null ;
2017-08-09 17:39:04 +03:00
static bool bypass_linking_checks = false ;
2016-04-21 15:57:02 +03:00
static string contents_dir ;
static string frameworks_dir ;
static string macos_dir ;
static string resources_dir ;
static string mmp_dir ;
2016-07-28 15:49:21 +03:00
static string AppPath { get { return Path . Combine ( macos_dir , app_name ) ; } }
2016-04-21 15:57:02 +03:00
static string icon ;
static string certificate_name ;
Add bindings for NSXpcConnection and related types (#7001)
* Add bindings for NSXpcConnection and related types
* Re-add accidentally deleted file
* Typo fix
* Add NSXpcInterface.CreateForType()
* Add MethodInfo-taking overloads to NSXpcInterface
* Add null check
* Mark methods with wrappers as internal
Also fixed a formatting bug that I didn't catch earlier.
* Change NSXPCProxyCreating methods to be strongly typed
I got rid of the NSXpcProxyCreating interface in this change,
because its only user was NSXpcConnection, and I needed to
inline the protocol methods into the class definition so I
could mark them as [Internal].
* Add missing casts
* Add NSXpcConnectionOptions enum
* Convert NSXpcConnection constructor to use new enum
* Remove now-unneeded manual constructor
* Fix bgen warning
* Typo fix
* Fix selector
* Remove incorrect use of BindAsAttribute
Per the docs, this only works for enums backed
by NSNumber and NSValue, not for enums
passed directly as integers.
* Fix duplicated selector errors
* Throw ArgumentException instead of InvalidOperationException
* Extend AppExtension targets to produce XPC services
Rather than create an entirely new set of targets
(that would require VS and VSMac updates to properly
consume), I have decided to use the existing AppExtension
build targets to produce XPC services as well. All the
user must do is set the $(IsXPCService) property to true in
their project file, and the targets will do The Right Thing™.
Note that this support is Mac-only for now; I may need a bit
of help adjusting them to work on for iOS/watchOS/tvOS, as I
am not as familiar with those platforms.
* Copy XPC service bundles into the correct location
* Move IsXPCService property definition to props file
* Don't pass /extension to mmp for XPC service targets
This would cause the XPC service binary to
be linked incorrectly.
* Add NSXpcConnection/NSXpcInterface.cs files to the build
* Fix build
* Fix build
* Add required type parameter requirements
* Fix type parameter requirements
* Fix return type
* Fix return type of NSXpcInterface.CreateForProtocol ()
* Take ownership of the returned object types
* Adjust XPC service mmp invocation
I need to link the XPC service bundle as if it is an app extension, but
I must not use xamarin_mac_extension_main. I added a new flag to make
this possible.
* Change mmp to correctly construct XPC service bundle
* Set the MonoBundleExecutable Info.plist key for XPC services
* Use the runtime to get the protocol
* Make NSXpcInterface.CreateForProtocol() public
The static registrar must be used for Cocoa to accept the protocol
as a valid XPC interface, but that then seems to break resolving
the protocol from the type. I must therefore hard-code the protocol
name in my code, and that requires I make this constructor public.
* Add XpcInterfaceAttribute
See the doc comment in XpcInterfaceAttribute.cs for why
this type is required. The referenced mmp optimizations
will be added in future commits.
* Add XpcInterfaceAttribute to generator build
* Add support for XpcInterfaceAttribute to the generator
* Force static generation of protocols decorated with XpcInterfaceAttribute
* Change how static registrar translates block parameters
Previously, they would always be marshalled as "id".
This would throw off the XPC subsystem, which parses
the block signature to determine the communication
protocol.
* Undo whitespace noise
* Remove unneeded casts
* Add trailing comma
* Use HasAttribute instead of GetCustomAttribute
* Fix style issues
* Bind NSXpcConnection.auditSessionIdentifier
* Address naming feedback
* Make Get/SetAllowedClasses public
IMHO, passing the selector as a string is just as
usable as passing a MethodInfo, and is also less
verbose if you copy/paste the selector string
from the ExportAttribute. There is no reason why
we cannot have both overloads be public.
* Update overload names to match
* Update more overload names to match
* Make mmp --xpc imply --extension
* Reformat if statement
* Fix build
* Conditionalize creation of PlugIns and XPCServices directories
* Add AutoGeneratedName
Co-Authored-By: Rolf Bjarne Kvinge <rolf@xamarin.com>
* Get rid of ProtocolizeAttribute
* Update availability attributes to please xharness
I actually think xharness is wrong here, since the
NSXPCConnection header lists these types as being
available starting in macOS 10.8.
* Update sharpie ignore files to reflect changes
This should fix the xtro-sharpie test failures CI has been reporting.
* Fix MM4105 error generation
* Adjust error message in test to match mmp
I had to change the error text slightly, because the type of the parameter
cannot be determined where the error is thrown anymore. However, the newer
exception message IMO is just as clear.
* Make exception message match test exactly
* Remove outdated copyright header text
* Remove more outdated copyright header text
* Revert changes to MM4105 error generation
I have a more elegant way of fixing this test now.
* Return "id" if Invoke method cannot be found
This fixes the MM4105 error unit test,
without requiring modification to that test.
* Remove redundant availability attributes
* Add DesignatedInitializerAttribute
* Re-add required code to macOS-Foundation.ignore
* Put DesignatedInitializer on the right constructor
* Update xtro-sharpie ignore files
2019-10-22 16:38:01 +03:00
static bool is_extension , is_xpc_service ;
2018-12-06 22:16:10 +03:00
static bool frameworks_copied_to_bundle_dir ; // Have we copied any frameworks to Foo.app/Contents/Frameworks?
static bool dylibs_copied_to_bundle_dir = > native_libraries_copied_in . Count > 0 ;
2016-05-26 00:20:33 +03:00
2016-04-21 15:57:02 +03:00
static void ShowHelp ( OptionSet os ) {
Console . WriteLine ( "mmp - Xamarin.Mac Packer" ) ;
Console . WriteLine ( "Copyright 2010 Novell Inc." ) ;
Console . WriteLine ( "Copyright 2011-2016 Xamarin Inc." ) ;
Console . WriteLine ( "Usage: mmp [options] application-exe" ) ;
os . WriteOptionDescriptions ( Console . Out ) ;
}
2019-05-23 23:59:40 +03:00
public static bool LinkProhibitedFrameworks { get ; private set ; }
2020-04-14 17:32:42 +03:00
public static bool UseLegacyAssemblyResolution { get ; private set ; }
2016-04-21 15:57:02 +03:00
2020-04-14 10:09:55 +03:00
static string mono_prefix ;
static string MonoPrefix {
get {
if ( mono_prefix = = null ) {
mono_prefix = Environment . GetEnvironmentVariable ( "MONO_PREFIX" ) ;
if ( string . IsNullOrEmpty ( mono_prefix ) )
mono_prefix = "/Library/Frameworks/Mono.framework/Versions/Current" ;
}
return mono_prefix ;
}
}
static string PkgConfig {
get {
var pkg_config = Path . Combine ( MonoPrefix , "bin" , "pkg-config" ) ;
if ( ! File . Exists ( pkg_config ) )
throw ErrorHelper . CreateError ( 5313 , Errors . MX5313 , pkg_config ) ;
return pkg_config ;
}
}
2016-12-23 20:50:35 +03:00
public static string GetArch32Directory ( Application app )
{
throw new InvalidOperationException ( "Arch32Directory when not Mobile or Full?" ) ;
2016-12-01 19:18:30 +03:00
}
2016-12-23 20:50:35 +03:00
public static string GetArch64Directory ( Application app )
{
if ( IsUnifiedMobile )
2020-08-06 17:10:06 +03:00
return Path . Combine ( GetFrameworkLibDirectory ( app ) , "x86_64" , "mobile" ) ;
2016-12-23 20:50:35 +03:00
else if ( IsUnifiedFullXamMacFramework )
2020-08-06 17:10:06 +03:00
return Path . Combine ( GetFrameworkLibDirectory ( app ) , "x86_64" , "full" ) ;
2016-12-23 20:50:35 +03:00
throw new InvalidOperationException ( "Arch64Directory when not Mobile or Full?" ) ;
2016-12-01 19:18:30 +03:00
}
2016-04-21 15:57:02 +03:00
public static bool EnableDebug {
get { return App . EnableDebug ; }
}
2020-02-19 00:05:42 +03:00
static int Main2 ( string [ ] args )
2016-04-21 15:57:02 +03:00
{
var os = new OptionSet ( ) {
2020-05-19 16:30:38 +03:00
{ "a|assembly=" , "Add an assembly to be processed [DEPRECATED, use --reference instead]" , v = > App . References . Add ( v ) , true /* Hide: this option is deprecated in favor of the shared --reference option instead */ } ,
2016-04-21 15:57:02 +03:00
{ "r|resource=" , "Add a resource to be included" , v = > resources . Add ( v ) } ,
{ "o|output=" , "Specify the output path" , v = > output_dir = v } ,
{ "n|name=" , "Specify the application name" , v = > app_name = v } ,
{ "s|sgen:" , "Use the SGen Garbage Collector" ,
v = > {
if ( ! ParseBool ( v , "sgen" ) )
2020-01-31 23:02:52 +03:00
ErrorHelper . Warning ( 43 , Errors . MX0043 ) ;
2016-04-21 15:57:02 +03:00
} ,
true // do not show the option anymore
} ,
{ "boehm:" , "Enable the Boehm garbage collector" ,
v = > {
if ( ParseBool ( v , "boehm" ) )
2020-01-31 23:02:52 +03:00
ErrorHelper . Warning ( 43 , Errors . MX0043 ) ; } ,
2016-04-21 15:57:02 +03:00
true // do not show the option anymore
} ,
{ "new-refcount:" , "Enable new refcounting logic" ,
v = > {
if ( ! ParseBool ( v , "new-refcount" ) )
2020-01-31 23:02:52 +03:00
ErrorHelper . Warning ( 80 , Errors . MX0080 ) ;
2016-04-21 15:57:02 +03:00
} ,
true // do not show this option anymore
} ,
2020-05-14 17:45:05 +03:00
{ "mapinject" , "Inject a fast method map [deprecated]" , v = > { ErrorHelper . Show ( new ProductException ( 16 , false , Errors . MX0016 , "--mapinject" ) ) ; } } ,
2020-05-19 16:30:38 +03:00
{ "minos=" , "Minimum supported version of Mac OS X [DEPRECATED, use --targetver instead]" ,
2016-04-21 15:57:02 +03:00
v = > {
try {
2017-11-23 19:16:30 +03:00
App . DeploymentTarget = StringUtils . ParseVersion ( v ) ;
2016-04-21 15:57:02 +03:00
} catch ( Exception ex ) {
2020-05-14 17:45:05 +03:00
throw ErrorHelper . CreateError ( 26 , ex , Errors . MX0026 , $"minos:{v}" , ex . Message ) ;
2016-04-21 15:57:02 +03:00
}
2020-05-19 16:30:38 +03:00
} , true /* Hide: this option is deprecated in favor of the shared --targetver option instead */
2016-04-21 15:57:02 +03:00
} ,
{ "c|certificate=" , "The Code Signing certificate for the application" , v = > { certificate_name = v ; } } ,
{ "p" , "Generate a plist for the application" , v = > { generate_plist = true ; } } ,
{ "i|icon=" , "Use the specified file as the bundle icon" , v = > { icon = v ; } } ,
2018-05-29 20:08:34 +03:00
{ "time" , v = > WatchLevel + + } ,
2020-05-11 17:27:19 +03:00
{ "arch=" , "Specify the architecture ('x86_64') of the native runtime (default to 'x86_64', which is the only valid value) [DEPRECATED, use --abi instead]" , v = > { App . ParseAbi ( v ) ; } , true } ,
[mtouch/mmp] Improve target framework code. (#8137)
* Unify target framework code between mtouch and mmp.
* Simplify the code in mmp: have three possible valid target frameworks for
most of code, and add special code to handle setting any other valid target
frameworks to redirect to one of those three valid target frameworks (and
warn if given any of those valid, but not "main", target frameworks). Any
other code can then depend on the target framework having exactly one of
those specific values, which means we can make IsUnified* variables
convenience properties instead.
* Unify a bit more of the argument parsing code between mtouch and mmp, since
that made a few other things easier.
* Add TargetFramework.IsValidFramework to have one validation implementation.
* Move the implementation of TargetFramework.MonoFrameworkDirectory to mmp
itself, it's not really related to the target framework.
* Remove Driver.IsUnified and IsClassic from mmp, they're not used anymore.
* Formally deprecate --xamarin-[full|system]-framework in mmp, they've really been deprecated for many years.
* Remove LinkerOptions.TargetFramework, it's not used anymore.
* Get rid of mmp's userTargetFramework fried, it's duplicated with the
targetFramework field.
* Add a few tests, and tweak others a bit.
Breaking changes:
* Both mtouch and mmp require --target-framework now. The only direct
consumers should be the MSBuild tasks, which already pass --target-framework
all the time. This simplifies code, and removes assumptions.
2020-03-19 11:28:09 +03:00
{ "profile=" , "(Obsoleted in favor of --target-framework) Specify the .NET profile to use" , v = > SetTargetFramework ( v ) , true } ,
2018-04-30 16:33:48 +03:00
{ "force-thread-check" , "Keep UI thread checks inside (even release) builds [DEPRECATED, use --optimize=-remove-uithread-checks instead]" , v = > { App . Optimizations . RemoveUIThreadChecks = false ; } , true } ,
{ "disable-thread-check" , "Remove UI thread checks inside (even debug) builds [DEPRECATED, use --optimize=remove-uithread-checks instead]" , v = > { App . Optimizations . RemoveUIThreadChecks = true ; } , true } ,
2016-04-21 15:57:02 +03:00
{ "no-root-assembly" , "Specifies that mmp will not process a root assembly. This is if the app needs to be packaged with a different directory structure than what mmp supports." , v = > no_executable = true } ,
{ "embed-mono:" , "Specifies whether the app will embed the Mono runtime, or if it will use the system Mono found at runtime (default: true)." , v = > {
embed_mono = ParseBool ( v , "embed-mono" ) ;
}
} ,
{ "link_flags=" , "Specifies additional arguments to the native linker." ,
2019-10-14 17:18:46 +03:00
v = > {
if ( ! StringUtils . TryParseArguments ( v , out var lf , out var ex ) )
2020-01-31 23:02:52 +03:00
throw ErrorHelper . CreateError ( 26 , ex , Errors . MX0026 , $"-link_flags={v}" , ex . Message ) ;
2019-10-14 17:18:46 +03:00
if ( link_flags = = null )
link_flags = new List < string > ( ) ;
link_flags . AddRange ( lf ) ;
}
2016-04-21 15:57:02 +03:00
} ,
{ "ignore-native-library=" , "Add a native library to be ignored during assembly scanning and packaging" ,
v = > ignored_assemblies . Add ( v )
} ,
{ "native-reference=" , "Add a native (static, dynamic, or framework) library to be included in the bundle. Can be specified multiple times." ,
v = > {
native_references . Add ( v ) ;
if ( v . EndsWith ( ".framework" , true , CultureInfo . InvariantCulture ) )
App . Frameworks . Add ( v ) ;
[msbuild] Simplify resolving xcframeworks (#10376)
TD&LR: This PR simplifies how we refer to user frameworks and fixes both
warnings and non-optimal (app) output.
Much longer story:
Additional testing on macOS showed some build-time warnings and an
[extra (dupe) file](https://github.com/spouliot/xcframework/commit/a20f8aba419e32e2338cb7c5e4b45d0f38862893#diff-54fd7d9cd5deae57f30195be0a43133eace03c1132401741a317e0ae8d5e13fdR34).
Logs shows that we referred to the xcframework several times, where once
should have been enough.
```
/native-reference:/Users/poupou/git/spouliot/xcframework/Universal.xcframework
/native-reference:/Users/poupou/git/spouliot/xcframework/Universal.xcframework/macos-arm64_x86_64/Universal.framework
/native-reference:/Users/poupou/git/spouliot/xcframework/Universal.xcframework/macos-arm64_x86_64/Universal.framework/Universal
```
The first `/native-reference` line produced a warning like:
```
MMP warning MM2006: Native library 'Universal.xcframework' was referenced but could not be found.
```
which makes sense as the tools (both `mmp` and `mtouch`) are not, by
design, aware of (unresolved) xcframeworks.
Removing `{NativeReference}` from `Xamarin.Mac.Common.targets` (and
`Xamarin.iOS.Common.targets`) as it has already been processed by
`_ExpandNativeReferences` solves this.
The other part of the issue (next two lines) is because `msbuild` does
not track changes to directories like it does for files - and the
workaround (in `_ExpandNativeReferences`) had to be copied in other
places (both XI and XM `_CompileToNative`) and that was not enough (and
would eventually need to be duplicated again and again).
This could lead to duplicate entries (i msbuild logs) like
```
NativeReferences
../../Universal.xcframework/macos-arm64_x86_64/Universal.framework
../../Universal.xcframework/macos-arm64_x86_64/Universal.framework/Univeral
```
which maps to our extra entries.
In order to simplify things we make the `_ExpandNativeReferences` resolve
the full path to the library name (not the `.framework` directory) which
simplifies both `_CompileToNative` and ensure a single way (at least for
`msbuild`) to provide this data to the tools (`mmp` and `mtouch`).
Using a file, instead of a directory, is also more consistent for the
existing `-framework` option, e.g. we provide the names like:
```
--framework=CoreLocation
--framework=ModelIO
```
So adding a full path that include the name is more appropriate, e.g.
``` --framework=/Users/poupou/git/master/xamarin-macios/tests/xharness/tmp-test-dir/xcframework-test760/bin/AnyCPU/Debug/bindings-xcframework-test.resources/XTest.xcframework/ios-i386_x86_64-simulator/XTest.framework/XTest
```
Finally for macOS applications it turns out we were embedding yet another
copy of the framework's library inside the `MonoBundle`, which is clearly
wrong, because of the last entry.
```
$ l bin/Release/xcf-mac.app/Contents/MonoBundle/Universal
-rwxr-xr-x 1 poupou staff 167152 2 Dec 16:16 bin/Release/xcf-mac.app/Contents/MonoBundle/Universal
```
The tool now checks if a provided library is inside a framework (or not)
which is a good validation to have anyway when it gets called directly,
i.e. not thru `msbuild`.
2021-01-13 00:02:01 +03:00
else {
// allow specifying the library inside the framework directory
var p = Path . GetDirectoryName ( v ) ;
if ( p . EndsWith ( ".framework" , true , CultureInfo . InvariantCulture ) )
App . Frameworks . Add ( p ) ;
}
2016-04-21 15:57:02 +03:00
}
} ,
2020-05-13 16:35:20 +03:00
{ "custom_bundle_name=" , "Specify a custom name for the MonoBundle folder." , v = > App . CustomBundleName = v , true } , // Hidden hack for "universal binaries"
2016-05-26 00:20:33 +03:00
{ "extension" , "Specifies an app extension" , v = > is_extension = true } ,
Add bindings for NSXpcConnection and related types (#7001)
* Add bindings for NSXpcConnection and related types
* Re-add accidentally deleted file
* Typo fix
* Add NSXpcInterface.CreateForType()
* Add MethodInfo-taking overloads to NSXpcInterface
* Add null check
* Mark methods with wrappers as internal
Also fixed a formatting bug that I didn't catch earlier.
* Change NSXPCProxyCreating methods to be strongly typed
I got rid of the NSXpcProxyCreating interface in this change,
because its only user was NSXpcConnection, and I needed to
inline the protocol methods into the class definition so I
could mark them as [Internal].
* Add missing casts
* Add NSXpcConnectionOptions enum
* Convert NSXpcConnection constructor to use new enum
* Remove now-unneeded manual constructor
* Fix bgen warning
* Typo fix
* Fix selector
* Remove incorrect use of BindAsAttribute
Per the docs, this only works for enums backed
by NSNumber and NSValue, not for enums
passed directly as integers.
* Fix duplicated selector errors
* Throw ArgumentException instead of InvalidOperationException
* Extend AppExtension targets to produce XPC services
Rather than create an entirely new set of targets
(that would require VS and VSMac updates to properly
consume), I have decided to use the existing AppExtension
build targets to produce XPC services as well. All the
user must do is set the $(IsXPCService) property to true in
their project file, and the targets will do The Right Thing™.
Note that this support is Mac-only for now; I may need a bit
of help adjusting them to work on for iOS/watchOS/tvOS, as I
am not as familiar with those platforms.
* Copy XPC service bundles into the correct location
* Move IsXPCService property definition to props file
* Don't pass /extension to mmp for XPC service targets
This would cause the XPC service binary to
be linked incorrectly.
* Add NSXpcConnection/NSXpcInterface.cs files to the build
* Fix build
* Fix build
* Add required type parameter requirements
* Fix type parameter requirements
* Fix return type
* Fix return type of NSXpcInterface.CreateForProtocol ()
* Take ownership of the returned object types
* Adjust XPC service mmp invocation
I need to link the XPC service bundle as if it is an app extension, but
I must not use xamarin_mac_extension_main. I added a new flag to make
this possible.
* Change mmp to correctly construct XPC service bundle
* Set the MonoBundleExecutable Info.plist key for XPC services
* Use the runtime to get the protocol
* Make NSXpcInterface.CreateForProtocol() public
The static registrar must be used for Cocoa to accept the protocol
as a valid XPC interface, but that then seems to break resolving
the protocol from the type. I must therefore hard-code the protocol
name in my code, and that requires I make this constructor public.
* Add XpcInterfaceAttribute
See the doc comment in XpcInterfaceAttribute.cs for why
this type is required. The referenced mmp optimizations
will be added in future commits.
* Add XpcInterfaceAttribute to generator build
* Add support for XpcInterfaceAttribute to the generator
* Force static generation of protocols decorated with XpcInterfaceAttribute
* Change how static registrar translates block parameters
Previously, they would always be marshalled as "id".
This would throw off the XPC subsystem, which parses
the block signature to determine the communication
protocol.
* Undo whitespace noise
* Remove unneeded casts
* Add trailing comma
* Use HasAttribute instead of GetCustomAttribute
* Fix style issues
* Bind NSXpcConnection.auditSessionIdentifier
* Address naming feedback
* Make Get/SetAllowedClasses public
IMHO, passing the selector as a string is just as
usable as passing a MethodInfo, and is also less
verbose if you copy/paste the selector string
from the ExportAttribute. There is no reason why
we cannot have both overloads be public.
* Update overload names to match
* Update more overload names to match
* Make mmp --xpc imply --extension
* Reformat if statement
* Fix build
* Conditionalize creation of PlugIns and XPCServices directories
* Add AutoGeneratedName
Co-Authored-By: Rolf Bjarne Kvinge <rolf@xamarin.com>
* Get rid of ProtocolizeAttribute
* Update availability attributes to please xharness
I actually think xharness is wrong here, since the
NSXPCConnection header lists these types as being
available starting in macOS 10.8.
* Update sharpie ignore files to reflect changes
This should fix the xtro-sharpie test failures CI has been reporting.
* Fix MM4105 error generation
* Adjust error message in test to match mmp
I had to change the error text slightly, because the type of the parameter
cannot be determined where the error is thrown anymore. However, the newer
exception message IMO is just as clear.
* Make exception message match test exactly
* Remove outdated copyright header text
* Remove more outdated copyright header text
* Revert changes to MM4105 error generation
I have a more elegant way of fixing this test now.
* Return "id" if Invoke method cannot be found
This fixes the MM4105 error unit test,
without requiring modification to that test.
* Remove redundant availability attributes
* Add DesignatedInitializerAttribute
* Re-add required code to macOS-Foundation.ignore
* Put DesignatedInitializer on the right constructor
* Update xtro-sharpie ignore files
2019-10-22 16:38:01 +03:00
{ "xpc" , "Specifies an XPC service" , v = > { is_extension = true ; is_xpc_service = true ; } } ,
2016-06-08 19:47:09 +03:00
{ "allow-unsafe-gac-resolution" , "Allow MSBuild to resolve from the System GAC" , v = > { } , true } , // Used in Xamarin.Mac.XM45.targets and must be ignored here. Hidden since it is a total hack. If you can use it, you don't need support
2017-08-09 17:39:04 +03:00
{ "force-unsupported-linker" , "Bypass safety checkes preventing unsupported linking options." , v = > bypass_linking_checks = true , true } , // Undocumented option for a reason, You get to keep the pieces when it breaks
2020-05-13 16:35:20 +03:00
{ "disable-lldb-attach=" , "Disable automatic lldb attach on crash" , v = > App . DisableLldbAttach = ParseBool ( v , "disable-lldb-attach" ) } ,
{ "disable-omit-fp=" , "Disable a JIT optimization where the frame pointer is omitted from the stack. This is optimization is disabled by default for debug builds." , v = > App . DisableOmitFramePointer = ParseBool ( v , "disable-omit-fp" ) } ,
2016-10-13 18:42:05 +03:00
{ "machine-config=" , "Custom machine.config file to copy into MonoBundle/mono/4.5/machine.config. Pass \"\" to copy in a valid \"empty\" config file." , v = > machine_config_path = v } ,
2020-02-19 17:23:52 +03:00
{ "xamarin-framework-directory=" , "The framework directory" , v = > { framework_dir = v ; } , true } ,
[mtouch/mmp] Improve target framework code. (#8137)
* Unify target framework code between mtouch and mmp.
* Simplify the code in mmp: have three possible valid target frameworks for
most of code, and add special code to handle setting any other valid target
frameworks to redirect to one of those three valid target frameworks (and
warn if given any of those valid, but not "main", target frameworks). Any
other code can then depend on the target framework having exactly one of
those specific values, which means we can make IsUnified* variables
convenience properties instead.
* Unify a bit more of the argument parsing code between mtouch and mmp, since
that made a few other things easier.
* Add TargetFramework.IsValidFramework to have one validation implementation.
* Move the implementation of TargetFramework.MonoFrameworkDirectory to mmp
itself, it's not really related to the target framework.
* Remove Driver.IsUnified and IsClassic from mmp, they're not used anymore.
* Formally deprecate --xamarin-[full|system]-framework in mmp, they've really been deprecated for many years.
* Remove LinkerOptions.TargetFramework, it's not used anymore.
* Get rid of mmp's userTargetFramework fried, it's duplicated with the
targetFramework field.
* Add a few tests, and tweak others a bit.
Breaking changes:
* Both mtouch and mmp require --target-framework now. The only direct
consumers should be the MSBuild tasks, which already pass --target-framework
all the time. This simplifies code, and removes assumptions.
2020-03-19 11:28:09 +03:00
{ "xamarin-full-framework" , "Used with --target-framework=4.5 to select XM Full Target Framework. Deprecated, use --target-framework=Xamarin.Mac,Version=v4.0,Profile=Full instead." , v = > { TargetFramework = TargetFramework . Xamarin_Mac_4_5_Full ; } , true } ,
{ "xamarin-system-framework" , "Used with --target-framework=4.5 to select XM Full Target Framework. Deprecated, use --target-framework=Xamarin.Mac,Version=v4.0,Profile=System instead." , v = > { TargetFramework = TargetFramework . Xamarin_Mac_4_5_System ; } , true } ,
2017-10-20 23:42:14 +03:00
{ "aot:" , "Specify assemblies that should be AOT compiled\n- none - No AOT (default)\n- all - Every assembly in MonoBundle\n- core - Xamarin.Mac, System, mscorlib\n- sdk - Xamarin.Mac.dll and BCL assemblies\n- |hybrid after option enables hybrid AOT which allows IL stripping but is slower (only valid for 'all')\n - Individual files can be included for AOT via +FileName.dll and excluded via -FileName.dll\n\nExamples:\n --aot:all,-MyAssembly.dll\n --aot:core,+MyOtherAssembly.dll,-mscorlib.dll" ,
2017-01-11 23:10:39 +03:00
v = > {
2020-05-13 16:35:20 +03:00
App . AOTOptions = new AOTOptions ( v ) ;
2017-01-11 23:10:39 +03:00
}
} ,
2019-05-23 23:59:40 +03:00
{ "link-prohibited-frameworks" , "Natively link against prohibited (rejected by AppStore) frameworks" , v = > { LinkProhibitedFrameworks = true ; } } ,
2020-04-14 17:32:42 +03:00
{ "legacy-assembly-resolution" , "Use a legacy assembly resolution logic when using the Xamarin.Mac Full framework." , v = > { UseLegacyAssemblyResolution = true ; } , false /* hidden until we know if it's needed */ } ,
2020-05-19 16:30:38 +03:00
/* Any new options that are identical between mtouch and mmp should be added to common/Driver.cs */
2016-04-21 15:57:02 +03:00
} ;
2019-12-20 18:27:36 +03:00
var extra_args = Environment . GetEnvironmentVariable ( "MMP_ENV_OPTIONS" ) ;
if ( ! string . IsNullOrEmpty ( extra_args ) ) {
var l = new List < string > ( args ) ;
l . AddRange ( extra_args . Split ( new char [ ] { ' ' } , StringSplitOptions . RemoveEmptyEntries ) ) ;
args = l . ToArray ( ) ;
}
[mtouch/mmp] Improve target framework code. (#8137)
* Unify target framework code between mtouch and mmp.
* Simplify the code in mmp: have three possible valid target frameworks for
most of code, and add special code to handle setting any other valid target
frameworks to redirect to one of those three valid target frameworks (and
warn if given any of those valid, but not "main", target frameworks). Any
other code can then depend on the target framework having exactly one of
those specific values, which means we can make IsUnified* variables
convenience properties instead.
* Unify a bit more of the argument parsing code between mtouch and mmp, since
that made a few other things easier.
* Add TargetFramework.IsValidFramework to have one validation implementation.
* Move the implementation of TargetFramework.MonoFrameworkDirectory to mmp
itself, it's not really related to the target framework.
* Remove Driver.IsUnified and IsClassic from mmp, they're not used anymore.
* Formally deprecate --xamarin-[full|system]-framework in mmp, they've really been deprecated for many years.
* Remove LinkerOptions.TargetFramework, it's not used anymore.
* Get rid of mmp's userTargetFramework fried, it's duplicated with the
targetFramework field.
* Add a few tests, and tweak others a bit.
Breaking changes:
* Both mtouch and mmp require --target-framework now. The only direct
consumers should be the MSBuild tasks, which already pass --target-framework
all the time. This simplifies code, and removes assumptions.
2020-03-19 11:28:09 +03:00
if ( ParseOptions ( App , os , args , ref action ) )
return 0 ;
2017-11-16 18:02:34 +03:00
2020-05-13 16:35:20 +03:00
if ( App . AOTOptions = = null ) {
2017-02-08 22:40:48 +03:00
string forceAotVariable = Environment . GetEnvironmentVariable ( "XM_FORCE_AOT" ) ;
if ( forceAotVariable ! = null )
2020-05-13 16:35:20 +03:00
App . AOTOptions = new AOTOptions ( forceAotVariable ) ;
2017-02-08 22:40:48 +03:00
}
2019-07-24 19:01:14 +03:00
if ( IsUnifiedFullSystemFramework ) {
2016-04-21 15:57:02 +03:00
// With newer Mono builds, the system assemblies passed to us by msbuild are
// no longer safe to copy into the bundle. They are stripped "fake" BCL
// copies. So we redirect to the "real" ones. Thanks TargetFrameworkDirectories :(
Regex monoAPIRegex = new Regex ( "lib/mono/.*-api/" , RegexOptions . IgnoreCase ) ;
Regex monoAPIFacadesRegex = new Regex ( "lib/mono/.*-api/Facades/" , RegexOptions . IgnoreCase ) ;
FixReferences ( x = > monoAPIRegex . IsMatch ( x ) & & ! monoAPIFacadesRegex . IsMatch ( x ) , x = > x . Replace ( monoAPIRegex . Match ( x ) . Value , "lib/mono/4.5/" ) ) ;
}
2020-05-13 16:35:20 +03:00
if ( App . Registrar = = RegistrarMode . PartialStatic & & App . LinkMode ! = LinkMode . None )
2020-05-14 17:45:05 +03:00
throw new ProductException ( 2110 , true , Errors . MM2110 ) ;
2018-10-05 17:43:53 +03:00
2016-04-21 15:57:02 +03:00
// sanity check as this should never happen: we start out by not setting any
// Unified/Classic properties, and only IsUnifiedMobile if we are are on the
// XM framework. If we are not, we set IsUnifiedFull to true iff we detect
// an explicit reference to the full unified Xamarin.Mac assembly; that is
// only one of IsUnifiedMobile or IsUnifiedFull should ever be true. IsUnified
// is true if one of IsUnifiedMobile or IsUnifiedFull is true; IsClassic is
// implied if IsUnified is not true;
2020-07-23 17:52:15 +03:00
// Skip this check if we're in .NET 5 mode (which happens when generating the partial static registrar code).
if ( ! TargetFramework . IsDotNet ) {
int IsUnifiedCount = IsUnifiedMobile ? 1 : 0 ;
if ( IsUnifiedFullSystemFramework )
IsUnifiedCount + + ;
if ( IsUnifiedFullXamMacFramework )
IsUnifiedCount + + ;
if ( IsUnifiedCount ! = 1 )
throw ErrorHelper . CreateError ( 99 , Errors . MX0099 , "IsClassic/IsUnified/IsUnifiedMobile/IsUnifiedFullSystemFramework/IsUnifiedFullXamMacFramework logic regression" ) ;
}
2016-04-21 15:57:02 +03:00
2017-05-30 17:23:28 +03:00
ValidateXamarinMacReference ( ) ;
2017-08-09 17:39:04 +03:00
if ( ! bypass_linking_checks & & ( IsUnifiedFullSystemFramework | | IsUnifiedFullXamMacFramework ) ) {
2017-05-17 01:05:26 +03:00
switch ( App . LinkMode ) {
case LinkMode . None :
case LinkMode . Platform :
break ;
default :
2020-05-14 17:45:05 +03:00
throw new ProductException ( 2007 , true , Errors . MM2007 ) ;
2017-05-17 01:05:26 +03:00
}
}
2016-04-21 15:57:02 +03:00
2020-08-06 17:10:06 +03:00
ValidateXcode ( App , false , true ) ;
2016-12-01 19:18:30 +03:00
2017-04-05 22:38:40 +03:00
App . Initialize ( ) ;
2017-09-29 20:45:53 +03:00
// InitializeCommon needs SdkVersion set to something valid
ValidateSDKVersion ( ) ;
2018-03-02 16:30:18 +03:00
// InitializeCommon needs the current profile
2019-07-24 19:01:14 +03:00
if ( IsUnifiedFullXamMacFramework | | IsUnifiedFullSystemFramework )
Profile . Current = new XamarinMacProfile ( ) ;
2018-03-02 16:30:18 +03:00
else
2019-07-24 19:01:14 +03:00
Profile . Current = new MacMobileProfile ( ) ;
2018-03-02 16:30:18 +03:00
2019-04-25 19:08:10 +03:00
BuildTarget = new Target ( App ) ;
2019-05-09 22:36:42 +03:00
App . Targets . Add ( BuildTarget ) ;
2016-05-11 13:24:55 +03:00
App . InitializeCommon ( ) ;
2018-09-14 20:12:59 +03:00
Log ( "Xamarin.Mac {0}.{1}" , Constants . Version , Constants . Revision ) ;
2020-02-18 23:44:19 +03:00
Log ( 1 , "Selected target framework: {0}; API: Unified" , targetFramework ) ;
2018-08-13 21:09:31 +03:00
Log ( 1 , $"Selected Linking: '{App.LinkMode}'" ) ;
2016-12-13 21:12:03 +03:00
2016-12-01 19:18:30 +03:00
if ( action = = Action . RunRegistrar ) {
App . Registrar = RegistrarMode . Static ;
App . RunRegistrar ( ) ;
2020-02-19 00:05:42 +03:00
return 0 ;
2016-12-01 19:18:30 +03:00
}
2016-04-21 15:57:02 +03:00
try {
2017-11-16 18:02:34 +03:00
Pack ( App . RootAssemblies ) ;
2016-04-21 15:57:02 +03:00
} finally {
2017-01-03 17:14:47 +03:00
if ( App . Cache . IsCacheTemporary ) {
2016-04-21 15:57:02 +03:00
// 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 {
2017-01-03 17:14:47 +03:00
Directory . Delete ( App . Cache . Location , true ) ;
2016-04-21 15:57:02 +03:00
} 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.
2020-11-10 19:20:23 +03:00
App . Cache . ValidateCache ( App ) ;
2016-04-21 15:57:02 +03:00
}
}
Log ( "bundling complete" ) ;
2020-02-19 00:05:42 +03:00
return 0 ;
2016-04-21 15:57:02 +03:00
}
2017-05-30 17:23:28 +03:00
static void ValidateXamarinMacReference ( )
{
// Many Xamarin.Mac references are technically valid, so whitelisting risks breaking working project
// However, passing in Mobile / Xamarin.Mac folders and resolving full/4.5 or vice versa is
// far from expected. So catch the common cases if we can
2020-05-05 16:35:02 +03:00
string reference = App . References . FirstOrDefault ( x = > x . EndsWith ( "Xamarin.Mac.dll" , StringComparison . Ordinal ) ) ;
2017-05-30 17:23:28 +03:00
if ( reference ! = null ) {
bool valid = true ;
if ( IsUnifiedMobile )
valid = ! reference . Contains ( "full/" ) & & ! reference . Contains ( "4.5/" ) ;
else if ( IsUnifiedFullXamMacFramework | | IsUnifiedFullSystemFramework )
valid = ! reference . Contains ( "mobile/" ) & & ! reference . Contains ( "Xamarin.Mac/" ) ;
if ( ! valid )
2020-01-31 23:02:52 +03:00
throw ErrorHelper . CreateError ( 1407 , Errors . MM1407 , reference , TargetFramework ) ;
2017-05-30 17:23:28 +03:00
}
}
2016-04-21 15:57:02 +03:00
static void FixReferences ( Func < string , bool > match , Func < string , string > fix )
{
2020-05-05 16:35:02 +03:00
for ( var i = 0 ; i < App . References . Count ; i + + ) {
if ( match ( App . References [ i ] ) )
App . References [ i ] = fix ( App . References [ i ] ) ;
}
2016-04-21 15:57:02 +03:00
}
2016-12-13 21:12:03 +03:00
// SDK versions are only passed in as X.Y but some frameworks/APIs require X.Y.Z
// Mutate them if we have a new enough Xcode
static Version MutateSDKVersionToPointRelease ( Version rv )
{
if ( rv . Major = = 10 & & ( rv . Revision = = 0 | | rv . Revision = = - 1 ) ) {
2020-03-06 03:48:28 +03:00
if ( rv . Minor = = 15 & & XcodeVersion > = new Version ( 11 , 4 ) )
return new Version ( rv . Major , rv . Minor , 4 ) ;
2018-02-27 14:53:13 +03:00
if ( rv . Minor = = 13 & & XcodeVersion > = new Version ( 9 , 3 ) )
return new Version ( rv . Major , rv . Minor , 4 ) ;
2017-11-28 23:29:05 +03:00
if ( rv . Minor = = 13 & & XcodeVersion > = new Version ( 9 , 2 ) )
return new Version ( rv . Major , rv . Minor , 2 ) ;
2018-02-27 14:53:13 +03:00
if ( rv . Minor = = 13 & & XcodeVersion > = new Version ( 9 , 1 ) )
return new Version ( rv . Major , rv . Minor , 1 ) ;
2017-02-24 11:17:03 +03:00
if ( rv . Minor = = 12 & & XcodeVersion > = new Version ( 8 , 3 ) )
return new Version ( rv . Major , rv . Minor , 4 ) ;
2016-12-13 21:12:03 +03:00
if ( rv . Minor = = 12 & & XcodeVersion > = new Version ( 8 , 2 ) )
return new Version ( rv . Major , rv . Minor , 2 ) ;
if ( rv . Minor = = 12 & & XcodeVersion > = new Version ( 8 , 1 ) )
return new Version ( rv . Major , rv . Minor , 1 ) ;
if ( rv . Minor = = 11 & & XcodeVersion > = new Version ( 7 , 3 ) )
return new Version ( rv . Major , rv . Minor , 4 ) ;
}
2018-07-02 14:45:34 +03:00
// Since Version has wrong behavior:
// new Version (10, 14) < new Version (10, 14, 0) => true
// Force any unset revision to 0 instead of -1
if ( rv . Revision = = - 1 )
return new Version ( rv . Major , rv . Minor , 0 ) ;
2016-12-13 21:12:03 +03:00
return rv ;
}
// Validates that sdk_version is set to a reasonable value before compile
static void ValidateSDKVersion ( )
2016-04-21 15:57:02 +03:00
{
2016-12-23 20:50:35 +03:00
if ( App . SdkVersion ! = null ) {
2016-12-13 21:12:03 +03:00
// We can't do mutation while parsing command line args as XcodeVersion isn't set yet
2016-12-23 20:50:35 +03:00
App . SdkVersion = MutateSDKVersionToPointRelease ( App . SdkVersion ) ;
2016-04-21 15:57:02 +03:00
return ;
2016-12-13 21:12:03 +03:00
}
2016-04-21 15:57:02 +03:00
if ( string . IsNullOrEmpty ( DeveloperDirectory ) )
return ;
var sdks = new List < Version > ( ) ;
var sdkdir = Path . Combine ( DeveloperDirectory , "Platforms" , "MacOSX.platform" , "Developer" , "SDKs" ) ;
foreach ( var sdkpath in Directory . GetDirectories ( sdkdir ) ) {
var sdk = Path . GetFileName ( sdkpath ) ;
2016-10-20 16:34:26 +03:00
if ( sdk . StartsWith ( "MacOSX" , StringComparison . Ordinal ) & & sdk . EndsWith ( ".sdk" , StringComparison . Ordinal ) ) {
2016-04-21 15:57:02 +03:00
Version sdkVersion ;
if ( Version . TryParse ( sdk . Substring ( 6 , sdk . Length - 10 ) , out sdkVersion ) )
sdks . Add ( sdkVersion ) ;
}
}
if ( sdks . Count > 0 ) {
sdks . Sort ( ) ;
// select the highest.
2016-12-23 20:50:35 +03:00
App . SdkVersion = MutateSDKVersionToPointRelease ( sdks [ sdks . Count - 1 ] ) ;
2016-04-21 15:57:02 +03:00
}
}
static void CheckForUnknownCommandLineArguments ( IList < Exception > exceptions , IList < string > arguments )
{
for ( int i = arguments . Count - 1 ; i > = 0 ; i - - ) {
2016-10-20 16:34:26 +03:00
if ( arguments [ i ] . StartsWith ( "-" , StringComparison . Ordinal ) ) {
2020-01-31 23:02:52 +03:00
exceptions . Add ( ErrorHelper . CreateError ( 18 , Errors . MX0018 , arguments [ i ] ) ) ;
2016-04-21 15:57:02 +03:00
arguments . RemoveAt ( i ) ;
}
}
}
2018-02-12 16:42:19 +03:00
public static void SelectRegistrar ( )
2016-04-21 15:57:02 +03:00
{
2020-05-13 16:35:20 +03:00
if ( App . Registrar = = RegistrarMode . Default ) {
2016-12-05 23:16:03 +03:00
if ( ! App . EnableDebug )
2020-05-13 16:35:20 +03:00
App . Registrar = RegistrarMode . Static ;
2019-07-24 19:01:14 +03:00
else if ( App . LinkMode = = LinkMode . None & & embed_mono & & App . IsDefaultMarshalManagedExceptionMode & & File . Exists ( PartialStaticLibrary ) )
2020-05-13 16:35:20 +03:00
App . Registrar = RegistrarMode . PartialStatic ;
2016-12-05 23:16:03 +03:00
else
2020-05-13 16:35:20 +03:00
App . Registrar = RegistrarMode . Dynamic ;
Log ( 1 , $"Defaulting registrar to '{App.Registrar}'" ) ;
2016-12-05 23:16:03 +03:00
}
2018-02-12 16:42:19 +03:00
}
static void Pack ( IList < string > unprocessed )
{
string fx_dir = null ;
string root_assembly = null ;
var native_libs = new Dictionary < string , List < MethodDefinition > > ( ) ;
2016-04-21 15:57:02 +03:00
if ( no_executable ) {
if ( unprocessed . Count ! = 0 ) {
var exceptions = new List < Exception > ( ) ;
CheckForUnknownCommandLineArguments ( exceptions , unprocessed ) ;
2020-05-14 17:45:05 +03:00
exceptions . Add ( new ProductException ( 50 , true , Errors . MM0050 , unprocessed . Count , string . Join ( "', '" , unprocessed . ToArray ( ) ) ) ) ;
2016-04-21 15:57:02 +03:00
throw new AggregateException ( exceptions ) ;
}
if ( string . IsNullOrEmpty ( output_dir ) )
2020-05-14 17:45:05 +03:00
throw new ProductException ( 51 , true , Errors . MM0051 ) ;
2016-04-21 15:57:02 +03:00
if ( string . IsNullOrEmpty ( app_name ) )
app_name = Path . GetFileNameWithoutExtension ( output_dir ) ;
} else {
if ( unprocessed . Count ! = 1 ) {
var exceptions = new List < Exception > ( ) ;
CheckForUnknownCommandLineArguments ( exceptions , unprocessed ) ;
if ( unprocessed . Count > 1 ) {
2020-01-31 23:02:52 +03:00
exceptions . Add ( ErrorHelper . CreateError ( 8 , Errors . MM0008 , unprocessed . Count , string . Join ( "', '" , unprocessed . ToArray ( ) ) ) ) ;
2016-04-21 15:57:02 +03:00
} else if ( unprocessed . Count = = 0 ) {
2020-01-31 23:02:52 +03:00
exceptions . Add ( ErrorHelper . CreateError ( 17 , Errors . MX0017 ) ) ;
2016-04-21 15:57:02 +03:00
}
throw new AggregateException ( exceptions ) ;
}
root_assembly = unprocessed [ 0 ] ;
if ( ! File . Exists ( root_assembly ) )
2020-05-14 17:45:05 +03:00
throw new ProductException ( 7 , true , Errors . MX0007 , root_assembly ) ;
2018-03-02 16:30:18 +03:00
2016-04-21 15:57:02 +03:00
string root_wo_ext = Path . GetFileNameWithoutExtension ( root_assembly ) ;
if ( Profile . IsSdkAssembly ( root_wo_ext ) | | Profile . IsProductAssembly ( root_wo_ext ) )
2020-05-14 17:45:05 +03:00
throw new ProductException ( 3 , true , Errors . MX0003 , root_wo_ext ) ;
2016-04-21 15:57:02 +03:00
2020-05-05 16:35:02 +03:00
if ( App . References . Exists ( a = > Path . GetFileNameWithoutExtension ( a ) . Equals ( root_wo_ext ) ) )
2020-05-14 17:45:05 +03:00
throw new ProductException ( 23 , true , Errors . MM0023 , root_wo_ext ) ;
2016-04-21 15:57:02 +03:00
2020-05-25 10:34:22 +03:00
fx_dir = GetPlatformFrameworkDirectory ( App ) ;
2016-04-21 15:57:02 +03:00
if ( ! Directory . Exists ( fx_dir ) )
2020-05-14 17:45:05 +03:00
throw new ProductException ( 1403 , true , Errors . MM1403 , "Directory" , fx_dir , TargetFramework ) ;
2016-04-21 15:57:02 +03:00
2020-05-05 16:35:02 +03:00
App . References . Add ( root_assembly ) ;
BuildTarget . Resolver . CommandLineAssemblies = App . References ;
2021-04-22 15:47:47 +03:00
BuildTarget . Resolver . Configure ( ) ;
2020-04-14 17:32:42 +03:00
2016-04-21 15:57:02 +03:00
if ( string . IsNullOrEmpty ( app_name ) )
app_name = root_wo_ext ;
if ( string . IsNullOrEmpty ( output_dir ) )
output_dir = Environment . CurrentDirectory ;
}
CreateDirectoriesIfNeeded ( ) ;
2019-02-11 19:29:13 +03:00
2020-05-11 17:27:19 +03:00
App . SetDefaultAbi ( ) ;
App . ValidateAbi ( ) ;
BuildTarget . Abis = App . Abis . ToList ( ) ;
2019-02-11 19:29:13 +03:00
2016-04-21 15:57:02 +03:00
Watch ( "Setup" , 1 ) ;
if ( ! no_executable ) {
BuildTarget . Resolver . FrameworkDirectory = fx_dir ;
BuildTarget . Resolver . RootDirectory = Path . GetDirectoryName ( Path . GetFullPath ( root_assembly ) ) ;
GatherAssemblies ( ) ;
CheckReferences ( ) ;
2017-04-28 19:09:03 +03:00
if ( ! is_extension & & ! resolved_assemblies . Exists ( f = > Path . GetExtension ( f ) . ToLower ( ) = = ".exe" ) & & ! App . Embeddinator )
2020-05-14 17:45:05 +03:00
throw new ProductException ( 79 , true , Errors . MM0079 , "" ) ;
2016-04-21 15:57:02 +03:00
// i18n must be dealed outside linking too (e.g. bug 11448)
if ( App . LinkMode = = LinkMode . None )
CopyI18nAssemblies ( App . I18n ) ;
CopyAssemblies ( ) ;
Watch ( "Copy Assemblies" , 1 ) ;
}
CopyResources ( ) ;
Watch ( "Copy Resources" , 1 ) ;
CopyConfiguration ( ) ;
Watch ( "Copy Configuration" , 1 ) ;
ExtractNativeLinkInfo ( ) ;
2017-11-16 18:18:18 +03:00
BuildTarget . ValidateAssembliesBeforeLink ( ) ;
2016-04-21 15:57:02 +03:00
if ( ! no_executable ) {
foreach ( var nr in native_references ) {
if ( ! native_libs . ContainsKey ( nr ) )
native_libs . Add ( nr , null ) ;
}
var linked_native_libs = Link ( ) ;
foreach ( var kvp in linked_native_libs ) {
List < MethodDefinition > methods ;
2016-11-23 23:00:01 +03:00
if ( native_libs . TryGetValue ( kvp . Key , out methods ) ) {
if ( methods = = null ) {
methods = new List < MethodDefinition > ( ) ;
native_libs [ kvp . Key ] = methods ;
}
2016-04-21 15:57:02 +03:00
methods . AddRange ( kvp . Value ) ;
2016-11-23 23:00:01 +03:00
}
else {
2016-04-21 15:57:02 +03:00
native_libs . Add ( kvp . Key , kvp . Value ) ;
2016-11-23 23:00:01 +03:00
}
2016-04-21 15:57:02 +03:00
}
Watch ( string . Format ( "Linking (mode: '{0}')" , App . LinkMode ) , 1 ) ;
}
[mtouch] Improve how we make sure native symbols aren't stripped away. Fixes #51710 and #54417. (#2162)
* [mtouch] Improve how we make sure native symbols aren't stripped away. Fixes #51710 and #54417.
* Refactor required symbol collection to store more information about each
symbol (field, function, Objective-C class), and in general make the code
more straight forward.
* Implement support for generating source code that references these symbols,
and do this whenever we can't ask the native linker to keep these symbols
(when using bitcode). Additionally make it possible to do this manually, so
that the source code can be generated for non-bitcode platforms too (which
is useful if the number of symbols is enormous, in which case we might
surpass the maximum command-line length).
* Also make it possible to completely ignore native symbols, or ignore them on
a per-symbol basis. This provides a fallback for users if we get something
right and we try to preserve something that shouldn't be preserved (for
instance if it doesn't exist), and the user ends up with unfixable linker
errors.
* Don't collect Objective-C classes unless they're in an assembly with
LinkWith attributes. We don't need to preserve Objective-C classes in any
other circumstances.
* Implement everything for both Xamarin.iOS and Xamarin.Mac, and share the
code between them.
* Remove previous workaround for bug #51710, since it's no longer needed.
* Add tests.
https://bugzilla.xamarin.com/show_bug.cgi?id=54417
https://bugzilla.xamarin.com/show_bug.cgi?id=51710
* [mtouch] Make sure to only keep symbols from the current app when code sharing.
This fixes a build problem with the interdependent-binding-projects test when
testing in Today Extension mode.
2017-06-02 19:29:19 +03:00
2017-04-05 22:38:40 +03:00
// These must occur _after_ Linking
[mtouch] Improve how we make sure native symbols aren't stripped away. Fixes #51710 and #54417. (#2162)
* [mtouch] Improve how we make sure native symbols aren't stripped away. Fixes #51710 and #54417.
* Refactor required symbol collection to store more information about each
symbol (field, function, Objective-C class), and in general make the code
more straight forward.
* Implement support for generating source code that references these symbols,
and do this whenever we can't ask the native linker to keep these symbols
(when using bitcode). Additionally make it possible to do this manually, so
that the source code can be generated for non-bitcode platforms too (which
is useful if the number of symbols is enormous, in which case we might
surpass the maximum command-line length).
* Also make it possible to completely ignore native symbols, or ignore them on
a per-symbol basis. This provides a fallback for users if we get something
right and we try to preserve something that shouldn't be preserved (for
instance if it doesn't exist), and the user ends up with unfixable linker
errors.
* Don't collect Objective-C classes unless they're in an assembly with
LinkWith attributes. We don't need to preserve Objective-C classes in any
other circumstances.
* Implement everything for both Xamarin.iOS and Xamarin.Mac, and share the
code between them.
* Remove previous workaround for bug #51710, since it's no longer needed.
* Add tests.
https://bugzilla.xamarin.com/show_bug.cgi?id=54417
https://bugzilla.xamarin.com/show_bug.cgi?id=51710
* [mtouch] Make sure to only keep symbols from the current app when code sharing.
This fixes a build problem with the interdependent-binding-projects test when
testing in Today Extension mode.
2017-06-02 19:29:19 +03:00
BuildTarget . CollectAllSymbols ( ) ;
2017-04-05 22:38:40 +03:00
BuildTarget . ComputeLinkerFlags ( ) ;
BuildTarget . GatherFrameworks ( ) ;
2016-04-21 15:57:02 +03:00
2018-10-15 22:39:29 +03:00
CopyMonoNative ( ) ;
2016-04-21 15:57:02 +03:00
CopyDependencies ( native_libs ) ;
Watch ( "Copy Dependencies" , 1 ) ;
// MDK check
2020-03-17 17:49:39 +03:00
Compile ( ) ;
2016-04-21 15:57:02 +03:00
Watch ( "Compile" , 1 ) ;
2020-03-17 17:49:39 +03:00
2016-04-21 15:57:02 +03:00
if ( generate_plist )
GeneratePList ( ) ;
2020-08-24 18:50:42 +03:00
if ( App . LinkMode ! = LinkMode . Full & & App . RuntimeOptions ! = null )
2017-05-08 18:58:21 +03:00
App . RuntimeOptions . Write ( resources_dir ) ;
2016-04-21 15:57:02 +03:00
2020-05-13 16:35:20 +03:00
if ( App . AOTOptions ! = null & & App . AOTOptions . IsAOT ) {
2017-02-08 22:40:48 +03:00
AOTCompilerType compilerType ;
2017-01-11 23:10:39 +03:00
if ( IsUnifiedMobile | | IsUnifiedFullXamMacFramework )
2019-07-24 19:01:14 +03:00
compilerType = AOTCompilerType . Bundled64 ;
2017-01-11 23:10:39 +03:00
else if ( IsUnifiedFullSystemFramework )
2019-07-24 19:01:14 +03:00
compilerType = AOTCompilerType . System64 ;
2017-01-11 23:10:39 +03:00
else
2020-01-31 23:02:52 +03:00
throw ErrorHelper . CreateError ( 0099 , Errors . MX0099 , "\"AOT with unexpected profile.\"" ) ;
2017-01-11 23:10:39 +03:00
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
AOTCompiler compiler = new AOTCompiler ( App . AOTOptions , App . Abis , compilerType , IsUnifiedMobile , ! EnableDebug ) ;
2017-02-08 22:40:48 +03:00
compiler . Compile ( mmp_dir ) ;
2017-01-11 23:10:39 +03:00
Watch ( "AOT Compile" , 1 ) ;
}
2016-04-21 15:57:02 +03:00
if ( ! string . IsNullOrEmpty ( certificate_name ) ) {
CodeSign ( ) ;
Watch ( "Code Sign" , 1 ) ;
}
}
2018-10-15 22:39:29 +03:00
static void CopyMonoNative ( )
{
string name ;
2020-04-16 15:19:45 +03:00
if ( File . Exists ( Path . Combine ( GetMonoLibraryDirectory ( App ) , "libmono-system-native.dylib" ) ) ) {
2019-03-25 18:01:09 +03:00
// legacy libmono-system-native.a needs to be included if it exists in the mono in question
name = "libmono-system-native" ;
} else {
// use modern libmono-native
2020-05-12 13:10:50 +03:00
name = App . GetLibNativeName ( ) ;
2018-10-15 22:39:29 +03:00
}
2020-04-16 15:19:45 +03:00
var src = Path . Combine ( GetMonoLibraryDirectory ( App ) , name + ".dylib" ) ;
2018-10-15 22:39:29 +03:00
var dest = Path . Combine ( mmp_dir , "libmono-native.dylib" ) ;
2020-05-12 13:10:50 +03:00
Watch ( $"Adding mono-native library {name} for {App.MonoNativeMode}." , 1 ) ;
2018-10-15 22:39:29 +03:00
2019-02-01 21:40:50 +03:00
if ( App . Optimizations . TrimArchitectures = = true ) {
// copy to temp directory and lipo there to avoid touching the final dest file if it's up to date
var temp_dest = Path . Combine ( App . Cache . Location , "libmono-native.dylib" ) ;
2018-10-15 22:39:29 +03:00
2019-05-24 18:51:17 +03:00
if ( Application . UpdateFile ( src , temp_dest ) )
2019-02-01 21:40:50 +03:00
LipoLibrary ( name , temp_dest ) ;
2019-05-24 18:51:17 +03:00
Application . UpdateFile ( temp_dest , dest ) ;
2019-02-01 21:40:50 +03:00
}
else {
// we can directly update the dest
Application . UpdateFile ( src , dest ) ;
}
2018-10-15 22:39:29 +03:00
}
2016-04-21 15:57:02 +03:00
static void ExtractNativeLinkInfo ( )
{
var exceptions = new List < Exception > ( ) ;
BuildTarget . ExtractNativeLinkInfo ( exceptions ) ;
if ( exceptions . Count > 0 )
throw new AggregateException ( exceptions ) ;
Watch ( "Extracted native link info" , 1 ) ;
}
2020-04-14 10:09:55 +03:00
static string system_mono_directory ;
2021-04-22 15:47:47 +03:00
public static string SystemMonoDirectory {
2020-04-14 10:09:55 +03:00
get {
if ( system_mono_directory = = null )
system_mono_directory = RunPkgConfig ( "--variable=prefix" , force_system_mono : true ) ;
return system_mono_directory ;
}
}
2016-04-21 15:57:02 +03:00
static string MonoDirectory {
get {
2020-04-14 10:09:55 +03:00
if ( IsUnifiedFullXamMacFramework | | IsUnifiedMobile )
2020-08-06 17:10:06 +03:00
return GetFrameworkCurrentDirectory ( App ) ;
2020-04-14 10:09:55 +03:00
return SystemMonoDirectory ;
2016-04-21 15:57:02 +03:00
}
}
static void GeneratePList ( ) {
2017-04-28 19:08:12 +03:00
var sr = new StreamReader ( typeof ( Driver ) . Assembly . GetManifestResourceStream ( App . Embeddinator ? "Info-framework.plist.tmpl" : "Info.plist.tmpl" ) ) ;
2016-04-21 15:57:02 +03:00
var all = sr . ReadToEnd ( ) ;
var icon_str = ( icon ! = null ) ? "\t<key>CFBundleIconFile</key>\n\t<string>" + icon + "</string>\n\t" : "" ;
2017-04-28 19:08:12 +03:00
var path = Path . Combine ( App . Embeddinator ? resources_dir : contents_dir , "Info.plist" ) ;
using ( var sw = new StreamWriter ( path ) ) {
2016-04-21 15:57:02 +03:00
sw . WriteLine (
all . Replace ( "@BUNDLEDISPLAYNAME@" , app_name ) .
Replace ( "@EXECUTABLE@" , app_name ) .
Replace ( "@BUNDLEID@" , string . Format ( "org.mono.bundler.{0}" , app_name ) ) .
Replace ( "@BUNDLEICON@" , icon_str ) .
Replace ( "@BUNDLENAME@" , app_name ) .
2020-05-05 16:35:02 +03:00
Replace ( "@ASSEMBLY@" , App . References . Where ( e = > Path . GetExtension ( e ) = = ".exe" ) . FirstOrDefault ( ) ) ) ;
2016-04-21 15:57:02 +03:00
}
}
// the 'codesign' is provided with OSX, not with Xcode (no need to use xcrun)
// note: by default the monodevelop addin does the signing (not mmp)
static void CodeSign ( ) {
RunCommand ( "codesign" , String . Format ( "-v -s \"{0}\" \"{1}\"" , certificate_name , App . AppDirectory ) ) ;
}
[DllImport (Constants.libSystemLibrary)]
static extern IntPtr realpath ( string path , IntPtr buffer ) ;
static string GetRealPath ( string path )
{
2016-10-20 16:34:26 +03:00
if ( path . StartsWith ( "@executable_path/" , StringComparison . Ordinal ) )
2016-04-21 15:57:02 +03:00
path = Path . Combine ( mmp_dir , path . Substring ( 17 ) ) ;
2016-10-20 16:34:26 +03:00
if ( path . StartsWith ( "@rpath/" , StringComparison . Ordinal ) )
2016-04-21 15:57:02 +03:00
path = Path . Combine ( mmp_dir , path . Substring ( 7 ) ) ;
const int PATHMAX = 1024 + 1 ;
IntPtr buffer = IntPtr . Zero ;
try {
buffer = Marshal . AllocHGlobal ( PATHMAX ) ;
var result = realpath ( path , buffer ) ;
if ( result = = IntPtr . Zero )
return path ;
else
return Marshal . PtrToStringAuto ( buffer ) ;
}
finally {
if ( buffer ! = IntPtr . Zero )
Marshal . FreeHGlobal ( buffer ) ;
}
}
2017-08-08 22:08:09 +03:00
static string PartialStaticLibrary {
get {
2020-08-06 17:10:06 +03:00
return Path . Combine ( GetFrameworkLibDirectory ( App ) , string . Format ( "mmp/Xamarin.Mac.registrar.{0}.a" , IsUnifiedMobile ? "mobile" : "full" ) ) ;
2017-08-08 22:08:09 +03:00
}
}
2019-10-14 17:18:46 +03:00
static void HandleFramework ( IList < string > args , string framework , bool weak )
2016-04-21 15:57:02 +03:00
{
string name = Path . GetFileName ( framework ) ;
if ( name . Contains ( '.' ) )
2019-10-14 17:18:46 +03:00
name = name . Remove ( name . IndexOf ( "." , StringComparison . Ordinal ) ) ;
2016-04-21 15:57:02 +03:00
string path = Path . GetDirectoryName ( framework ) ;
2019-10-14 17:18:46 +03:00
if ( ! string . IsNullOrEmpty ( path ) ) {
args . Add ( "-F" ) ;
args . Add ( path ) ;
}
2017-04-05 22:38:40 +03:00
if ( weak )
BuildTarget . WeakFrameworks . Add ( name ) ;
else
BuildTarget . Frameworks . Add ( name ) ;
2016-04-21 15:57:02 +03:00
2016-10-20 16:34:26 +03:00
if ( ! framework . EndsWith ( ".framework" , StringComparison . Ordinal ) )
2016-04-21 15:57:02 +03:00
return ;
2017-04-05 22:38:40 +03:00
// TODO - There is a chunk of code in mtouch that calls Xamarin.MachO.IsDynamicFramework and doesn't copy if framework of static libs
2016-04-21 15:57:02 +03:00
// But IsDynamicFramework is not on XM yet
CreateDirectoryIfNeeded ( frameworks_dir ) ;
Application . UpdateDirectory ( framework , frameworks_dir ) ;
2021-01-19 16:48:10 +03:00
var fxdir = Path . Combine ( frameworks_dir , name + ".framework" ) ;
Application . ExcludeNonEssentialFrameworkFiles ( fxdir ) ;
2016-07-28 15:49:21 +03:00
frameworks_copied_to_bundle_dir = true ;
2018-03-01 18:36:06 +03:00
if ( App . Optimizations . TrimArchitectures = = true )
2021-01-19 16:48:10 +03:00
LipoLibrary ( framework , Path . Combine ( name , Path . Combine ( fxdir , name ) ) ) ;
2016-04-21 15:57:02 +03:00
}
2020-02-26 02:38:20 +03:00
static void CheckSystemMonoVersion ( )
{
string mono_version ;
2020-04-14 10:09:55 +03:00
var versionFile = Path . Combine ( SystemMonoDirectory , "VERSION" ) ;
2020-02-26 02:38:20 +03:00
if ( File . Exists ( versionFile ) ) {
mono_version = File . ReadAllText ( versionFile ) ;
} else {
mono_version = RunPkgConfig ( "--modversion" , force_system_mono : true ) ;
}
mono_version = mono_version . Trim ( ) ;
if ( ! Version . TryParse ( mono_version , out var mono_ver ) )
return ;
if ( mono_ver < MonoVersions . MinimumMonoVersion )
throw ErrorHelper . CreateError ( 1 , Errors . MM0001 , MonoVersions . MinimumMonoVersion , mono_version ) ;
}
2020-03-17 17:49:39 +03:00
static void Compile ( )
2016-04-21 15:57:02 +03:00
{
2019-10-14 17:18:46 +03:00
string [ ] cflags = Array . Empty < string > ( ) ;
2016-04-21 15:57:02 +03:00
string registrarPath = null ;
2020-02-26 02:38:20 +03:00
CheckSystemMonoVersion ( ) ;
2020-05-13 16:35:20 +03:00
if ( App . Registrar = = RegistrarMode . Static ) {
2017-01-03 17:14:47 +03:00
registrarPath = Path . Combine ( App . Cache . Location , "registrar.m" ) ;
var registrarH = Path . Combine ( App . Cache . Location , "registrar.h" ) ;
2016-05-11 14:10:35 +03:00
BuildTarget . StaticRegistrar . Generate ( BuildTarget . Resolver . ResolverCache . Values , registrarH , registrarPath ) ;
2016-04-21 15:57:02 +03:00
2016-12-23 20:50:35 +03:00
var platform_assembly = BuildTarget . Resolver . ResolverCache . First ( ( v ) = > v . Value . Name . Name = = BuildTarget . StaticRegistrar . PlatformAssembly ) . Value ;
Frameworks . Gather ( App , platform_assembly , BuildTarget . Frameworks , BuildTarget . WeakFrameworks ) ;
2016-04-21 15:57:02 +03:00
}
2020-02-26 02:38:20 +03:00
var str_cflags = RunPkgConfig ( "--cflags" ) ;
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
var libdir = GetMonoLibraryDirectory ( App ) ;
2016-04-21 15:57:02 +03:00
2019-10-14 17:18:46 +03:00
if ( ! StringUtils . TryParseArguments ( str_cflags , out cflags , out var ex ) )
2020-01-31 23:02:52 +03:00
throw ErrorHelper . CreateError ( 147 , ex , Errors . MM0147 , str_cflags , ex . Message ) ;
2016-04-21 15:57:02 +03:00
var libmain = embed_mono ? "libxammac" : "libxammac-system" ;
2020-05-07 17:20:07 +03:00
var libxammac = Path . Combine ( GetXamarinLibraryDirectory ( App ) , libmain + ( App . EnableDebug ? "-debug" : "" ) + ".a" ) ;
2016-04-21 15:57:02 +03:00
if ( ! File . Exists ( libxammac ) )
2020-05-14 17:45:05 +03:00
throw new ProductException ( 5203 , true , Errors . MM5203 , libxammac ) ;
2016-04-21 15:57:02 +03:00
try {
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
List < string > compiledExecutables = new List < string > ( ) ;
foreach ( var abi in App . Abis ) {
var abiDir = Path . Combine ( App . Cache . Location , "main" , abi . AsArchString ( ) ) ;
// Delete previous content (so we don't have any remaining dsym if we switch from having one to not having one)
if ( Directory . Exists ( abiDir ) )
Directory . Delete ( abiDir , true ) ;
var main = Path . Combine ( abiDir , $"main.m" ) ;
BuildTarget . GenerateMain ( ApplePlatform . MacOSX , abi , main , null ) ;
var args = new List < string > ( ) ;
if ( App . EnableDebug )
args . Add ( "-g" ) ;
if ( App . Embeddinator ) {
args . Add ( "-shared" ) ;
args . Add ( "-install_name" ) ;
args . Add ( $"@loader_path/../Frameworks/{App.Name}.framework/{App.Name}" ) ;
}
args . Add ( $"-mmacosx-version-min={App.DeploymentTarget.ToString ()}" ) ;
args . Add ( "-arch" ) ;
args . Add ( abi . AsArchString ( ) ) ;
args . Add ( $"-fobjc-runtime=macosx-{App.DeploymentTarget.ToString ()}" ) ;
if ( ! embed_mono )
args . Add ( "-DDYNAMIC_MONO_RUNTIME" ) ;
if ( XcodeVersion > = new Version ( 9 , 0 ) )
args . Add ( "-Wno-unguarded-availability-new" ) ;
if ( XcodeVersion . Major > = 11 )
args . Add ( "-std=c++14" ) ;
bool appendedObjc = false ;
var sourceFiles = new List < string > ( ) ;
foreach ( var assembly in BuildTarget . Assemblies ) {
if ( assembly . LinkWith ! = null ) {
foreach ( var linkWith in assembly . LinkWith ) {
Log ( 2 , "Found LinkWith on {0} for {1}" , assembly . FileName , linkWith ) ;
if ( linkWith . EndsWith ( ".dylib" , StringComparison . Ordinal ) ) {
// Link against the version copied into MonoBudle, since we install_name_tool'd it already
string libName = Path . GetFileName ( linkWith ) ;
string finalLibPath = Path . Combine ( mmp_dir , libName ) ;
args . Add ( finalLibPath ) ;
} else {
args . Add ( linkWith ) ;
}
2016-04-21 15:57:02 +03:00
}
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
if ( ! appendedObjc ) {
appendedObjc = true ;
args . Add ( "-ObjC" ) ;
2016-04-21 15:57:02 +03:00
}
}
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
if ( assembly . LinkerFlags ! = null )
foreach ( var linkFlag in assembly . LinkerFlags )
args . Add ( linkFlag ) ;
if ( assembly . Frameworks ! = null ) {
foreach ( var f in assembly . Frameworks ) {
Log ( 2 , $"Adding Framework {f} for {assembly.FileName}" ) ;
HandleFramework ( args , f , false ) ;
}
2017-03-29 02:16:51 +03:00
}
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
if ( assembly . WeakFrameworks ! = null ) {
foreach ( var f in assembly . WeakFrameworks ) {
Log ( 2 , $"Adding Weak Framework {f} for {assembly.FileName}" ) ;
HandleFramework ( args , f , true ) ;
}
2017-04-05 22:38:40 +03:00
}
}
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
foreach ( var framework in App . Frameworks )
HandleFramework ( args , framework , false ) ;
foreach ( var lib in native_libraries_copied_in ) {
// Link against the version copied into MonoBudle, since we install_name_tool'd it already
string libName = Path . GetFileName ( lib ) ;
string finalLibPath = Path . Combine ( mmp_dir , libName ) ;
args . Add ( finalLibPath ) ;
2017-04-05 22:38:40 +03:00
}
2016-04-21 15:57:02 +03:00
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
if ( frameworks_copied_to_bundle_dir ) {
args . Add ( "-rpath" ) ;
args . Add ( "@loader_path/../Frameworks" ) ;
}
if ( dylibs_copied_to_bundle_dir ) {
args . Add ( "-rpath" ) ;
args . Add ( $"@loader_path/../{App.CustomBundleName}" ) ;
}
2016-04-21 15:57:02 +03:00
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
if ( is_extension & & ! is_xpc_service ) {
args . Add ( "-e" ) ;
args . Add ( "_xamarin_mac_extension_main" ) ;
args . Add ( "-framework" ) ;
args . Add ( "NotificationCenter" ) ;
}
2016-04-21 15:57:02 +03:00
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
foreach ( var f in BuildTarget . Frameworks ) {
args . Add ( "-framework" ) ;
args . Add ( f ) ;
}
foreach ( var f in BuildTarget . WeakFrameworks ) {
args . Add ( "-weak_framework" ) ;
args . Add ( f ) ;
}
2018-12-11 18:28:55 +03:00
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
var requiredSymbols = BuildTarget . GetRequiredSymbols ( target_abis : abi ) ;
Driver . WriteIfDifferent ( Path . Combine ( App . Cache . Location , "exported-symbols-list" ) , string . Join ( "\n" , requiredSymbols . Select ( ( symbol ) = > symbol . Prefix + symbol . Name ) . ToArray ( ) ) ) ;
switch ( App . SymbolMode ) {
case SymbolMode . Ignore :
break ;
case SymbolMode . Code :
string reference_m = Path . Combine ( App . Cache . Location , "reference.m" ) ;
reference_m = BuildTarget . GenerateReferencingSource ( reference_m , requiredSymbols ) ;
if ( ! string . IsNullOrEmpty ( reference_m ) )
sourceFiles . Add ( reference_m ) ;
break ;
case SymbolMode . Linker :
case SymbolMode . Default :
foreach ( var symbol in requiredSymbols ) {
args . Add ( "-u" ) ;
args . Add ( symbol . Prefix + symbol . Name ) ;
}
break ;
default :
throw ErrorHelper . CreateError ( 99 , Errors . MX0099 , $"invalid symbol mode: {App.SymbolMode}" ) ;
}
2016-05-26 00:20:33 +03:00
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
bool linkWithRequiresForceLoad = BuildTarget . Assemblies . Any ( x = > x . ForceLoad ) ;
if ( no_executable | | linkWithRequiresForceLoad )
args . Add ( "-force_load" ) ; // make sure nothing is stripped away if we don't have a root assembly, since anything can end up being used.
args . Add ( libxammac ) ;
[mtouch] Improve how we make sure native symbols aren't stripped away. Fixes #51710 and #54417. (#2162)
* [mtouch] Improve how we make sure native symbols aren't stripped away. Fixes #51710 and #54417.
* Refactor required symbol collection to store more information about each
symbol (field, function, Objective-C class), and in general make the code
more straight forward.
* Implement support for generating source code that references these symbols,
and do this whenever we can't ask the native linker to keep these symbols
(when using bitcode). Additionally make it possible to do this manually, so
that the source code can be generated for non-bitcode platforms too (which
is useful if the number of symbols is enormous, in which case we might
surpass the maximum command-line length).
* Also make it possible to completely ignore native symbols, or ignore them on
a per-symbol basis. This provides a fallback for users if we get something
right and we try to preserve something that shouldn't be preserved (for
instance if it doesn't exist), and the user ends up with unfixable linker
errors.
* Don't collect Objective-C classes unless they're in an assembly with
LinkWith attributes. We don't need to preserve Objective-C classes in any
other circumstances.
* Implement everything for both Xamarin.iOS and Xamarin.Mac, and share the
code between them.
* Remove previous workaround for bug #51710, since it's no longer needed.
* Add tests.
https://bugzilla.xamarin.com/show_bug.cgi?id=54417
https://bugzilla.xamarin.com/show_bug.cgi?id=51710
* [mtouch] Make sure to only keep symbols from the current app when code sharing.
This fixes a build problem with the interdependent-binding-projects test when
testing in Today Extension mode.
2017-06-02 19:29:19 +03:00
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
args . Add ( "-o" ) ;
var outputPath = Path . Combine ( abiDir , Path . GetFileName ( AppPath ) ) ;
compiledExecutables . Add ( outputPath ) ;
args . Add ( outputPath ) ;
args . AddRange ( cflags ) ;
if ( embed_mono ) {
string libmono = Path . Combine ( libdir , "libmonosgen-2.0.a" ) ;
if ( ! File . Exists ( libmono ) )
throw new ProductException ( 5202 , true , Errors . MM5202 ) ;
args . Add ( libmono ) ;
string libmonoSystemNative = Path . Combine ( libdir , "libmono-system-native.a" ) ;
if ( File . Exists ( libmonoSystemNative ) ) {
// legacy libmono-system-native.a needs to be included if it exists in the mono in question
args . Add ( libmonoSystemNative ) ;
args . Add ( "-u" ) ;
args . Add ( "_SystemNative_RealPath" ) ; // This keeps libmono_system_native_la-pal_io.o symbols
} else {
// add modern libmono-native
args . Add ( Path . Combine ( libdir , App . GetLibNativeName ( ) + ".a" ) ) ;
args . Add ( "-framework" ) ;
args . Add ( "GSS" ) ;
}
if ( App . EnableProfiling ) {
args . Add ( Path . Combine ( libdir , "libmono-profiler-log.a" ) ) ;
args . Add ( "-u" ) ;
args . Add ( "_mono_profiler_init_log" ) ;
}
args . Add ( "-lz" ) ;
2019-10-14 17:18:46 +03:00
}
2016-04-21 15:57:02 +03:00
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
if ( App . Registrar = = RegistrarMode . PartialStatic ) {
args . Add ( PartialStaticLibrary ) ;
2019-10-14 17:18:46 +03:00
args . Add ( "-framework" ) ;
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
args . Add ( "Quartz" ) ;
2018-10-15 22:39:29 +03:00
}
2018-10-10 18:02:28 +03:00
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
args . Add ( "-liconv" ) ;
args . Add ( "-lc++" ) ;
args . Add ( "-x" ) ;
args . Add ( "objective-c++" ) ;
if ( XcodeVersion . Major > = 10 ) {
// Xcode 10 doesn't ship with libstdc++
args . Add ( "-stdlib=libc++" ) ;
}
args . Add ( $"-I{GetProductSdkIncludeDirectory (App)}" ) ;
if ( registrarPath ! = null )
args . Add ( registrarPath ) ;
args . Add ( "-fno-caret-diagnostics" ) ;
args . Add ( "-fno-diagnostics-fixit-info" ) ;
if ( link_flags ! = null )
args . AddRange ( link_flags ) ;
if ( ! string . IsNullOrEmpty ( DeveloperDirectory ) ) {
var sysRootSDKVersion = new Version ( App . SdkVersion . Major , App . SdkVersion . Minor ) ; // Sys Root SDKs do not have X.Y.Z, just X.Y
args . Add ( "-isysroot" ) ;
args . Add ( Path . Combine ( DeveloperDirectory , "Platforms" , "MacOSX.platform" , "Developer" , "SDKs" , "MacOSX" + sysRootSDKVersion + ".sdk" ) ) ;
2016-04-21 15:57:02 +03:00
}
2016-12-01 19:18:30 +03:00
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
if ( App . RequiresPInvokeWrappers ) {
var state = BuildTarget . LinkerOptions . MarshalNativeExceptionsState ;
state . End ( ) ;
args . Add ( state . SourcePath ) ;
}
2016-12-01 19:18:30 +03:00
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
sourceFiles . Add ( main ) ;
args . AddRange ( sourceFiles ) ;
2016-04-21 15:57:02 +03:00
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
RunClang ( App , args ) ;
2016-05-11 14:27:51 +03:00
}
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
RunLipoAndCreateDsym ( App , AppPath , compiledExecutables ) ;
2016-04-21 15:57:02 +03:00
} catch ( Win32Exception e ) {
2020-05-14 17:45:05 +03:00
throw new ProductException ( 5103 , true , e , Errors . MM5103 , "driver" ) ;
2016-04-21 15:57:02 +03:00
}
}
2020-02-26 02:38:20 +03:00
static string RunPkgConfig ( string option , bool force_system_mono = false )
{
2020-06-18 13:34:07 +03:00
Dictionary < string , string > env = null ;
2020-02-26 02:38:20 +03:00
if ( ! IsUnifiedFullSystemFramework & & ! force_system_mono )
2020-07-16 18:57:15 +03:00
env = new Dictionary < string , string > { { "PKG_CONFIG_PATH" , Path . Combine ( GetProductSdkLibDirectory ( App ) , "pkgconfig" ) } } ;
2020-02-26 02:38:20 +03:00
var sb = new StringBuilder ( ) ;
int rv ;
try {
2020-04-14 10:09:55 +03:00
rv = RunCommand ( PkgConfig , new [ ] { option , "mono-2" } , env , sb ) ;
2020-02-26 02:38:20 +03:00
} catch ( Exception e ) {
throw ErrorHelper . CreateError ( 5314 , e , Errors . MX5314 , e . Message ) ;
}
if ( rv ! = 0 )
throw ErrorHelper . CreateError ( 5312 , Errors . MX5312 , rv ) ;
return sb . ToString ( ) . Trim ( ) ;
}
2019-07-24 19:01:14 +03:00
// check that we have a reference to Xamarin.Mac.dll and not to MonoMac.dll.
2016-04-21 15:57:02 +03:00
static void CheckReferences ( )
{
List < Exception > exceptions = new List < Exception > ( ) ;
var cache = BuildTarget . Resolver . ToResolverCache ( ) ;
var incompatibleReferences = new List < string > ( ) ;
var haveValidReference = false ;
foreach ( string entry in cache . Keys ) {
switch ( entry ) {
case "Xamarin.Mac" :
2019-07-24 19:01:14 +03:00
haveValidReference = true ;
2016-04-21 15:57:02 +03:00
break ;
case "XamMac" :
2019-07-24 19:01:14 +03:00
incompatibleReferences . Add ( entry ) ;
2016-04-21 15:57:02 +03:00
break ;
case "MonoMac" :
incompatibleReferences . Add ( entry ) ;
break ;
}
}
if ( ! haveValidReference )
2020-05-14 17:45:05 +03:00
exceptions . Add ( new ProductException ( 1401 , true , Errors . MM1401 ) ) ;
2016-04-21 15:57:02 +03:00
foreach ( var refName in incompatibleReferences )
2020-05-14 17:45:05 +03:00
exceptions . Add ( new ProductException ( 1402 , true , Errors . MM1402 , refName + ".dll" ) ) ;
2016-04-21 15:57:02 +03:00
if ( exceptions . Count > 0 )
throw new AggregateException ( exceptions ) ;
}
static IDictionary < string , List < MethodDefinition > > Link ( )
{
2017-09-05 21:48:09 +03:00
var cache = ( Dictionary < string , AssemblyDefinition > ) BuildTarget . Resolver . ResolverCache ;
2020-04-14 17:32:42 +03:00
AssemblyResolver resolver ;
if ( UseLegacyAssemblyResolution ) {
if ( cache ! = null ) {
resolver = new Mono . Linker . AssemblyResolver ( cache ) ;
} else {
resolver = new Mono . Linker . AssemblyResolver ( ) ;
}
} else {
resolver = new MonoMacAssemblyResolver ( BuildTarget . Resolver ) ;
}
2016-04-21 15:57:02 +03:00
resolver . AddSearchDirectory ( BuildTarget . Resolver . RootDirectory ) ;
resolver . AddSearchDirectory ( BuildTarget . Resolver . FrameworkDirectory ) ;
var options = new LinkerOptions {
2020-05-05 16:35:02 +03:00
MainAssembly = BuildTarget . Resolver . GetAssembly ( App . References [ App . References . Count - 1 ] ) ,
2016-04-21 15:57:02 +03:00
OutputDirectory = mmp_dir ,
LinkSymbols = App . EnableDebug ,
LinkMode = App . LinkMode ,
Resolver = resolver ,
SkippedAssemblies = App . LinkSkipped ,
I18nAssemblies = App . I18n ,
ExtraDefinitions = App . Definitions ,
RuntimeOptions = App . RuntimeOptions ,
2016-05-11 14:27:51 +03:00
MarshalNativeExceptionsState = ! App . RequiresPInvokeWrappers ? null : new PInvokeWrapperGenerator ( )
{
2016-12-23 20:50:35 +03:00
App = App ,
2017-01-03 17:14:47 +03:00
SourcePath = Path . Combine ( App . Cache . Location , "pinvokes.m" ) ,
HeaderPath = Path . Combine ( App . Cache . Location , "pinvokes.h" ) ,
2016-05-11 14:27:51 +03:00
Registrar = ( StaticRegistrar ) BuildTarget . StaticRegistrar ,
} ,
2016-10-26 13:57:11 +03:00
SkipExportedSymbolsInSdkAssemblies = ! embed_mono ,
2017-05-24 22:04:32 +03:00
Target = BuildTarget ,
2020-02-21 06:25:23 +03:00
WarnOnTypeRef = App . WarnOnTypeRef ,
2016-04-21 15:57:02 +03:00
} ;
2020-05-07 16:01:26 +03:00
BuildTarget . LinkerOptions = options ;
2016-05-11 14:27:51 +03:00
2019-02-07 09:57:01 +03:00
MonoMac . Tuner . Linker . Process ( options , out var context , out resolved_assemblies ) ;
ErrorHelper . Show ( context . Exceptions ) ;
2016-08-16 23:24:01 +03:00
// Idealy, this would be handled by Linker.Process above. However in the non-linking case
// we do not run MobileMarkStep which generates the pinvoke list. Hack around this for now
// https://bugzilla.xamarin.com/show_bug.cgi?id=43419
if ( App . LinkMode = = LinkMode . None )
return ProcessDllImports ( ) ;
else
return BuildTarget . LinkContext . PInvokeModules ;
2016-04-21 15:57:02 +03:00
}
2016-08-16 23:24:01 +03:00
static Dictionary < string , List < MethodDefinition > > ProcessDllImports ( )
2016-04-21 15:57:02 +03:00
{
2016-08-16 23:24:01 +03:00
var pinvoke_modules = new Dictionary < string , List < MethodDefinition > > ( ) ;
2016-04-21 15:57:02 +03:00
foreach ( string assembly_name in resolved_assemblies ) {
AssemblyDefinition assembly = BuildTarget . Resolver . GetAssembly ( assembly_name ) ;
2016-08-16 23:24:01 +03:00
if ( assembly ! = null ) {
foreach ( ModuleDefinition md in assembly . Modules ) {
if ( md . HasTypes ) {
foreach ( TypeDefinition type in md . Types ) {
if ( type . HasMethods ) {
foreach ( MethodDefinition method in type . Methods ) {
if ( ( method ! = null ) & & ! method . HasBody & & method . IsPInvokeImpl ) {
// this happens for c++ assemblies (ref #11448)
if ( method . PInvokeInfo = = null )
continue ;
string module = method . PInvokeInfo . Module . Name ;
if ( ! String . IsNullOrEmpty ( module ) ) {
List < MethodDefinition > methods ;
if ( ! pinvoke_modules . TryGetValue ( module , out methods ) )
pinvoke_modules . Add ( module , methods = new List < MethodDefinition > ( ) ) ;
}
2016-04-21 15:57:02 +03:00
}
}
}
}
}
}
}
}
2016-08-16 23:24:01 +03:00
return pinvoke_modules ;
2016-04-21 15:57:02 +03:00
}
static void CopyDependencies ( IDictionary < string , List < MethodDefinition > > libraries )
{
// Process LinkWith first so we don't have unnecessary warnings
foreach ( var assembly in BuildTarget . Assemblies . Where ( a = > a . LinkWith ! = null ) ) {
2016-10-20 16:34:26 +03:00
foreach ( var linkWith in assembly . LinkWith . Where ( l = > l . EndsWith ( ".dylib" , StringComparison . Ordinal ) ) ) {
2016-04-21 15:57:02 +03:00
string libName = Path . GetFileName ( linkWith ) ;
string finalLibPath = Path . Combine ( mmp_dir , libName ) ;
Application . UpdateFile ( linkWith , finalLibPath ) ;
2020-08-06 17:10:06 +03:00
RunInstallNameTool ( App , new [ ] { "-id" , "@executable_path/../" + App . CustomBundleName + "/" + libName , finalLibPath } ) ;
2016-04-21 15:57:02 +03:00
native_libraries_copied_in . Add ( libName ) ;
}
}
var processed = new HashSet < string > ( ) ;
foreach ( var kvp in libraries . Where ( l = > ! native_libraries_copied_in . Contains ( Path . GetFileName ( l . Key ) ) ) )
ProcessNativeLibrary ( processed , kvp . Key , kvp . Value ) ;
// .dylibs might refers to specific paths (e.g. inside Mono framework directory) and/or
// refer to a symlink (pointing to a more specific version of the library)
2019-10-14 17:18:46 +03:00
var sb = new List < string > ( ) ;
2016-04-21 15:57:02 +03:00
foreach ( string library in Directory . GetFiles ( mmp_dir , "*.dylib" ) ) {
foreach ( string lib in Xamarin . MachO . GetNativeDependencies ( library ) ) {
2020-04-14 10:09:55 +03:00
if ( lib . StartsWith ( Path . GetDirectoryName ( MonoPrefix ) , StringComparison . Ordinal ) ) {
2016-04-21 15:57:02 +03:00
string libname = Path . GetFileName ( lib ) ;
string real_lib = GetRealPath ( lib ) ;
string real_libname = Path . GetFileName ( real_lib ) ;
// if a symlink was specified then re-create it inside the .app
if ( libname ! = real_libname )
CreateSymLink ( mmp_dir , real_libname , libname ) ;
2019-10-14 17:18:46 +03:00
sb . Add ( "-change" ) ;
sb . Add ( lib ) ;
2020-05-13 16:35:20 +03:00
sb . Add ( "@executable_path/../" + App . CustomBundleName + "/" + libname ) ;
2016-04-21 15:57:02 +03:00
}
}
// if required update the paths inside the .dylib that was copied
2019-10-14 17:18:46 +03:00
if ( sb . Count > 0 ) {
2020-03-18 14:15:20 +03:00
sb . Add ( library ) ;
2020-08-06 17:10:06 +03:00
RunInstallNameTool ( App , sb ) ;
2016-04-21 15:57:02 +03:00
sb . Clear ( ) ;
}
}
}
static string GetLibraryShortenedName ( string name )
{
// GetFileNameWithoutExtension only removes one extension, e.g. libx.so.2 won't work
int start = name . StartsWith ( "lib" , StringComparison . Ordinal ) ? 3 : 0 ;
int end = name . Length ;
if ( name . EndsWith ( ".dylib" , StringComparison . Ordinal ) )
end - = 6 ;
else if ( name . EndsWith ( ".so" , StringComparison . Ordinal ) )
end - = 3 ;
else if ( name . EndsWith ( ".dll" , StringComparison . OrdinalIgnoreCase ) )
end - = 4 ;
return name . Substring ( start , end - start ) ;
}
static bool ShouldSkipNativeLibrary ( string fileName )
{
string shortendName = GetLibraryShortenedName ( fileName ) ;
// well known libraries we do not bundle or warn about
switch ( shortendName . ToLowerInvariant ( ) ) {
case "xammac" : // we have a p/invoke to this library in Runtime.mac.cs, for users that don't bundle with mmp.
case "__internal" : // mono runtime
case "kernel32" : // windows specific
case "gdi32" : // windows specific
case "ole32" : // windows specific
case "user32" : // windows specific
case "advapi32" : // windows specific
case "crypt32" : // windows specific
case "msvcrt" : // windows specific
case "iphlpapi" : // windows specific
case "winmm" : // windows specific
case "winspool" : // windows specific
case "c" : // system provided
2018-12-06 22:16:10 +03:00
case "objc" : // system provided
case "objc.a" : // found in swift core libraries
case "system.b" : // found in swift core libraries
2016-04-21 15:57:02 +03:00
case "system" : // system provided, libSystem.dylib -> CommonCrypto
case "x11" : // msvcrt pulled in
case "winspool.drv" : // msvcrt pulled in
case "cups" : // msvcrt pulled in
case "fam.so.0" : // msvcrt pulled in
case "gamin-1.so.0" : // msvcrt pulled in
case "asound.so.2" : // msvcrt pulled in
case "oleaut32" : // referenced by System.Runtime.InteropServices.Marshal._[S|G]etErrorInfo
2019-02-01 21:40:50 +03:00
case "system.native" : // handled by CopyMonoNative()
2018-10-15 22:39:29 +03:00
case "system.security.cryptography.native.apple" : // same
2019-01-31 13:18:29 +03:00
case "system.net.security.native" : // same
2016-04-21 15:57:02 +03:00
return true ;
}
// Shutup the warning until we decide on bug: 36478
2019-04-08 18:26:23 +03:00
if ( shortendName . ToLowerInvariant ( ) = = "intl" & & ! native_references . Any ( x = > x . Contains ( "libintl.dylib" ) ) & & IsUnifiedFullXamMacFramework )
2016-04-21 15:57:02 +03:00
return true ;
return false ;
}
static void ProcessNativeLibrary ( HashSet < string > processed , string library , List < MethodDefinition > used_by_methods )
{
// We do not bundle system libraries, ever
if ( library . StartsWith ( "/usr/lib/" , StringComparison . Ordinal ) | | library . StartsWith ( "/System/Library/" , StringComparison . Ordinal ) )
return ;
// If we've been required to ignore this library, skip it
if ( ignored_assemblies . Contains ( library ) )
return ;
2018-03-01 18:36:06 +03:00
// If we're passed in a framework, ignore
2016-04-21 15:57:02 +03:00
if ( App . Frameworks . Contains ( library ) )
return ;
[msbuild] Simplify resolving xcframeworks (#10376)
TD&LR: This PR simplifies how we refer to user frameworks and fixes both
warnings and non-optimal (app) output.
Much longer story:
Additional testing on macOS showed some build-time warnings and an
[extra (dupe) file](https://github.com/spouliot/xcframework/commit/a20f8aba419e32e2338cb7c5e4b45d0f38862893#diff-54fd7d9cd5deae57f30195be0a43133eace03c1132401741a317e0ae8d5e13fdR34).
Logs shows that we referred to the xcframework several times, where once
should have been enough.
```
/native-reference:/Users/poupou/git/spouliot/xcframework/Universal.xcframework
/native-reference:/Users/poupou/git/spouliot/xcframework/Universal.xcframework/macos-arm64_x86_64/Universal.framework
/native-reference:/Users/poupou/git/spouliot/xcframework/Universal.xcframework/macos-arm64_x86_64/Universal.framework/Universal
```
The first `/native-reference` line produced a warning like:
```
MMP warning MM2006: Native library 'Universal.xcframework' was referenced but could not be found.
```
which makes sense as the tools (both `mmp` and `mtouch`) are not, by
design, aware of (unresolved) xcframeworks.
Removing `{NativeReference}` from `Xamarin.Mac.Common.targets` (and
`Xamarin.iOS.Common.targets`) as it has already been processed by
`_ExpandNativeReferences` solves this.
The other part of the issue (next two lines) is because `msbuild` does
not track changes to directories like it does for files - and the
workaround (in `_ExpandNativeReferences`) had to be copied in other
places (both XI and XM `_CompileToNative`) and that was not enough (and
would eventually need to be duplicated again and again).
This could lead to duplicate entries (i msbuild logs) like
```
NativeReferences
../../Universal.xcframework/macos-arm64_x86_64/Universal.framework
../../Universal.xcframework/macos-arm64_x86_64/Universal.framework/Univeral
```
which maps to our extra entries.
In order to simplify things we make the `_ExpandNativeReferences` resolve
the full path to the library name (not the `.framework` directory) which
simplifies both `_CompileToNative` and ensure a single way (at least for
`msbuild`) to provide this data to the tools (`mmp` and `mtouch`).
Using a file, instead of a directory, is also more consistent for the
existing `-framework` option, e.g. we provide the names like:
```
--framework=CoreLocation
--framework=ModelIO
```
So adding a full path that include the name is more appropriate, e.g.
``` --framework=/Users/poupou/git/master/xamarin-macios/tests/xharness/tmp-test-dir/xcframework-test760/bin/AnyCPU/Debug/bindings-xcframework-test.resources/XTest.xcframework/ios-i386_x86_64-simulator/XTest.framework/XTest
```
Finally for macOS applications it turns out we were embedding yet another
copy of the framework's library inside the `MonoBundle`, which is clearly
wrong, because of the last entry.
```
$ l bin/Release/xcf-mac.app/Contents/MonoBundle/Universal
-rwxr-xr-x 1 poupou staff 167152 2 Dec 16:16 bin/Release/xcf-mac.app/Contents/MonoBundle/Universal
```
The tool now checks if a provided library is inside a framework (or not)
which is a good validation to have anyway when it gets called directly,
i.e. not thru `msbuild`.
2021-01-13 00:02:01 +03:00
// Frameworks don't include the lib name, e.g. `../foo.framework` not `../foo.framework/foo` so check again
string path = Path . GetDirectoryName ( library ) ;
if ( App . Frameworks . Contains ( path ) )
return ;
2016-04-21 15:57:02 +03:00
// We need to check both the name and the shortened name, since we might get passed:
// full path - /foo/bar/libFoo.dylib
// just name - libFoo
string name = Path . GetFileName ( library ) ;
string libName = "lib" + GetLibraryShortenedName ( name ) + ".dylib" ;
// There is a list of libraries we always skip, honor that
if ( ShouldSkipNativeLibrary ( name ) )
return ;
string src = null ;
// If we've been passed in a full path and it is there, let's just go with that
if ( File . Exists ( library ) )
src = library ;
// Now let's check inside mono/lib
2020-04-16 15:19:45 +03:00
string monoDirPath = Path . Combine ( GetMonoLibraryDirectory ( App ) , libName ) ;
2016-04-21 15:57:02 +03:00
if ( src = = null & & File . Exists ( monoDirPath ) )
src = monoDirPath ;
// Now let's check in path with our libName
if ( src = = null & & ! String . IsNullOrEmpty ( path ) ) {
string pathWithLibName = Path . Combine ( path , name ) ;
if ( File . Exists ( pathWithLibName ) )
src = pathWithLibName ;
}
// If we can't find it at this point, scream
if ( src = = null ) {
2020-05-14 17:45:05 +03:00
ErrorHelper . Show ( new ProductException ( 2006 , false , Errors . MM2006 , name ) ) ;
2016-04-21 15:57:02 +03:00
if ( used_by_methods ! = null & & used_by_methods . Count > 0 ) {
const int referencedByLimit = 25 ;
2020-02-18 23:44:19 +03:00
bool limitReferencedByWarnings = used_by_methods . Count > referencedByLimit & & Verbosity < 4 ;
2016-04-21 15:57:02 +03:00
foreach ( var m in limitReferencedByWarnings ? used_by_methods . Take ( referencedByLimit ) : used_by_methods ) {
2020-01-31 23:02:52 +03:00
ErrorHelper . Warning ( 2009 , Errors . MM2009 , m . DeclaringType . FullName , m . Name ) ;
2016-04-21 15:57:02 +03:00
}
if ( limitReferencedByWarnings )
2020-01-31 23:02:52 +03:00
ErrorHelper . Warning ( 2012 , Errors . MM2012 , referencedByLimit , used_by_methods . Count ) ;
2016-04-21 15:57:02 +03:00
}
return ;
}
string real_src = GetRealPath ( src ) ;
string dest = Path . Combine ( mmp_dir , Path . GetFileName ( real_src ) ) ;
2020-02-18 23:44:19 +03:00
Log ( 2 , "Native library '{0}' copied to application bundle." , Path . GetFileName ( real_src ) ) ;
2016-04-21 15:57:02 +03:00
if ( GetRealPath ( dest ) = = real_src ) {
Console . WriteLine ( "Dependency {0} was already at destination, skipping." , Path . GetFileName ( real_src ) ) ;
}
else {
2016-05-25 23:29:33 +03:00
// install_name_tool gets angry if you copy in a read only native library
CopyFileAndRemoveReadOnly ( real_src , dest ) ;
2016-04-21 15:57:02 +03:00
}
2016-10-20 16:34:26 +03:00
bool isStaticLib = real_src . EndsWith ( ".a" , StringComparison . Ordinal ) ;
2018-03-01 18:36:06 +03:00
bool isDynamicLib = real_src . EndsWith ( ".dylib" , StringComparison . Ordinal ) ;
if ( isDynamicLib & & App . Optimizations . TrimArchitectures = = true )
LipoLibrary ( name , dest ) ;
2016-04-21 15:57:02 +03:00
if ( native_references . Contains ( real_src ) ) {
2020-03-17 17:49:39 +03:00
if ( ! isStaticLib )
2020-08-06 17:10:06 +03:00
RunInstallNameTool ( App , new [ ] { "-id" , "@executable_path/../" + App . CustomBundleName + "/" + name , dest } ) ;
2016-04-21 15:57:02 +03:00
native_libraries_copied_in . Add ( name ) ;
}
// if a symlink was used then it might still be needed at runtime
if ( src ! = real_src )
CreateSymLink ( mmp_dir , real_src , src ) ;
// We add both the resolved location and the initial request.
// @executable_path subtitution and other resolving can have these be different
// and we'll loop forever otherwise
processed . Add ( real_src ) ;
processed . Add ( library ) ;
// process native dependencies
if ( ! isStaticLib ) {
foreach ( string dependency in Xamarin . MachO . GetNativeDependencies ( real_src ) ) {
string lib = GetRealPath ( dependency ) ;
if ( ! processed . Contains ( lib ) )
ProcessNativeLibrary ( processed , lib , null ) ;
}
}
}
2018-03-01 18:36:06 +03:00
static void LipoLibrary ( string name , string dest )
{
var existingArchs = Xamarin . MachO . GetArchitectures ( dest ) ;
// If we have less than two, it will either match by default or
// we'll fail a link/launch time with a better error so bail
if ( existingArchs . Count ( ) < 2 )
return ;
2021-01-07 19:20:31 +03:00
// macOS frameworks often uses symlinks and we do not
// want to replace the symlink with the thin binary
// while leaving the fat binary inside the framework
dest = GetRealPath ( dest ) ;
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
var prefix = new [ ] { dest } ;
var suffix = new [ ] { "-output" , dest } ;
List < string > archArgs = new List < string > ( ) ;
foreach ( var abi in App . Abis ) {
archArgs . Add ( "-extract_family" ) ;
archArgs . Add ( abi . ToString ( ) . ToLowerInvariant ( ) ) ;
}
RunLipo ( App , prefix . Concat ( archArgs ) . Concat ( suffix ) . ToArray ( ) ) ;
if ( existingArchs . Except ( App . Abis ) . Count ( ) > 0 & & name ! = "MonoPosixHelper" & & name ! = "libmono-native-unified" & & name ! = "libmono-native-compat" )
ErrorHelper . Warning ( 2108 , Errors . MM2108 , name , string . Join ( ", " , App . Abis ) ) ;
2018-03-01 18:36:06 +03:00
}
2016-04-21 15:57:02 +03:00
static void CreateSymLink ( string directory , string real , string link )
{
string cd = Environment . CurrentDirectory ;
Environment . CurrentDirectory = directory ;
symlink ( Path . GetFileName ( real ) , "./" + Path . GetFileName ( link ) ) ;
Environment . CurrentDirectory = cd ;
}
/* Currently we clobber any existing files, perhaps we should error and have a -force flag */
static void CreateDirectoriesIfNeeded ( ) {
2017-04-28 19:09:03 +03:00
if ( App . Embeddinator ) {
App . AppDirectory = Path . Combine ( output_dir , app_name + ".framework" ) ;
contents_dir = Path . Combine ( App . AppDirectory , "Versions" , "A" ) ;
macos_dir = contents_dir ;
} else {
Add bindings for NSXpcConnection and related types (#7001)
* Add bindings for NSXpcConnection and related types
* Re-add accidentally deleted file
* Typo fix
* Add NSXpcInterface.CreateForType()
* Add MethodInfo-taking overloads to NSXpcInterface
* Add null check
* Mark methods with wrappers as internal
Also fixed a formatting bug that I didn't catch earlier.
* Change NSXPCProxyCreating methods to be strongly typed
I got rid of the NSXpcProxyCreating interface in this change,
because its only user was NSXpcConnection, and I needed to
inline the protocol methods into the class definition so I
could mark them as [Internal].
* Add missing casts
* Add NSXpcConnectionOptions enum
* Convert NSXpcConnection constructor to use new enum
* Remove now-unneeded manual constructor
* Fix bgen warning
* Typo fix
* Fix selector
* Remove incorrect use of BindAsAttribute
Per the docs, this only works for enums backed
by NSNumber and NSValue, not for enums
passed directly as integers.
* Fix duplicated selector errors
* Throw ArgumentException instead of InvalidOperationException
* Extend AppExtension targets to produce XPC services
Rather than create an entirely new set of targets
(that would require VS and VSMac updates to properly
consume), I have decided to use the existing AppExtension
build targets to produce XPC services as well. All the
user must do is set the $(IsXPCService) property to true in
their project file, and the targets will do The Right Thing™.
Note that this support is Mac-only for now; I may need a bit
of help adjusting them to work on for iOS/watchOS/tvOS, as I
am not as familiar with those platforms.
* Copy XPC service bundles into the correct location
* Move IsXPCService property definition to props file
* Don't pass /extension to mmp for XPC service targets
This would cause the XPC service binary to
be linked incorrectly.
* Add NSXpcConnection/NSXpcInterface.cs files to the build
* Fix build
* Fix build
* Add required type parameter requirements
* Fix type parameter requirements
* Fix return type
* Fix return type of NSXpcInterface.CreateForProtocol ()
* Take ownership of the returned object types
* Adjust XPC service mmp invocation
I need to link the XPC service bundle as if it is an app extension, but
I must not use xamarin_mac_extension_main. I added a new flag to make
this possible.
* Change mmp to correctly construct XPC service bundle
* Set the MonoBundleExecutable Info.plist key for XPC services
* Use the runtime to get the protocol
* Make NSXpcInterface.CreateForProtocol() public
The static registrar must be used for Cocoa to accept the protocol
as a valid XPC interface, but that then seems to break resolving
the protocol from the type. I must therefore hard-code the protocol
name in my code, and that requires I make this constructor public.
* Add XpcInterfaceAttribute
See the doc comment in XpcInterfaceAttribute.cs for why
this type is required. The referenced mmp optimizations
will be added in future commits.
* Add XpcInterfaceAttribute to generator build
* Add support for XpcInterfaceAttribute to the generator
* Force static generation of protocols decorated with XpcInterfaceAttribute
* Change how static registrar translates block parameters
Previously, they would always be marshalled as "id".
This would throw off the XPC subsystem, which parses
the block signature to determine the communication
protocol.
* Undo whitespace noise
* Remove unneeded casts
* Add trailing comma
* Use HasAttribute instead of GetCustomAttribute
* Fix style issues
* Bind NSXpcConnection.auditSessionIdentifier
* Address naming feedback
* Make Get/SetAllowedClasses public
IMHO, passing the selector as a string is just as
usable as passing a MethodInfo, and is also less
verbose if you copy/paste the selector string
from the ExportAttribute. There is no reason why
we cannot have both overloads be public.
* Update overload names to match
* Update more overload names to match
* Make mmp --xpc imply --extension
* Reformat if statement
* Fix build
* Conditionalize creation of PlugIns and XPCServices directories
* Add AutoGeneratedName
Co-Authored-By: Rolf Bjarne Kvinge <rolf@xamarin.com>
* Get rid of ProtocolizeAttribute
* Update availability attributes to please xharness
I actually think xharness is wrong here, since the
NSXPCConnection header lists these types as being
available starting in macOS 10.8.
* Update sharpie ignore files to reflect changes
This should fix the xtro-sharpie test failures CI has been reporting.
* Fix MM4105 error generation
* Adjust error message in test to match mmp
I had to change the error text slightly, because the type of the parameter
cannot be determined where the error is thrown anymore. However, the newer
exception message IMO is just as clear.
* Make exception message match test exactly
* Remove outdated copyright header text
* Remove more outdated copyright header text
* Revert changes to MM4105 error generation
I have a more elegant way of fixing this test now.
* Return "id" if Invoke method cannot be found
This fixes the MM4105 error unit test,
without requiring modification to that test.
* Remove redundant availability attributes
* Add DesignatedInitializerAttribute
* Re-add required code to macOS-Foundation.ignore
* Put DesignatedInitializer on the right constructor
* Update xtro-sharpie ignore files
2019-10-22 16:38:01 +03:00
string bundle_ext ;
if ( is_extension & & is_xpc_service )
bundle_ext = "xpc" ;
else if ( is_extension )
bundle_ext = "appex" ;
else
bundle_ext = "app" ;
App . AppDirectory = Path . Combine ( output_dir , string . Format ( "{0}.{1}" , app_name , bundle_ext ) ) ;
2017-04-28 19:09:03 +03:00
contents_dir = Path . Combine ( App . AppDirectory , "Contents" ) ;
macos_dir = Path . Combine ( contents_dir , "MacOS" ) ;
}
2016-05-26 00:20:33 +03:00
2016-04-21 15:57:02 +03:00
frameworks_dir = Path . Combine ( contents_dir , "Frameworks" ) ;
resources_dir = Path . Combine ( contents_dir , "Resources" ) ;
2020-05-13 16:35:20 +03:00
mmp_dir = Path . Combine ( contents_dir , App . CustomBundleName ) ;
2016-04-21 15:57:02 +03:00
CreateDirectoryIfNeeded ( App . AppDirectory ) ;
CreateDirectoryIfNeeded ( contents_dir ) ;
CreateDirectoryIfNeeded ( macos_dir ) ;
CreateDirectoryIfNeeded ( resources_dir ) ;
CreateDirectoryIfNeeded ( mmp_dir ) ;
2017-04-28 19:09:03 +03:00
if ( App . Embeddinator ) {
CreateSymlink ( Path . Combine ( App . AppDirectory , "Versions" , "Current" ) , "A" ) ;
CreateSymlink ( Path . Combine ( App . AppDirectory , app_name ) , $"Versions/Current/{app_name}" ) ;
CreateSymlink ( Path . Combine ( App . AppDirectory , "Resources" ) , "Versions/Current/Resources" ) ;
}
}
// Mono.Unix can't create symlinks to relative paths, it insists on the target to a full path before creating the symlink.
static void CreateSymlink ( string file , string target )
{
unlink ( file ) ; // Delete any existing symlinks.
var rv = symlink ( target , file ) ;
if ( rv ! = 0 )
2020-01-31 23:02:52 +03:00
throw ErrorHelper . CreateError ( 1034 , Errors . MM1034 , file , target , Marshal . GetLastWin32Error ( ) ) ;
2016-04-21 15:57:02 +03:00
}
static void CreateDirectoryIfNeeded ( string dir ) {
if ( ! Directory . Exists ( dir ) )
Directory . CreateDirectory ( dir ) ;
}
static void CopyConfiguration ( ) {
if ( IsUnifiedMobile ) {
CopyResourceFile ( "config_mobile" , "config" ) ;
}
else {
if ( IsUnifiedFullXamMacFramework ) {
CopyResourceFile ( "machine.4_5.config" , "machine.config" ) ;
}
else {
string machine_config = Path . Combine ( MonoDirectory , "etc" , "mono" , "4.5" , "machine.config" ) ;
if ( ! File . Exists ( machine_config ) )
2020-05-14 17:45:05 +03:00
throw new ProductException ( 1403 , true , Errors . MM1403 , "File" , machine_config , TargetFramework ) ;
2016-04-21 15:57:02 +03:00
File . Copy ( machine_config , Path . Combine ( mmp_dir , "machine.config" ) , true ) ;
}
CopyResourceFile ( "config" , "config" ) ;
}
2016-10-13 18:42:05 +03:00
if ( machine_config_path ! = null ) {
string machineConfigDestDir = Path . Combine ( mmp_dir , "mono/4.5/" ) ;
string machineConfigDestFile = Path . Combine ( machineConfigDestDir , "machine.config" ) ;
CreateDirectoryIfNeeded ( machineConfigDestDir ) ;
if ( machine_config_path = = String . Empty ) {
File . WriteAllLines ( machineConfigDestFile , new string [ ] { "<?xml version=\"1.0\" encoding=\"utf-8\"?>" , "<configuration>" , "</configuration>" } ) ;
}
else {
if ( ! File . Exists ( machine_config_path ) )
2020-05-14 17:45:05 +03:00
throw new ProductException ( 97 , true , Errors . MM0097 , machine_config_path ) ;
2016-10-13 18:42:05 +03:00
File . Copy ( machine_config_path , machineConfigDestFile ) ;
}
}
2016-04-21 15:57:02 +03:00
}
static void CopyResourceFile ( string streamName , string outputFileName ) {
var sr = new StreamReader ( typeof ( Driver ) . Assembly . GetManifestResourceStream ( streamName ) ) ;
var all = sr . ReadToEnd ( ) ;
var config = Path . Combine ( mmp_dir , outputFileName ) ;
using ( var sw = new StreamWriter ( config ) ) {
sw . WriteLine ( all ) ;
}
}
static void CopyI18nAssemblies ( I18nAssemblies i18n )
{
if ( i18n = = I18nAssemblies . None )
return ;
string fx_dir = BuildTarget . Resolver . FrameworkDirectory ;
// always needed (if any is specified)
resolved_assemblies . Add ( Path . Combine ( fx_dir , "I18N.dll" ) ) ;
// optionally needed
if ( ( i18n & I18nAssemblies . CJK ) ! = 0 )
resolved_assemblies . Add ( Path . Combine ( fx_dir , "I18N.CJK.dll" ) ) ;
if ( ( i18n & I18nAssemblies . MidEast ) ! = 0 )
resolved_assemblies . Add ( Path . Combine ( fx_dir , "I18N.MidEast.dll" ) ) ;
if ( ( i18n & I18nAssemblies . Other ) ! = 0 )
resolved_assemblies . Add ( Path . Combine ( fx_dir , "I18N.Other.dll" ) ) ;
if ( ( i18n & I18nAssemblies . Rare ) ! = 0 )
resolved_assemblies . Add ( Path . Combine ( fx_dir , "I18N.Rare.dll" ) ) ;
if ( ( i18n & I18nAssemblies . West ) ! = 0 )
resolved_assemblies . Add ( Path . Combine ( fx_dir , "I18N.West.dll" ) ) ;
}
2016-05-25 23:29:33 +03:00
static void CopyFileAndRemoveReadOnly ( string src , string dest ) {
File . Copy ( src , dest , true ) ;
FileAttributes attrs = File . GetAttributes ( dest ) ;
if ( ( attrs & FileAttributes . ReadOnly ) = = FileAttributes . ReadOnly )
File . SetAttributes ( dest , attrs & ~ FileAttributes . ReadOnly ) ;
}
2016-04-21 15:57:02 +03:00
static void CopyAssemblies ( ) {
foreach ( string asm in resolved_assemblies ) {
var configfile = string . Format ( "{0}.config" , asm ) ;
string filename = Path . GetFileName ( asm ) ;
2016-05-25 23:29:33 +03:00
// The linker later gets angry if you copy in a read only assembly
CopyFileAndRemoveReadOnly ( asm , Path . Combine ( mmp_dir , filename ) ) ;
2017-02-01 03:59:08 +03:00
2020-02-18 23:44:19 +03:00
Log ( 1 , "Added assembly {0}" , asm ) ;
2016-04-21 15:57:02 +03:00
2020-05-13 09:40:07 +03:00
if ( App . PackageManagedDebugSymbols ) {
2017-04-13 00:38:54 +03:00
var mdbfile = asm + ".mdb" ;
if ( File . Exists ( mdbfile ) )
2018-03-01 18:36:06 +03:00
CopyFileAndRemoveReadOnly ( mdbfile , Path . Combine ( mmp_dir , Path . GetFileName ( mdbfile ) ) ) ;
2017-04-13 00:38:54 +03:00
var pdbfile = Path . ChangeExtension ( asm , ".pdb" ) ;
if ( File . Exists ( pdbfile ) )
2018-03-01 18:36:06 +03:00
CopyFileAndRemoveReadOnly ( pdbfile , Path . Combine ( mmp_dir , Path . GetFileName ( pdbfile ) ) ) ;
2017-04-13 00:38:54 +03:00
}
2016-04-21 15:57:02 +03:00
if ( File . Exists ( configfile ) )
File . Copy ( configfile , Path . Combine ( mmp_dir , Path . GetFileName ( configfile ) ) , true ) ;
}
2017-02-01 03:59:08 +03:00
foreach ( var assembly in BuildTarget . Assemblies )
assembly . CopySatellitesToDirectory ( mmp_dir ) ;
2016-04-21 15:57:02 +03:00
}
static void CopyResources ( ) {
foreach ( string res in resources ) {
File . Copy ( res , Path . Combine ( resources_dir , Path . GetFileName ( res ) ) , true ) ;
}
}
static void GatherAssemblies ( ) {
2020-05-05 16:35:02 +03:00
foreach ( string asm in App . References ) {
2017-08-23 17:31:02 +03:00
AssemblyDefinition assembly = AddAssemblyPathToResolver ( asm ) ;
2016-04-21 15:57:02 +03:00
ProcessAssemblyReferences ( assembly ) ;
}
if ( BuildTarget . Resolver . Exceptions . Count > 0 )
throw new AggregateException ( BuildTarget . Resolver . Exceptions ) ;
}
static void ProcessAssemblyReferences ( AssemblyDefinition assembly ) {
if ( assembly = = null )
return ;
2016-08-24 16:43:35 +03:00
var fqname = GetRealPath ( assembly . MainModule . FileName ) ;
2016-04-21 15:57:02 +03:00
if ( resolved_assemblies . Contains ( fqname ) )
return ;
[mtouch/mmp] Print assembly references in verbose mode. (#2139)
* [mtouch/mmp] Print assembly references in verbose mode.
Sample output:
Loaded assembly 'unifiedtestapp, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' from /Users/rolf/Projects/TestApp/bin/iPhoneSimulator/Debug/unifiedtestapp.exe
References: mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
References: Xamarin.iOS, Version=0.0.0.0, Culture=neutral, PublicKeyToken=84e04ff9cfb79065
Loaded assembly 'mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e' from /work/maccore/master/xamarin-macios/_ios-build/Library/Frameworks/Xamarin.iOS.framework/Versions/git/lib/mono/Xamarin.iOS/mscorlib.dll
Loaded assembly 'Xamarin.iOS, Version=0.0.0.0, Culture=neutral, PublicKeyToken=84e04ff9cfb79065' from /work/maccore/master/xamarin-macios/_ios-build/Library/Frameworks/Xamarin.iOS.framework/Versions/git/lib/mono/Xamarin.iOS/../../64bits/Xamarin.iOS.dll
References: mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
References: System, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
References: System.Core, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
References: Mono.Security, Version=2.0.5.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756
References: System.Xml, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
Loaded assembly 'System, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e' from /work/maccore/master/xamarin-macios/_ios-build/Library/Frameworks/Xamarin.iOS.framework/Versions/git/lib/mono/Xamarin.iOS/System.dll
References: mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
References: Mono.Security, Version=2.0.5.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756
References: System.Xml, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
Loaded assembly 'Mono.Security, Version=2.0.5.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756' from /work/maccore/master/xamarin-macios/_ios-build/Library/Frameworks/Xamarin.iOS.framework/Versions/git/lib/mono/Xamarin.iOS/Mono.Security.dll
References: mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
References: System, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
Loaded assembly 'System.Xml, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e' from /work/maccore/master/xamarin-macios/_ios-build/Library/Frameworks/Xamarin.iOS.framework/Versions/git/lib/mono/Xamarin.iOS/System.Xml.dll
References: mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
References: System, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
Loaded assembly 'System.Core, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e' from /work/maccore/master/xamarin-macios/_ios-build/Library/Frameworks/Xamarin.iOS.framework/Versions/git/lib/mono/Xamarin.iOS/System.Core.dll
References: mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
References: System, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
I believe this will make it easier to diagnose cases where something references a desktop assembly.
* [mtouch/mmp] Share more code between mmp and mtouch.
2017-05-29 17:15:22 +03:00
Target . PrintAssemblyReferences ( assembly ) ;
2016-04-21 15:57:02 +03:00
2020-07-17 17:38:40 +03:00
var asm = BuildTarget . AddAssembly ( assembly ) ;
2017-02-01 03:59:08 +03:00
asm . ComputeSatellites ( ) ;
2016-04-21 15:57:02 +03:00
resolved_assemblies . Add ( fqname ) ;
foreach ( AssemblyNameReference reference in assembly . MainModule . AssemblyReferences ) {
2020-04-14 17:32:42 +03:00
AssemblyDefinition reference_assembly = AddAssemblyReferenceToResolver ( reference ) ;
2016-04-21 15:57:02 +03:00
ProcessAssemblyReferences ( reference_assembly ) ;
}
}
2017-08-23 17:31:02 +03:00
static AssemblyDefinition AddAssemblyPathToResolver ( string path )
{
if ( AssemblySwapInfo . AssemblyNeedsSwappedOut ( path ) )
path = AssemblySwapInfo . GetSwappedAssemblyPath ( path ) ;
2018-01-13 01:39:38 +03:00
var assembly = BuildTarget . Resolver . Load ( path ) ;
2017-08-23 17:31:02 +03:00
if ( assembly = = null )
2020-01-31 23:02:52 +03:00
ErrorHelper . Warning ( 1501 , Errors . MM1501 , path ) ;
2017-08-23 17:31:02 +03:00
return assembly ;
}
2020-04-14 17:32:42 +03:00
static AssemblyDefinition AddAssemblyReferenceToResolver ( AssemblyNameReference reference )
2017-08-23 17:31:02 +03:00
{
2020-04-14 17:32:42 +03:00
if ( AssemblySwapInfo . ReferencedNeedsSwappedOut ( reference . Name ) )
return BuildTarget . Resolver . Load ( AssemblySwapInfo . GetSwappedReference ( reference . Name ) ) ;
2017-08-23 17:31:02 +03:00
return BuildTarget . Resolver . Resolve ( reference ) ;
}
}
public static class AssemblySwapInfo {
static HashSet < string > xammac_reference_assemblies_names = new HashSet < string > {
"Xamarin.Mac" ,
"Xamarin.Mac.CFNetwork" ,
"OpenTK"
} ;
public static bool AssemblyNeedsSwappedOut ( string path ) = > NeedsSwappedCore ( Path . GetFileNameWithoutExtension ( path ) ) ;
public static bool ReferencedNeedsSwappedOut ( string reference ) = > NeedsSwappedCore ( reference ) ;
static bool NeedsSwappedCore ( string name )
{
if ( name . Contains ( "OpenTK" ) & & Driver . IsUnifiedFullXamMacFramework )
return false ;
2019-07-24 19:01:14 +03:00
return xammac_reference_assemblies_names . Contains ( name ) ;
2017-08-23 17:31:02 +03:00
}
public static string GetSwappedAssemblyPath ( string path ) = > GetSwappedPathCore ( Path . GetFileNameWithoutExtension ( path ) ) ;
public static string GetSwappedReference ( string reference ) = > GetSwappedPathCore ( reference ) ;
static string GetSwappedPathCore ( string name )
2016-04-21 15:57:02 +03:00
{
2017-08-23 17:31:02 +03:00
string flavor = ( Driver . IsUnifiedFullSystemFramework | | Driver . IsUnifiedFullXamMacFramework ) ? "full" : "mobile" ;
2020-05-11 17:27:19 +03:00
var abi = Driver . App . Abi ;
var arch = abi . AsArchString ( ) ;
switch ( abi ) {
case Abi . x86_64 :
Xamarin.Mac native Apple Silicon targetting support (#10115)
* Add support for Xamarin.Mac arm64
* Add compile product definition task
Xamarin.Mac can be provided with a ProductDefinition file for the generated pkg. Normally, providing a product definition was optional. However, with Apple Silicon, we have an extra issue : `productbuild` needs to know what architectures your package target. If not provided with them, it will guess to the best of its abilities. However, on Catalina and lower, the guess is x86_64, even if you have an arm64 slice. To fix this, we add a new task to compile the product definition and use this file to create the pkg. If you provide your own Product Definition, we can check and warn if the architectures don't match what we expect. If the file doesn't exist or there is no architecture, we set it ourselves based on our target architectures.
* Don't reference dynamic objC_send on arm64
When building in debug, we currently try to link dynamic objC_send symbols when targeting a 64-bit architecture. However, this is actually only defined on Intel architectures, not on arm64, so we end up failing because we're referring symbols that don't exist. Rework the `GetRequiredSymbols` to take an abi, and tag those symbols to only be valid on i386/x86_64, so they don't get referred at all when building on arm64, but still get referred in x86_64.
* Fix improper delete/move with already existing directories
* Fix stret requirement for Xamarin.Mac in arm64.
The generator supposes that we're running in x64 mode, refactor to take into account the possibility of running in arm64.
* Implement OS version generation in Product.plist, based on MinimumSystemVersion of the app
* Re-generalize some mmp registrar rules
`Microsoft.macOS.registrar` was missed by the current rule set
* Fix mmp tests
* Set E7072 as not translated
Tests were failing otherwise
* Rename Xamarin.Mac lib/x86_64 folder to 64bits (currently all targeted archs are the same)
* Fix style issues
* Fix `ToLower` usage for invariant usage
* Fix xtro-sharpie test
2021-03-18 04:48:02 +03:00
case Abi . ARM64 :
return Path . Combine ( Driver . GetFrameworkLibDirectory ( Driver . App ) , "64bits" , flavor , name + ".dll" ) ;
2016-04-21 15:57:02 +03:00
default :
2020-05-14 17:45:05 +03:00
throw new ProductException ( 5205 , true , Errors . MM5205 , arch ) ;
2016-04-21 15:57:02 +03:00
}
}
}
}