Add modifications to support compiling on iOS.

Author: freakboy3742

docs/markdown/Dependencies.md

@@ -462,10 +462,11 @@ TODO
 
 Supports the BLAS and LAPACK components of macOS Accelerate, also referred to
 as the vecLib framework. ILP64 support is only available on macOS 13.3 and up.
-From macOS 13.3, Accelerate ships with two different builds of 32-bit (LP64)
-BLAS and LAPACK. Meson will default to the newer of those builds, by defining
-`ACCELERATE_NEW_LAPACK`, unless `MACOS_DEPLOYMENT_TARGET` is set to a version
-lower than 13.3.
+From macOS 13.3 and iOS 16.4, Accelerate ships with two different builds of
+32-bit (LP64) BLAS and LAPACK. Meson will default to the newer of those builds,
+by defining `ACCELERATE_NEW_LAPACK`, unless `MACOS_DEPLOYMENT_TARGET` is set to
+a version lower than 13.3, or `IPHONEOS_DEPLOYMENT_TARGET` is set to a version
+lower than 16.4.
 
 ```meson
 accelerate_dep = dependency('accelerate',

mesonbuild/dependencies/blas_lapack.py

@@ -738,7 +738,10 @@ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.
         self.parse_modules(kwargs)
 
         for_machine = MachineChoice.BUILD if kwargs.get('native', False) else MachineChoice.HOST
-        if environment.machines[for_machine].is_darwin() and self.check_macOS_recent_enough():
+        if (
+            (environment.machines[for_machine].system == 'darwin' and self.check_macOS_recent_enough())
+            or (environment.machines[for_machine].system == 'ios' and self.check_iOS_recent_enough())
+        ):
             self.detect(kwargs)
 
     def check_macOS_recent_enough(self) -> bool:
@@ -752,6 +755,18 @@ def check_macOS_recent_enough(self) -> bool:
         sdk_version = subprocess.run(cmd, capture_output=True, check=True, text=True).stdout.strip()
         return mesonlib.version_compare(sdk_version, '>=13.3')
 
+    def check_iOS_recent_enough(self) -> bool:
+        ios_version = platform.ios_ver().system
+        deploy_target = os.environ.get('IPHONEOS_DEPLOYMENT_TARGET', ios_version)
+        if not mesonlib.version_compare(deploy_target, '>=16.4'):
+            return False
+
+        # We also need the SDK to be >=16.4
+        sdk = "iphonesimulator" if platform.ios_ver().is_simulator else "iphoneos"
+        cmd = ['xcrun', '-sdk', sdk, '--show-sdk-version']
+        sdk_version = subprocess.run(cmd, capture_output=True, check=True, text=True).stdout.strip()
+        return mesonlib.version_compare(sdk_version, '>=16.4')
+
     def detect(self, kwargs: T.Dict[str, T.Any]) -> None:
         from .framework import ExtraFrameworkDependency
         dep = ExtraFrameworkDependency('Accelerate', self.env, kwargs)

mesonbuild/envconfig.py

@@ -310,9 +310,9 @@ def is_linux(self) -> bool:
 
     def is_darwin(self) -> bool:
         """
-        Machine is Darwin (iOS/tvOS/OS X)?
+        Machine is a Darwin kernel (macOS/iOS/tvOS/watchOS)?
         """
-        return self.system in {'darwin', 'ios', 'tvos'}
+        return self.system in {'darwin', 'ios', 'tvos', 'watchos'}
 
     def is_android(self) -> bool:
         """

mesonbuild/environment.py

@@ -447,6 +447,9 @@ def detect_cpu(compilers: CompilersDict) -> str:
                                         'linux': 'linux',
                                         'cygwin': 'nt',
                                         'darwin': 'xnu',
+                                        'ios': 'xnu',
+                                        'tvos': 'xnu',
+                                        'watchos': 'xnu',
                                         'dragonfly': 'dragonfly',
                                         'haiku': 'haiku',
                                         }

mesonbuild/linkers/detect.py

@@ -213,7 +213,10 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty
     elif 'xtools-' in o.split('\n', maxsplit=1)[0]:
         xtools = o.split(' ', maxsplit=1)[0]
         v = xtools.split('-', maxsplit=2)[1]
-        linker = linkers.AppleDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
+        linker = linkers.AppleDynamicLinker(
+            compiler, for_machine, comp_class.LINKER_PREFIX, override,
+            system=env.machines[for_machine].system, version=v
+        )
     # detect linker on MacOS - must be after other platforms because the
     # "(use -v to see invocation)" will match clang on other platforms,
     # but the rest of the checks will fail and call __failed_to_detect_linker.
@@ -232,7 +235,10 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty
                 break
         else:
             __failed_to_detect_linker(compiler, check_args, o, e)
-        linker = linkers.AppleDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
+        linker = linkers.AppleDynamicLinker(
+            compiler, for_machine, comp_class.LINKER_PREFIX, override,
+            system=env.machines[for_machine].system, version=v
+        )
     else:
         __failed_to_detect_linker(compiler, check_args, o, e)
     return linker

mesonbuild/linkers/linkers.py

@@ -130,9 +130,11 @@ def _apply_prefix(self, arg: T.Union[str, T.List[str]]) -> T.List[str]:
 
     def __init__(self, exelist: T.List[str],
                  for_machine: mesonlib.MachineChoice, prefix_arg: T.Union[str, T.List[str]],
-                 always_args: T.List[str], *, version: str = 'unknown version'):
+                 always_args: T.List[str], *, system: str = 'unknown system',
+                 version: str = 'unknown version'):
         self.exelist = exelist
         self.for_machine = for_machine
+        self.system = system
         self.version = version
         self.prefix_arg = prefix_arg
         self.always_args = always_args
@@ -758,10 +760,18 @@ def get_asneeded_args(self) -> T.List[str]:
         return self._apply_prefix('-dead_strip_dylibs')
 
     def get_allow_undefined_args(self) -> T.List[str]:
-        return self._apply_prefix('-undefined,dynamic_lookup')
+        # iOS doesn't allow undefined symbols when linking
+        if self.system == 'ios':
+            return []
+        else:
+            return self._apply_prefix('-undefined,dynamic_lookup')
 
     def get_std_shared_module_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
-        return ['-bundle'] + self._apply_prefix('-undefined,dynamic_lookup')
+        # iOS requires modules to be linked as dynamic libraries.
+        if self.system == 'ios':
+            return ["-dynamiclib"]
+        else:
+            return ['-bundle'] + self._apply_prefix('-undefined,dynamic_lookup')
 
     def get_pie_args(self) -> T.List[str]:
         return []

mesonbuild/utils/universal.py

@@ -118,13 +118,16 @@ class _VerPickleLoadable(Protocol):
     'is_freebsd',
     'is_haiku',
     'is_hurd',
+    'is_ios',
     'is_irix',
     'is_linux',
     'is_netbsd',
     'is_openbsd',
     'is_osx',
     'is_qnx',
     'is_sunos',
+    'is_tvos',
+    'is_watchos',
     'is_windows',
     'is_wsl',
     'iter_regexin_iter',
@@ -629,6 +632,18 @@ def is_osx() -> bool:
     return platform.system().lower() == 'darwin'
 
 
+def is_ios() -> bool:
+    return platform.system().lower() == 'ios'
+
+
+def is_tvos() -> bool:
+    return platform.system().lower() == 'tvos'
+
+
+def is_watchos() -> bool:
+    return platform.system().lower() == 'watchos'
+
+
 def is_linux() -> bool:
     return platform.system().lower() == 'linux'