@nativescript/ios 8.6.4-next.2024-03-09-8212029414 → 8.6.4

package/framework/internal/metadata-generator-arm64/bin/build-step-metadata-generator.py

@@ -178,11 +178,5 @@ def generate_metadata(arch):
 
 
 for arch in env("ARCHS").split():
-    # skip metadata generation for architectures different than the one specified in the command line
-    # in case the command line argument is not specified, generate metadata for all architectures
-    if len(sys.argv) >= 2 and sys.argv[1].lower() != arch.lower():
-        print("Skipping metadata generation for " + arch)
-        continue
-
     print("Generating metadata for " + arch)
     generate_metadata(arch)

package/framework/internal/metadata-generator-arm64/bin/lib/clang/{15.0.7 → 13.0.1}/include/__clang_cuda_complex_builtins.h

@@ -16,7 +16,7 @@
 // to work with CUDA and OpenMP target offloading [in C and C++ mode].)
 
 #pragma push_macro("__DEVICE__")
-#if defined(__OPENMP_NVPTX__) || defined(__OPENMP_AMDGCN__)
+#ifdef __OPENMP_NVPTX__
 #pragma omp declare target
 #define __DEVICE__ __attribute__((noinline, nothrow, cold, weak))
 #else
@@ -26,7 +26,7 @@
 // To make the algorithms available for C and C++ in CUDA and OpenMP we select
 // different but equivalent function versions. TODO: For OpenMP we currently
 // select the native builtins as the overload support for templates is lacking.
-#if !defined(__OPENMP_NVPTX__) && !defined(__OPENMP_AMDGCN__)
+#if !defined(__OPENMP_NVPTX__)
 #define _ISNANd std::isnan
 #define _ISNANf std::isnan
 #define _ISINFd std::isinf
@@ -276,7 +276,7 @@ __DEVICE__ float _Complex __divsc3(float __a, float __b, float __c, float __d) {
 #undef _fmaxd
 #undef _fmaxf
 
-#if defined(__OPENMP_NVPTX__) || defined(__OPENMP_AMDGCN__)
+#ifdef __OPENMP_NVPTX__
 #pragma omp end declare target
 #endif
 

package/framework/internal/metadata-generator-arm64/bin/lib/clang/{15.0.7 → 13.0.1}/include/__clang_cuda_intrinsics.h

@@ -71,8 +71,8 @@
   }                                                                            \
   inline __device__ unsigned long long __FnName(                               \
       unsigned long long __val, __Type __offset, int __width = warpSize) {     \
-    return static_cast<unsigned long long>(                                    \
-        ::__FnName(static_cast<long long>(__val), __offset, __width));         \
+    return static_cast<unsigned long long>(::__FnName(                         \
+        static_cast<unsigned long long>(__val), __offset, __width));           \
   }                                                                            \
   inline __device__ double __FnName(double __val, __Type __offset,             \
                                     int __width = warpSize) {                  \
@@ -139,8 +139,8 @@ __MAKE_SHUFFLES(__shfl_xor, __nvvm_shfl_bfly_i32, __nvvm_shfl_bfly_f32, 0x1f,
   inline __device__ unsigned long long __FnName(                               \
       unsigned int __mask, unsigned long long __val, __Type __offset,          \
       int __width = warpSize) {                                                \
-    return static_cast<unsigned long long>(                                    \
-        ::__FnName(__mask, static_cast<long long>(__val), __offset, __width)); \
+    return static_cast<unsigned long long>(::__FnName(                         \
+        __mask, static_cast<unsigned long long>(__val), __offset, __width));   \
   }                                                                            \
   inline __device__ long __FnName(unsigned int __mask, long __val,             \
                                   __Type __offset, int __width = warpSize) {   \
@@ -234,7 +234,7 @@ inline __device__ unsigned int __match32_any_sync(unsigned int mask,
   return __nvvm_match_any_sync_i32(mask, value);
 }
 
-inline __device__ unsigned int
+inline __device__ unsigned long long
 __match64_any_sync(unsigned int mask, unsigned long long value) {
   return __nvvm_match_any_sync_i64(mask, value);
 }
@@ -244,7 +244,7 @@ __match32_all_sync(unsigned int mask, unsigned int value, int *pred) {
   return __nvvm_match_all_sync_i32p(mask, value, pred);
 }
 
-inline __device__ unsigned int
+inline __device__ unsigned long long
 __match64_all_sync(unsigned int mask, unsigned long long value, int *pred) {
   return __nvvm_match_all_sync_i64p(mask, value, pred);
 }
@@ -483,36 +483,4 @@ inline __device__ unsigned __funnelshift_rc(unsigned low32, unsigned high32,
 
 #endif // !defined(__CUDA_ARCH__) || __CUDA_ARCH__ >= 320
 
-#if CUDA_VERSION >= 11000
-extern "C" {
-__device__ inline size_t __nv_cvta_generic_to_global_impl(const void *__ptr) {
-  return (size_t)(void __attribute__((address_space(1))) *)__ptr;
-}
-__device__ inline size_t __nv_cvta_generic_to_shared_impl(const void *__ptr) {
-  return (size_t)(void __attribute__((address_space(3))) *)__ptr;
-}
-__device__ inline size_t __nv_cvta_generic_to_constant_impl(const void *__ptr) {
-  return (size_t)(void __attribute__((address_space(4))) *)__ptr;
-}
-__device__ inline size_t __nv_cvta_generic_to_local_impl(const void *__ptr) {
-  return (size_t)(void __attribute__((address_space(5))) *)__ptr;
-}
-__device__ inline void *__nv_cvta_global_to_generic_impl(size_t __ptr) {
-  return (void *)(void __attribute__((address_space(1))) *)__ptr;
-}
-__device__ inline void *__nv_cvta_shared_to_generic_impl(size_t __ptr) {
-  return (void *)(void __attribute__((address_space(3))) *)__ptr;
-}
-__device__ inline void *__nv_cvta_constant_to_generic_impl(size_t __ptr) {
-  return (void *)(void __attribute__((address_space(4))) *)__ptr;
-}
-__device__ inline void *__nv_cvta_local_to_generic_impl(size_t __ptr) {
-  return (void *)(void __attribute__((address_space(5))) *)__ptr;
-}
-__device__ inline cuuint32_t __nvvm_get_smem_pointer(void *__ptr) {
-  return __nv_cvta_generic_to_shared_impl(__ptr);
-}
-} // extern "C"
-#endif // CUDA_VERSION >= 11000
-
 #endif // defined(__CLANG_CUDA_INTRINSICS_H__)

package/framework/internal/{metadata-generator-x86_64/bin/lib/clang/15.0.7 → metadata-generator-arm64/bin/lib/clang/13.0.1}/include/__clang_cuda_libdevice_declares.h

@@ -16,7 +16,6 @@ extern "C" {
 
 #if defined(__OPENMP_NVPTX__)
 #define __DEVICE__
-#pragma omp begin assumes ext_spmd_amenable no_openmp
 #elif defined(__CUDA__)
 #define __DEVICE__ __device__
 #endif
@@ -457,11 +456,6 @@ __DEVICE__ double __nv_y1(double __a);
 __DEVICE__ float __nv_y1f(float __a);
 __DEVICE__ float __nv_ynf(int __a, float __b);
 __DEVICE__ double __nv_yn(int __a, double __b);
-
-#if defined(__OPENMP_NVPTX__)
-#pragma omp end assumes ext_spmd_amenable no_openmp
-#endif
-
 #if defined(__cplusplus)
 } // extern "C"
 #endif

package/framework/internal/{metadata-generator-x86_64/bin/lib/clang/15.0.7 → metadata-generator-arm64/bin/lib/clang/13.0.1}/include/__clang_cuda_math.h

@@ -345,4 +345,4 @@ __DEVICE__ float ynf(int __a, float __b) { return __nv_ynf(__a, __b); }
 #pragma pop_macro("__DEVICE_VOID__")
 #pragma pop_macro("__FAST_OR_SLOW")
 
-#endif // __CLANG_CUDA_MATH_H__
+#endif // __CLANG_CUDA_DEVICE_FUNCTIONS_H__

package/framework/internal/metadata-generator-arm64/bin/lib/clang/{15.0.7 → 13.0.1}/include/__clang_cuda_runtime_wrapper.h

@@ -65,9 +65,9 @@
 #endif
 
 // Make largest subset of device functions available during host
-// compilation.
+// compilation -- SM_35 for the time being.
 #ifndef __CUDA_ARCH__
-#define __CUDA_ARCH__ 9999
+#define __CUDA_ARCH__ 350
 #endif
 
 #include "__clang_cuda_builtin_vars.h"
@@ -271,38 +271,7 @@ static inline __device__ void __brkpt(int __c) { __brkpt(); }
 #undef __CUDABE__
 #endif
 #include "sm_20_atomic_functions.hpp"
-// Predicate functions used in `__builtin_assume` need to have no side effect.
-// However, sm_20_intrinsics.hpp doesn't define them with neither pure nor
-// const attribute. Rename definitions from sm_20_intrinsics.hpp and re-define
-// them as pure ones.
-#pragma push_macro("__isGlobal")
-#pragma push_macro("__isShared")
-#pragma push_macro("__isConstant")
-#pragma push_macro("__isLocal")
-#define __isGlobal __ignored_cuda___isGlobal
-#define __isShared __ignored_cuda___isShared
-#define __isConstant __ignored_cuda___isConstant
-#define __isLocal __ignored_cuda___isLocal
 #include "sm_20_intrinsics.hpp"
-#pragma pop_macro("__isGlobal")
-#pragma pop_macro("__isShared")
-#pragma pop_macro("__isConstant")
-#pragma pop_macro("__isLocal")
-#pragma push_macro("__DEVICE__")
-#define __DEVICE__ static __device__ __forceinline__ __attribute__((const))
-__DEVICE__ unsigned int __isGlobal(const void *p) {
-  return __nvvm_isspacep_global(p);
-}
-__DEVICE__ unsigned int __isShared(const void *p) {
-  return __nvvm_isspacep_shared(p);
-}
-__DEVICE__ unsigned int __isConstant(const void *p) {
-  return __nvvm_isspacep_const(p);
-}
-__DEVICE__ unsigned int __isLocal(const void *p) {
-  return __nvvm_isspacep_local(p);
-}
-#pragma pop_macro("__DEVICE__")
 #include "sm_32_atomic_functions.hpp"
 
 // Don't include sm_30_intrinsics.h and sm_32_intrinsics.h.  These define the
@@ -357,34 +326,6 @@ __DEVICE__ unsigned int __isLocal(const void *p) {
 
 #pragma pop_macro("__host__")
 
-// __clang_cuda_texture_intrinsics.h must be included first in order to provide
-// implementation for __nv_tex_surf_handler that CUDA's headers depend on.
-// The implementation requires c++11 and only works with CUDA-9 or newer.
-#if __cplusplus >= 201103L && CUDA_VERSION >= 9000
-// clang-format off
-#include <__clang_cuda_texture_intrinsics.h>
-// clang-format on
-#else
-#if CUDA_VERSION >= 9000
-// Provide a hint that texture support needs C++11.
-template <typename T> struct __nv_tex_needs_cxx11 {
-  const static bool value = false;
-};
-template <class T>
-__host__ __device__ void __nv_tex_surf_handler(const char *name, T *ptr,
-                                               cudaTextureObject_t obj,
-                                               float x) {
-  _Static_assert(__nv_tex_needs_cxx11<T>::value,
-                 "Texture support requires C++11");
-}
-#else
-// Textures in CUDA-8 and older are not supported by clang.There's no
-// convenient way to intercept texture use in these versions, so we can't
-// produce a meaningful error. The source code that attempts to use textures
-// will continue to fail as it does now.
-#endif // CUDA_VERSION
-#endif // __cplusplus >= 201103L && CUDA_VERSION >= 9000
-#include "texture_fetch_functions.h"
 #include "texture_indirect_functions.h"
 
 // Restore state of __CUDA_ARCH__ and __THROW we had on entry.

package/framework/internal/{metadata-generator-x86_64/bin/lib/clang/15.0.7 → metadata-generator-arm64/bin/lib/clang/13.0.1}/include/__clang_hip_runtime_wrapper.h

@@ -50,9 +50,6 @@ extern "C" {
 #include <cmath>
 #include <cstdlib>
 #include <stdlib.h>
-#if __has_include("hip/hip_version.h")
-#include "hip/hip_version.h"
-#endif // __has_include("hip/hip_version.h")
 #else
 typedef __SIZE_TYPE__ size_t;
 // Define macros which are needed to declare HIP device API's without standard
@@ -77,35 +74,25 @@ typedef __SIZE_TYPE__ __hip_size_t;
 extern "C" {
 #endif //__cplusplus
 
-#if HIP_VERSION_MAJOR * 100 + HIP_VERSION_MINOR >= 405
-extern "C" __device__ unsigned long long __ockl_dm_alloc(unsigned long long __size);
-extern "C" __device__ void __ockl_dm_dealloc(unsigned long long __addr);
-__attribute__((weak)) inline __device__ void *malloc(__hip_size_t __size) {
-  return (void *) __ockl_dm_alloc(__size);
-}
-__attribute__((weak)) inline __device__ void free(void *__ptr) {
-  __ockl_dm_dealloc((unsigned long long)__ptr);
-}
-#else  // HIP version check
 #if __HIP_ENABLE_DEVICE_MALLOC__
 __device__ void *__hip_malloc(__hip_size_t __size);
 __device__ void *__hip_free(void *__ptr);
 __attribute__((weak)) inline __device__ void *malloc(__hip_size_t __size) {
   return __hip_malloc(__size);
 }
-__attribute__((weak)) inline __device__ void free(void *__ptr) {
-  __hip_free(__ptr);
+__attribute__((weak)) inline __device__ void *free(void *__ptr) {
+  return __hip_free(__ptr);
 }
 #else
 __attribute__((weak)) inline __device__ void *malloc(__hip_size_t __size) {
   __builtin_trap();
   return (void *)0;
 }
-__attribute__((weak)) inline __device__ void free(void *__ptr) {
+__attribute__((weak)) inline __device__ void *free(void *__ptr) {
   __builtin_trap();
+  return (void *)0;
 }
 #endif
-#endif // HIP version check
 
 #ifdef __cplusplus
 } // extern "C"

package/framework/internal/{metadata-generator-x86_64/bin/lib/clang/15.0.7 → metadata-generator-arm64/bin/lib/clang/13.0.1}/include/__wmmintrin_aes.h

@@ -133,7 +133,7 @@ _mm_aesimc_si128(__m128i __V)
 ///    An 8-bit round constant used to generate the AES encryption key.
 /// \returns A 128-bit round key for AES encryption.
 #define _mm_aeskeygenassist_si128(C, R) \
-  ((__m128i)__builtin_ia32_aeskeygenassist128((__v2di)(__m128i)(C), (int)(R)))
+  (__m128i)__builtin_ia32_aeskeygenassist128((__v2di)(__m128i)(C), (int)(R))
 
 #undef __DEFAULT_FN_ATTRS
 

package/framework/internal/{metadata-generator-x86_64/bin/lib/clang/15.0.7 → metadata-generator-arm64/bin/lib/clang/13.0.1}/include/__wmmintrin_pclmul.h

@@ -22,23 +22,23 @@
 /// \headerfile <x86intrin.h>
 ///
 /// \code
-/// __m128i _mm_clmulepi64_si128(__m128i X, __m128i Y, const int I);
+/// __m128i _mm_clmulepi64_si128(__m128i __X, __m128i __Y, const int __I);
 /// \endcode
 ///
 /// This intrinsic corresponds to the <c> VPCLMULQDQ </c> instruction.
 ///
-/// \param X
+/// \param __X
 ///    A 128-bit vector of [2 x i64] containing one of the source operands.
-/// \param Y
+/// \param __Y
 ///    A 128-bit vector of [2 x i64] containing one of the source operands.
-/// \param I
+/// \param __I
 ///    An immediate value specifying which 64-bit values to select from the
-///    operands. Bit 0 is used to select a value from operand \a X, and bit
-///    4 is used to select a value from operand \a Y: \n
-///    Bit[0]=0 indicates that bits[63:0] of operand \a X are used. \n
-///    Bit[0]=1 indicates that bits[127:64] of operand \a X are used. \n
-///    Bit[4]=0 indicates that bits[63:0] of operand \a Y are used. \n
-///    Bit[4]=1 indicates that bits[127:64] of operand \a Y are used.
+///    operands. Bit 0 is used to select a value from operand \a __X, and bit
+///    4 is used to select a value from operand \a __Y: \n
+///    Bit[0]=0 indicates that bits[63:0] of operand \a __X are used. \n
+///    Bit[0]=1 indicates that bits[127:64] of operand \a __X are used. \n
+///    Bit[4]=0 indicates that bits[63:0] of operand \a __Y are used. \n
+///    Bit[4]=1 indicates that bits[127:64] of operand \a __Y are used.
 /// \returns The 128-bit integer vector containing the result of the carry-less
 ///    multiplication of the selected 64-bit values.
 #define _mm_clmulepi64_si128(X, Y, I) \