Commit e3274067f8

@@ -4,6 +4,10 @@
 #ifndef _ARM__LIMITS_H_
 #define _ARM__LIMITS_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 #define __DARWIN_CLK_TCK                100     /* ticks per second */
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif  /* _ARM__LIMITS_H_ */
\ No newline at end of file

@@ -29,6 +29,8 @@
 #ifndef __ARM_MCONTEXT_H_
 #define __ARM_MCONTEXT_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 #include <sys/cdefs.h> /* __DARWIN_UNIX03 */
 #include <sys/appleapiopts.h>
 #include <mach/machine/_structs.h>
@@ -88,4 +90,6 @@ typedef _STRUCT_MCONTEXT32      *mcontext_t;
 #endif
 #endif /* _MCONTEXT_T */
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif /* __ARM_MCONTEXT_H_ */
\ No newline at end of file

@@ -5,6 +5,8 @@
 #ifndef _ARM__PARAM_H_
 #define _ARM__PARAM_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 #include <arm/_types.h>
 
 /*
@@ -18,5 +20,6 @@
 #define      __DARWIN_ALIGNBYTES32     (sizeof(__uint32_t) - 1)
 #define       __DARWIN_ALIGN32(p)       ((__darwin_size_t)((__darwin_size_t)(p) + __DARWIN_ALIGNBYTES32) &~ __DARWIN_ALIGNBYTES32)
 
+#endif /* defined (__arm__) || defined (__arm64__) */
 
 #endif /* _ARM__PARAM_H_ */
\ No newline at end of file

@@ -4,6 +4,8 @@
 #ifndef _BSD_ARM__TYPES_H_
 #define _BSD_ARM__TYPES_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 /*
  * This header file contains integer types.  It's intended to also contain
  * flotaing point and other arithmetic types, as needed, later.
@@ -95,4 +97,6 @@ typedef __uint32_t              __darwin_socklen_t;     /* socklen_t (duh) */
 typedef long                    __darwin_ssize_t;       /* byte count or error */
 typedef long                    __darwin_time_t;        /* time() */
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif  /* _BSD_ARM__TYPES_H_ */
\ No newline at end of file

@@ -28,6 +28,8 @@
 #ifndef _ARM_ARCH_H
 #define _ARM_ARCH_H
 
+#if defined (__arm__) || defined (__arm64__)
+
 /* Collect the __ARM_ARCH_*__ compiler flags into something easier to use. */
 #if defined (__ARM_ARCH_7A__) || defined (__ARM_ARCH_7S__) || defined (__ARM_ARCH_7F__) || defined (__ARM_ARCH_7K__)
 #define _ARM_ARCH_7
@@ -64,4 +66,6 @@
 #define _ARM_ARCH_4
 #endif
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif
\ No newline at end of file

@@ -42,6 +42,8 @@
 #ifndef _ARM__ENDIAN_H_
 #define _ARM__ENDIAN_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 #include <sys/cdefs.h>
 /*
  * Define _NOQUAD if the compiler does NOT support 64-bit integers.
@@ -75,4 +77,5 @@
 #include <sys/_endian.h>
 
 #endif /* defined(KERNEL) || (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)) */
+#endif /* defined (__arm__) || defined (__arm64__) */
 #endif /* !_ARM__ENDIAN_H_ */
\ No newline at end of file

@@ -39,6 +39,8 @@
 #ifndef _ARM_LIMITS_H_
 #define _ARM_LIMITS_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 #include <sys/cdefs.h>
 #include <arm/_limits.h>
 
@@ -107,4 +109,6 @@
 #endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) || _DARWIN_C_SOURCE */
 #endif /* !_ANSI_SOURCE */
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif /* _ARM_LIMITS_H_ */
\ No newline at end of file

@@ -48,6 +48,8 @@
 #ifndef _ARM_PARAM_H_
 #define _ARM_PARAM_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 #include <arm/_param.h>
 
 /*
@@ -144,4 +146,6 @@
 #define DELAY(n)        { int N = (n); while (--N > 0); }
 #endif  /* defined(KERNEL) || defined(STANDALONE) */
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif /* _ARM_PARAM_H_ */
\ No newline at end of file

@@ -9,10 +9,14 @@
 #ifndef _ARM_SIGNAL_
 #define _ARM_SIGNAL_ 1
 
+#if defined (__arm__) || defined (__arm64__)
+
 #include <sys/cdefs.h>
 
 #ifndef _ANSI_SOURCE
 typedef int sig_atomic_t;
 #endif /* ! _ANSI_SOURCE */
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif  /* _ARM_SIGNAL_ */
\ No newline at end of file

@@ -39,9 +39,12 @@
  *	@(#)types.h	8.3 (Berkeley) 1/5/94
  */
 
-#ifndef _MACHTYPES_H_
+#ifndef _ARM_MACHTYPES_H_
+#define _ARM_MACHTYPES_H_
 #define _MACHTYPES_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 #ifndef __ASSEMBLER__
 #include <arm/_types.h>
 #include <sys/cdefs.h>
@@ -104,4 +107,5 @@ typedef u_int64_t               syscall_arg_t;
 #endif
 
 #endif /* __ASSEMBLER__ */
-#endif  /* _MACHTYPES_H_ */
\ No newline at end of file
+#endif /* defined (__arm__) || defined (__arm64__) */
+#endif  /* _ARM_MACHTYPES_H_ */
\ No newline at end of file

@@ -31,6 +31,8 @@
 #ifndef _MACH_ARM__STRUCTS_H_
 #define _MACH_ARM__STRUCTS_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 #include <sys/cdefs.h> /* __DARWIN_UNIX03 */
 #include <machine/types.h> /* __uint32_t */
 
@@ -507,25 +509,6 @@ _STRUCT_ARM_NEON_STATE
 
 #endif /* __DARWIN_UNIX03 */
 
-#if __DARWIN_UNIX03
-#define _STRUCT_ARM_AMX_STATE_V1 struct __darwin_arm_amx_state_v1
-_STRUCT_ARM_AMX_STATE_V1
-{
-	__uint8_t  __x[8][64];        /* 8 64-byte registers */
-	__uint8_t  __y[8][64];        /* 8 64-byte registers */
-	__uint8_t  __z[64][64];       /* 64 64-byte registers in an M-by-N matrix */
-	__uint64_t __amx_state_t_el1; /* AMX_STATE_T_EL1 value */
-} __attribute__((aligned(64)));
-#else /* !__DARWIN_UNIX03 */
-#define _STRUCT_ARM_AMX_STATE_V1 struct arm_amx_state_v1
-_STRUCT_ARM_AMX_STATE_V1
-{
-	__uint8_t  x[8][64];        /* 8 64-byte registers */
-	__uint8_t  y[8][64];        /* 8 64-byte registers */
-	__uint8_t  z[64][64];       /* 64 64-byte registers in an M-by-N matrix */
-	__uint64_t amx_state_t_el1; /* AMX_STATE_T_EL1 value. */
-} __attribute__((aligned(64)));
-#endif /* __DARWIN_UNIX03 */
 
 #define _STRUCT_ARM_PAGEIN_STATE struct __arm_pagein_state
 _STRUCT_ARM_PAGEIN_STATE
@@ -642,4 +625,6 @@ _STRUCT_ARM_CPMU_STATE64
 };
 #endif /* !__DARWIN_UNIX03 */
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif /* _MACH_ARM__STRUCTS_H_ */
\ No newline at end of file

@@ -65,6 +65,10 @@
 #ifndef _MACH_ARM_BOOLEAN_H_
 #define _MACH_ARM_BOOLEAN_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 typedef int             boolean_t;
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif  /* _MACH_ARM_BOOLEAN_H_ */
\ No newline at end of file

@@ -29,6 +29,8 @@
 #ifndef _MACH_ARM_EXCEPTION_H_
 #define _MACH_ARM_EXCEPTION_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 #define EXC_TYPES_COUNT         14      /* incl. illegal exception 0 */
 
 #define EXC_MASK_MACHINE         0
@@ -75,5 +77,6 @@
 
 #define EXC_ARM_BREAKPOINT      1       /* breakpoint trap */
 
+#endif /* defined (__arm__) || defined (__arm64__) */
 
 #endif  /* _MACH_ARM_EXCEPTION_H_ */
\ No newline at end of file

@@ -67,8 +67,12 @@
 #ifndef _MACH_ARM_KERN_RETURN_H_
 #define _MACH_ARM_KERN_RETURN_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 #ifndef ASSEMBLER
 typedef int             kern_return_t;
 #endif  /* ASSEMBLER */
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif  /* _MACH_ARM_KERN_RETURN_H_ */
\ No newline at end of file

@@ -29,6 +29,8 @@
 #ifndef _MACH_ARM_PROCESSOR_INFO_H_
 #define _MACH_ARM_PROCESSOR_INFO_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 #define PROCESSOR_CPU_STAT   0x10000003 /* Low-level CPU statistics */
 #define PROCESSOR_CPU_STAT64 0x10000004 /* Low-level CPU statistics, in full 64-bit */
 
@@ -69,4 +71,6 @@ typedef struct processor_cpu_stat64 *processor_cpu_stat64_t;
 #define PROCESSOR_CPU_STAT64_COUNT ((mach_msg_type_number_t) \
 	        (sizeof(processor_cpu_stat64_data_t) / sizeof(integer_t)))
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif /* _MACH_ARM_PROCESSOR_INFO_H_ */
\ No newline at end of file

@@ -32,4 +32,8 @@
 #ifndef _MACH_ARM_RPC_H_
 #define _MACH_ARM_RPC_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif /* _MACH_ARM_RPC_H_ */
\ No newline at end of file

@@ -32,13 +32,11 @@
 #ifndef _MACH_ARM_THREAD_STATE_H_
 #define _MACH_ARM_THREAD_STATE_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 /* Size of maximum exported thread state in words */
 #define ARM_THREAD_STATE_MAX    (1296)    /* Size of biggest state possible */
 
-#if defined (__arm__) || defined(__arm64__)
-#define THREAD_STATE_MAX        ARM_THREAD_STATE_MAX
-#else
-#error Unsupported arch
-#endif
+#endif /* defined (__arm__) || defined (__arm64__) */
 
 #endif  /* _MACH_ARM_THREAD_STATE_H_ */
\ No newline at end of file

@@ -33,10 +33,12 @@
 #ifndef _ARM_THREAD_STATUS_H_
 #define _ARM_THREAD_STATUS_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 #include <mach/machine/_structs.h>
+#include <mach/machine/thread_state.h>
 #include <mach/message.h>
 #include <mach/vm_types.h>
-#include <mach/arm/thread_state.h>
 
 /*
  *    Support for determining the state of a thread
@@ -67,13 +69,12 @@
 #define ARM_CPMU_STATE64         18
 
 
-/* API */
-#define ARM_AMX_STATE            24
-#define ARM_AMX_STATE_V1         25
-#define ARM_STATE_FLAVOR_IS_OTHER_VALID(_flavor_) \
-	((_flavor_) == ARM_AMX_STATE_V1)
 #define ARM_PAGEIN_STATE         27
 
+#ifndef ARM_STATE_FLAVOR_IS_OTHER_VALID
+#define ARM_STATE_FLAVOR_IS_OTHER_VALID(_flavor_) 0
+#endif
+
 #define VALID_THREAD_STATE_FLAVOR(x) \
 	((x == ARM_THREAD_STATE) ||           \
 	 (x == ARM_VFP_STATE) ||              \
@@ -170,7 +171,6 @@ typedef _STRUCT_ARM_NEON_STATE        arm_neon_state_t;
 typedef _STRUCT_ARM_NEON_STATE        arm_neon_state32_t;
 typedef _STRUCT_ARM_NEON_STATE64      arm_neon_state64_t;
 
-typedef _STRUCT_ARM_AMX_STATE_V1       arm_amx_state_v1_t;
 
 typedef _STRUCT_ARM_EXCEPTION_STATE   arm_exception_state_t;
 typedef _STRUCT_ARM_EXCEPTION_STATE   arm_exception_state32_t;
@@ -224,26 +224,12 @@ typedef _STRUCT_ARM_LEGACY_DEBUG_STATE arm_debug_state_t;
 #define MACHINE_THREAD_STATE_COUNT ARM_UNIFIED_THREAD_STATE_COUNT
 
 
-struct arm_amx_state {
-	arm_state_hdr_t ash;
-	union {
-		arm_amx_state_v1_t as_v1;
-	} uas;
-};
-#define as_v1 uas.as_v1
-typedef struct arm_amx_state arm_amx_state_t;
-
-#define ARM_AMX_STATE_V1_COUNT ((mach_msg_type_number_t) \
-	(sizeof(arm_amx_state_v1_t)/sizeof(unsigned int)))
-
-#define ARM_AMX_STATE_COUNT ((mach_msg_type_number_t) \
-	(sizeof(arm_amx_state_t)/sizeof(unsigned int)))
-
-
 /*
  * Largest state on this machine:
  */
 #define THREAD_MACHINE_STATE_MAX THREAD_STATE_MAX
 
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif /* _ARM_THREAD_STATUS_H_ */
\ No newline at end of file

@@ -36,6 +36,8 @@
 #ifndef _MACH_ARM_VM_PARAM_H_
 #define _MACH_ARM_VM_PARAM_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 
 #if !defined (KERNEL) && !defined (__ASSEMBLER__)
 #include <mach/vm_page_size.h>
@@ -104,4 +106,6 @@
 
 #define SWI_SYSCALL     0x80
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif  /* _MACH_ARM_VM_PARAM_H_ */
\ No newline at end of file

@@ -67,11 +67,14 @@
 #ifndef _MACH_ARM_VM_TYPES_H_
 #define _MACH_ARM_VM_TYPES_H_
 
+#if defined (__arm__) || defined (__arm64__)
+
 #ifndef ASSEMBLER
 
 #include <arm/_types.h>
 #include <stdint.h>
 #include <Availability.h>
+#include <sys/cdefs.h>
 
 /*
  * natural_t and integer_t are Mach's legacy types for machine-
@@ -98,18 +101,18 @@ typedef int                     integer_t;
  * e.g. an offset into a virtual memory space.
  */
 #ifdef __LP64__
-typedef uintptr_t               vm_offset_t;
+typedef uintptr_t               vm_offset_t __kernel_ptr_semantics;
 typedef uintptr_t               vm_size_t;
 
-typedef uint64_t                mach_vm_address_t;
-typedef uint64_t                mach_vm_offset_t;
+typedef uint64_t                mach_vm_address_t __kernel_ptr_semantics;
+typedef uint64_t                mach_vm_offset_t __kernel_ptr_semantics;
 typedef uint64_t                mach_vm_size_t;
 
-typedef uint64_t                vm_map_offset_t;
-typedef uint64_t                vm_map_address_t;
+typedef uint64_t                vm_map_offset_t __kernel_ptr_semantics;
+typedef uint64_t                vm_map_address_t __kernel_ptr_semantics;
 typedef uint64_t                vm_map_size_t;
 #else
-typedef natural_t               vm_offset_t;
+typedef natural_t               vm_offset_t __kernel_ptr_semantics;
 /*
  * A vm_size_t is the proper type for e.g.
  * expressing the difference between two
@@ -129,13 +132,13 @@ typedef uint32_t                mach_vm_address_t;
 typedef uint32_t                mach_vm_offset_t;
 typedef uint32_t                mach_vm_size_t;
 #else
-typedef uint64_t                mach_vm_address_t;
-typedef uint64_t                mach_vm_offset_t;
+typedef uint64_t                mach_vm_address_t __kernel_ptr_semantics;
+typedef uint64_t                mach_vm_offset_t __kernel_ptr_semantics;
 typedef uint64_t                mach_vm_size_t;
 #endif
 
-typedef uint32_t                vm_map_offset_t;
-typedef uint32_t                vm_map_address_t;
+typedef uint32_t                vm_map_offset_t __kernel_ptr_semantics;
+typedef uint32_t                vm_map_address_t __kernel_ptr_semantics;
 typedef uint32_t                vm_map_size_t;
 #endif /* __LP64__ */
 
@@ -154,4 +157,6 @@ typedef vm_offset_t             mach_port_context_t;
  */
 #define MACH_MSG_TYPE_INTEGER_T MACH_MSG_TYPE_INTEGER_32
 
+#endif /* defined (__arm__) || defined (__arm64__) */
+
 #endif  /* _MACH_ARM_VM_TYPES_H_ */
\ No newline at end of file

@@ -184,6 +184,7 @@ _STRUCT_ARM_THREAD_STATE64
 
 #define __DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH 0x1
 #define __DARWIN_ARM_THREAD_STATE64_FLAGS_IB_SIGNED_LR 0x2
+#define __DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED 0x4
 
 /* Return pc field of arm_thread_state64_t as a data pointer value */
 #define __darwin_arm_thread_state64_get_pc(ts) \
@@ -212,7 +213,9 @@ _STRUCT_ARM_THREAD_STATE64
 	ptrauth_auth_and_resign(__f, ptrauth_key_function_pointer, 0, \
 	ptrauth_key_process_independent_code,                         \
 	ptrauth_string_discriminator("pc")) : ptrauth_auth_data(__f,  \
-	ptrauth_key_function_pointer, 0)) : __f); })
+	ptrauth_key_function_pointer, 0)) : __f);                     \
+	__tsp->__opaque_flags &=                                      \
+	~__DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED; })
 /* Return lr field of arm_thread_state64_t as a data pointer value */
 #define __darwin_arm_thread_state64_get_lr(ts) \
 	__extension__ ({ const _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts); \
@@ -243,7 +246,8 @@ _STRUCT_ARM_THREAD_STATE64
 	ptrauth_auth_and_resign(__f, ptrauth_key_function_pointer, 0,          \
 	ptrauth_key_process_independent_code,                                  \
 	ptrauth_string_discriminator("lr"))) : ptrauth_auth_data(__f,          \
-	ptrauth_key_function_pointer, 0)) : __f); })
+	ptrauth_key_function_pointer, 0)) : __f); __tsp->__opaque_flags &=     \
+	~__DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED; })
 /* Return sp field of arm_thread_state64_t as a data pointer value */
 #define __darwin_arm_thread_state64_get_sp(ts) \
 	__extension__ ({ const _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts); \
@@ -260,7 +264,9 @@ _STRUCT_ARM_THREAD_STATE64
 	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ?             \
 	ptrauth_sign_unauthenticated(__p,                           \
 	ptrauth_key_process_independent_data,                       \
-	ptrauth_string_discriminator("sp")) : __p); })
+	ptrauth_string_discriminator("sp")) : __p);                 \
+	__tsp->__opaque_flags &=                                    \
+	~__DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED; })
 /* Return fp field of arm_thread_state64_t as a data pointer value */
 #define __darwin_arm_thread_state64_get_fp(ts) \
 	__extension__ ({ const _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts); \
@@ -277,7 +283,9 @@ _STRUCT_ARM_THREAD_STATE64
 	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ?             \
 	ptrauth_sign_unauthenticated(__p,                           \
 	ptrauth_key_process_independent_data,                       \
-	ptrauth_string_discriminator("fp")) : __p); })
+	ptrauth_string_discriminator("fp")) : __p);                 \
+	__tsp->__opaque_flags &=                                    \
+	~__DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED; })
 
 /* Strip ptr auth bits from pc, lr, sp and fp field of arm_thread_state64_t */
 #define __darwin_arm_thread_state64_ptrauth_strip(ts) \
@@ -296,7 +304,8 @@ _STRUCT_ARM_THREAD_STATE64
 	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ? __tsp->__opaque_fp :      \
 	ptrauth_strip(__tsp->__opaque_fp, ptrauth_key_process_independent_data)); \
 	__tsp->__opaque_flags |=                                                  \
-	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH; })
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH; __tsp->__opaque_flags &=    \
+	~__DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED; })
 
 #else /* __has_feature(ptrauth_calls) && defined(__LP64__) */
 

@@ -39,6 +39,7 @@
 #if defined (__arm__) || defined (__arm64__)
 
 
+
 #if !defined (KERNEL) && !defined (__ASSEMBLER__)
 #include <mach/vm_page_size.h>
 #endif

@@ -70,6 +70,7 @@
 #include <mach/mach_types.h>
 #include <mach/message.h>
 #include <mach/port.h>
+#include <stdint.h>
 
 
 
@@ -82,7 +83,6 @@ typedef char *  io_buf_ptr_t;
  * Some types for IOKit.
  */
 
-#ifdef IOKIT
 
 /* must match device_types.defs */
 typedef char                    io_name_t[128];
@@ -113,6 +113,5 @@ typedef mach_port_t     io_object_t;
 #endif  /* __IOKIT_PORTS_DEFINED__ */
 
 
-#endif  /* IOKIT */
 
 #endif  /* DEVICE_TYPES_H */
\ No newline at end of file

@@ -127,6 +127,33 @@
 #define DISPATCH_UNAVAILABLE_MSG(msg)
 #endif
 
+#if defined(__cplusplus)
+# if __cplusplus >= 201703L
+#  define DISPATCH_FALLTHROUGH [[fallthrough]]
+# elif __cplusplus >= 201103L
+#  if defined(__clang__)
+#   define DISPATCH_FALLTHROUGH [[clang::fallthrough]]
+#  elif defined(__GNUC__) && __GNUC__ >= 7
+#   define DISPATCH_FALLTHROUGH [[gnu::fallthrough]]
+#  else
+#   define DISPATCH_FALLTHROUGH
+#  endif
+# else
+#  define DISPATCH_FALLTHROUGH
+# endif
+#elif defined(__GNUC__) && __GNUC__ >= 7
+# define DISPATCH_FALLTHROUGH __attribute__((__fallthrough__))
+#elif defined(__clang__)
+# if __has_attribute(fallthrough) && __clang_major__ >= 5
+#  define DISPATCH_FALLTHROUGH __attribute__((__fallthrough__))
+# else
+#  define DISPATCH_FALLTHROUGH
+# endif
+#else
+# define DISPATCH_FALLTHROUGH
+#endif
+
+
 #define DISPATCH_LINUX_UNAVAILABLE()
 
 #ifdef __FreeBSD__

@@ -52,6 +52,7 @@ typedef function_table_entry   *function_table_t;
 #define	clock_MSG_COUNT	3
 #endif	/* clock_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>

@@ -52,6 +52,7 @@ typedef function_table_entry   *function_table_t;
 #define	clock_priv_MSG_COUNT	2
 #endif	/* clock_priv_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>

@@ -52,6 +52,7 @@ typedef function_table_entry   *function_table_t;
 #define	host_priv_MSG_COUNT	26
 #endif	/* host_priv_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>

@@ -52,6 +52,7 @@ typedef function_table_entry   *function_table_t;
 #define	host_security_MSG_COUNT	2
 #endif	/* host_security_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>

@@ -52,6 +52,7 @@ typedef function_table_entry   *function_table_t;
 #define	lock_set_MSG_COUNT	6
 #endif	/* lock_set_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>

@@ -85,10 +85,6 @@ __BEGIN_DECLS
 extern void                     panic_init(mach_port_t);
 extern void                     panic(const char *, ...);
 
-extern void                     safe_gets(char *,
-    char *,
-    int);
-
 extern void                     slot_name(cpu_type_t,
     cpu_subtype_t,
     char **,

@@ -52,6 +52,7 @@ typedef function_table_entry   *function_table_t;
 #define	mach_host_MSG_COUNT	35
 #endif	/* mach_host_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>
@@ -74,8 +75,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_info
 (
 	host_t host,
@@ -251,8 +251,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_request_notification
 (
 	host_t host,
@@ -308,8 +307,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_create_mach_voucher
 (
 	host_t host,
@@ -324,8 +322,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_register_mach_voucher_attr_manager
 (
 	host_t host,
@@ -341,8 +338,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_register_well_known_mach_voucher_attr_manager
 (
 	host_t host,
@@ -358,8 +354,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_set_atm_diagnostic_flag
 (
 	host_t host,
@@ -372,8 +367,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_get_atm_diagnostic_flag
 (
 	host_t host,

@@ -31,6 +31,7 @@
 
 #include <mach/std_types.h>
 #include <mach/port.h>
+#include <mach/message.h>
 
 /*
  * Mach Voucher - an immutable collection of attribute value handles.
@@ -212,7 +213,7 @@ typedef mach_port_t             ipc_voucher_attr_control_t;
  * The private handle that the voucher attribute manager provides to
  * the mach voucher mechanism to represent a given attr content/value.
  */
-typedef uint64_t mach_voucher_attr_value_handle_t;
+typedef uint64_t mach_voucher_attr_value_handle_t __kernel_ptr_semantics;
 typedef mach_voucher_attr_value_handle_t *mach_voucher_attr_value_handle_array_t;
 
 typedef mach_msg_type_number_t mach_voucher_attr_value_handle_array_size_t;

@@ -151,7 +151,6 @@ typedef struct mig_symtab {
 #define MIG_SERVER_ROUTINE
 #endif
 
-
 __BEGIN_DECLS
 
 /* Client side reply port allocate */

@@ -52,6 +52,7 @@ typedef function_table_entry   *function_table_t;
 #define	processor_MSG_COUNT	6
 #endif	/* processor_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>

@@ -44,6 +44,4 @@ typedef int sync_policy_t;
 #define SYNC_POLICY_LIFO                (SYNC_POLICY_FIFO|SYNC_POLICY_REVERSED)
 
 
-#define SYNC_POLICY_MAX                 0x7
-
 #endif  /* _MACH_SYNC_POLICY_H_ */
\ No newline at end of file

@@ -29,6 +29,9 @@
 #ifndef MACH_TASK_INSPECT_H
 #define MACH_TASK_INSPECT_H
 
+#include <stdint.h>
+#include <mach/vm_types.h>
+
 /*
  * XXX These interfaces are still in development -- they are subject to change
  * without notice.

@@ -131,7 +131,11 @@ typedef struct thread_extended_policy   *thread_extended_policy_t;
  *
  * computation: This is the nominal amount of computation
  * time needed during a separate processing arrival, specified
- * in absolute time units.
+ * in absolute time units.  The thread may be preempted after
+ * the computation time has elapsed.
+ * If (computation < constraint/2) it will be forced to
+ * constraint/2 to avoid unintended preemption and associated
+ * timer interrupts.
  *
  * constraint: This is the maximum amount of real time that
  * may elapse from the start of a separate processing arrival
@@ -139,11 +143,11 @@ typedef struct thread_extended_policy   *thread_extended_policy_t;
  * specified in absolute time units.  Must be (>= computation).
  * Note that latency = (constraint - computation).
  *
- * preemptible: This indicates that the computation may be
- * interrupted, subject to the constraint specified above.
+ * preemptible: IGNORED (This indicates that the computation may be
+ * interrupted, subject to the constraint specified above.)
  */
 
-#define THREAD_TIME_CONSTRAINT_POLICY   2
+#define THREAD_TIME_CONSTRAINT_POLICY           2
 
 struct thread_time_constraint_policy {
 	uint32_t                period;

@@ -32,7 +32,6 @@
 #include <Availability.h>
 #include <mach/mach.h>
 
-#ifndef KERNEL
 /*
  * Gets all register values in the target thread with pointer-like contents.
  *
@@ -58,6 +57,5 @@
 __API_AVAILABLE(macosx(10.14), ios(12.0), tvos(9.0), watchos(5.0))
 kern_return_t thread_get_register_pointer_values(thread_t thread,
     uintptr_t *sp, size_t *length, uintptr_t *values);
-#endif
 
 #endif /* _MACH_THREAD_STATE_H_ */
\ No newline at end of file

@@ -69,12 +69,51 @@
 #include <mach_debug/hash_info.h>
 #include <mach_debug/lockgroup_info.h>
 
-#define MACH_CORE_FILEHEADER_SIGNATURE  0x0063614d20646152ULL
+#define MACH_CORE_FILEHEADER_SIGNATURE    0x0063614d20646152ULL
+#define MACH_CORE_FILEHEADER_V2_SIGNATURE 0x63614d2073736f42ULL
 #define MACH_CORE_FILEHEADER_MAXFILES 16
 #define MACH_CORE_FILEHEADER_NAMELEN 16
 
+/* The following are defined for mach_core_fileheader_v2 */
+#define MACH_CORE_FILEHEADER_V2_FLAG_LOG_ENCRYPTED_AEA    (1ULL << 0) /* The log is encrypted using AEA */
+#define MACH_CORE_FILEHEADER_V2_FLAG_EXISTING_COREFILE_KEY_FORMAT_NIST_P256 (1ULL << 8) /* The public key is an NIST-P256 ECC key */
+#define MACH_CORE_FILEHEADER_V2_FLAG_NEXT_COREFILE_KEY_FORMAT_NIST_P256 (1ULL << 16) /* The next public key is an NIST-P256 ECC key */
+
+#define MACH_CORE_FILEHEADER_V2_FLAGS_EXISTING_COREFILE_KEY_FORMAT_MASK (0x1ULL << 8) /* A bit-mask for all supported key formats */
+#define MACH_CORE_FILEHEADER_V2_FLAGS_NEXT_COREFILE_KEY_FORMAT_MASK (0x1ULL << 16) /* A bit-mask for all supported next key formats */
+
+#define MACH_CORE_FILEHEADER_V2_FLAGS_NEXT_KEY_FORMAT_TO_KEY_FORMAT(x) (((x) >> 8) & MACH_CORE_FILEHEADER_V2_FLAGS_EXISTING_COREFILE_KEY_FORMAT_MASK)
+
+/* The following are defined for mach_core_details_v2 */
+#define MACH_CORE_DETAILS_V2_FLAG_ENCRYPTED_AEA   (1ULL << 0) /* This core is encrypted using AEA */
+#define MACH_CORE_DETAILS_V2_FLAG_COMPRESSED_ZLIB (1ULL << 8) /* This core is compressed using ZLib */
+
 typedef char    symtab_name_t[32];
 
+/*
+ ***********************
+ *
+ * Mach corefile layout
+ *
+ ***********************
+ *
+ * uint64_t signature
+ * uint64_t log_offset                                 >---+
+ * uint64_t log_length                                     |
+ * mach_core_details files[MACH_CORE_FILEHEADER_MAXFILES]  |
+ *   |--> uint64_t gzip_offset                   >---+     |
+ *   |    uint64_t gzip_length                       |     |
+ *   |    char core_name[]                           |     |
+ *   |--> uint64_t gzip_offset             >---+     |     |
+ *   |    uint64_t gzip_length                 |     |     |
+ *   |    char core_name[]                     |     |     |
+ *   |--> [...]                                |     |     |
+ * [log data. Plain-text]                      |     | <---+
+ * [core #1 data. Zlib compressed]             | <---+
+ * [core #2 data. Zlib compressed]         <---+
+ * [core #x data...]
+ */
+
 struct mach_core_details {
 	uint64_t gzip_offset;
 	uint64_t gzip_length;
@@ -82,13 +121,78 @@ struct mach_core_details {
 };
 
 struct mach_core_fileheader {
-	uint64_t signature;
+	uint64_t signature; /* MACH_CORE_FILEHEADER_SIGNATURE */
 	uint64_t log_offset;
 	uint64_t log_length;
 	uint64_t num_files;
 	struct mach_core_details files[MACH_CORE_FILEHEADER_MAXFILES];
 };
 
+/*
+ * Mach corefile V2 headers are denoted with MACH_CORE_FILEHEADER_V2_SIGNATURE.
+ * Note that the V2 headers contain a version field that further indicates the version of the
+ * header's contents. For example, if a V2 header's 'version' field indicates version 5, then
+ * the header follows the format of the 'mach_core_fileheader_v5' structure.
+ *
+ * Further note that 'mach_core_details_' structures are not bound to the same versioning scheme
+ * as the header itself. This means that it's perfectly acceptable for a 'mach_core_fileheader_v5' header
+ * to make use of 'mach_core_details_v2'
+ *
+ **************************
+ *
+ * Mach corefile layout V2 (using a version 2 header struct as an example)
+ *
+ **************************
+ *
+ * uint64_t signature
+ * uint32_t version
+ * uint64_t flags
+ * uint64_t pub_key_offset                                                         >---+
+ * uint16_t pub_key_length                                                             |
+ * uint64_t log_offset                                                       >---+     |
+ * uint64_t log_length                                                           |     |
+ * uint64_t num_files                                                            |     |
+ * mach_core_details_v2 files[]                                                  |     |
+ *   |--> uint64_t flags                                                         |     |
+ *   |    uint64_t offset                                              >---+     |     |
+ *   |    uint64_t length                                                  |     |     |
+ *   |    char core_name[]                                                 |     |     |
+ *   |--> uint64_t flags                                                   |     |     |
+ *   |    uint64_t offset                                        >---+     |     |     |
+ *   |    uint64_t length                                            |     |     |     |
+ *   |    char core_name[]                                           |     |     |     |
+ *   |--> [...]                                                      |     |     |     |
+ * [public key data]                                                 |     |     | <---+
+ * [log data. Plain-text or an AEA container]                        |     | <---+
+ * [core #1 data. Zlib compressed. Possibly in an AEA container]     | <---+
+ * [core #2 data. Zlib compressed. Possibly in an AEA container] <---+
+ * [core #x data...]
+ */
+
+struct mach_core_details_v2 {
+	uint64_t flags;  /* See the MACH_CORE_DETAILS_V2_FLAG_* definitions */
+	uint64_t offset;
+	uint64_t length;
+	char core_name[MACH_CORE_FILEHEADER_NAMELEN];
+};
+
+struct mach_core_fileheader_base {
+	uint64_t signature; /* MACH_CORE_FILEHEADER_V2_SIGNATURE */
+	uint32_t version;
+};
+
+struct mach_core_fileheader_v2 {
+	uint64_t signature;       /* MACH_CORE_FILEHEADER_V2_SIGNATURE */
+	uint32_t version;         /* 2 */
+	uint64_t flags;           /* See the MACH_CORE_FILEHEADER_V2_FLAG_* definitions */
+	uint64_t pub_key_offset;  /* Offset of the public key */
+	uint16_t pub_key_length;  /* Length of the public key */
+	uint64_t log_offset;
+	uint64_t log_length;
+	uint64_t num_files;
+	struct mach_core_details_v2 files[];
+};
+
 #define KOBJECT_DESCRIPTION_LENGTH      512
 typedef char kobject_description_t[KOBJECT_DESCRIPTION_LENGTH];
 

@@ -74,7 +74,7 @@
 #define KEV_DL_LINK_QUALITY_METRIC_CHANGED      20
 #define KEV_DL_NODE_PRESENCE                    21
 #define KEV_DL_NODE_ABSENCE                     22
-#define KEV_DL_MASTER_ELECTED                   23
+#define KEV_DL_PRIMARY_ELECTED                  23
 #define KEV_DL_ISSUES                           24
 #define KEV_DL_IFDELEGATE_CHANGED               25
 #define KEV_DL_AWDL_RESTRICTED                  26
@@ -83,6 +83,8 @@
 #define KEV_DL_QOS_MODE_CHANGED                 29
 #define KEV_DL_LOW_POWER_MODE_CHANGED           30
 
+#define KEV_DL_MASTER_ELECTED (_Pragma("gcc warn Use KEV_DL_PRIMARY_ELECTED instead") KEV_DL_PRIMARY_ELECTED)
+
 
 #define KEV_INET6_SUBCLASS      6       /* inet6 subclass */
 /* KEV_INET6_SUBCLASS event codes */

@@ -316,73 +316,4 @@ _objc_msgForward_stret(id _Nonnull receiver, SEL _Nonnull sel, ...)
     OBJC_ARM64_UNAVAILABLE;
 #endif
 
-
-/* Variable-argument Messaging Primitives
- *
- * Use these functions to call methods with a list of arguments, such 
- * as the one passed to forward:: .
- *
- * The contents of the argument list are architecture-specific. 
- * Consult your local function call ABI documentation for details.
- * 
- * These functions must be cast to an appropriate function pointer type 
- * before being called, except for objc_msgSendv_stret() which must not 
- * be cast to a struct-returning type.
- */
-
-typedef void* marg_list;
-
-OBJC_EXPORT id _Nullable
-objc_msgSendv(id _Nullable self, SEL _Nonnull op, size_t arg_size,
-              marg_list _Nonnull arg_frame)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT void
-objc_msgSendv_stret(void * _Nonnull stretAddr, id _Nullable self,
-                    SEL _Nonnull op, size_t arg_size,
-                    marg_list _Nullable arg_frame)
-    OBJC2_UNAVAILABLE;
-/* Note that objc_msgSendv_stret() does not return a structure type, 
- * and should not be cast to do so. This is unlike objc_msgSend_stret() 
- * and objc_msgSendSuper_stret().
- */
-#if defined(__i386__)
-OBJC_EXPORT double
-objc_msgSendv_fpret(id _Nullable self, SEL _Nonnull op,
-                    unsigned arg_size, marg_list _Nullable arg_frame)
-    OBJC2_UNAVAILABLE;
-#endif
-
-
-/* The following marg_list macros are of marginal utility. They
- * are included for compatibility with the old objc-class.h header. */
-
-#if !__OBJC2__
-
-#define marg_prearg_size	0
-
-#define marg_malloc(margs, method) \
-	do { \
-		margs = (marg_list *)malloc (marg_prearg_size + ((7 + method_getSizeOfArguments(method)) & ~7)); \
-	} while (0)
-
-#define marg_free(margs) \
-	do { \
-		free(margs); \
-	} while (0)
-	
-#define marg_adjustedOffset(method, offset) \
-	(marg_prearg_size + offset)
-
-#define marg_getRef(margs, offset, type) \
-	( (type *)((char *)margs + marg_adjustedOffset(method,offset) ) )
-
-#define marg_getValue(margs, offset, type) \
-	( *marg_getRef(margs, offset, type) )
-
-#define marg_setValue(margs, offset, type, value) \
-	( marg_getValue(margs, offset, type) = (value) )
-
-#endif
-
 #endif
\ No newline at end of file

@@ -8,7 +8,7 @@
 #include <TargetConditionals.h>
 #include <objc/objc.h>
 
-#if __LP64__ || 0 || NS_BUILD_32_LIKE_64
+#if __LP64__ || TARGET_OS_WIN32 || NS_BUILD_32_LIKE_64
 typedef long NSInteger;
 typedef unsigned long NSUInteger;
 #else

@@ -41,7 +41,14 @@
  *  way in which simd functions are overloaded, the usual weak-linking tricks
  *  do not work; these functions are simply unavailable when targeting older
  *  versions of the library.                                                  */
-#   if   __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_13   || \
+#   if   __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_12_0   || \
+        __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_15_0 || \
+         __WATCH_OS_VERSION_MIN_REQUIRED >= __WATCHOS_8_0 || \
+            __TV_OS_VERSION_MIN_REQUIRED >= __TVOS_15_0   || \
+        __BRIDGE_OS_VERSION_MIN_REQUIRED >= 60000   || \
+        __DRIVERKIT_VERSION_MIN_REQUIRED >= __DRIVERKIT_21_0
+#    define SIMD_LIBRARY_VERSION 4
+#   elif __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_13   || \
         __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_11_0 || \
          __WATCH_OS_VERSION_MIN_REQUIRED >= __WATCHOS_4_0 || \
             __TV_OS_VERSION_MIN_REQUIRED >= __TVOS_11_0   || \

@@ -24,6 +24,10 @@
  *
  *      simd_transpose(x)               Transpose of the matrix x.
  *
+ *      simd_trace(x)                   Trace of the matrix x.
+ *
+ *      simd_determinant(x)             Determinant of the matrix x.
+ *
  *      simd_inverse(x)                 Inverse of x if x is non-singular.  If
  *                                      x is singular, the result is undefined.
  *
@@ -248,6 +252,14 @@ static simd_double4x3 SIMD_CFUNC simd_transpose(simd_double3x4 __x);
 static simd_double4x4 SIMD_CFUNC simd_transpose(simd_double4x4 __x);
 #define matrix_transpose simd_transpose
 
+static float SIMD_CFUNC simd_trace(simd_float2x2 __x);
+static float SIMD_CFUNC simd_trace(simd_float3x3 __x);
+static float SIMD_CFUNC simd_trace(simd_float4x4 __x);
+static double SIMD_CFUNC simd_trace(simd_double2x2 __x);
+static double SIMD_CFUNC simd_trace(simd_double3x3 __x);
+static double SIMD_CFUNC simd_trace(simd_double4x4 __x);
+#define matrix_trace simd_trace
+
 static float SIMD_CFUNC simd_determinant(simd_float2x2 __x);
 static float SIMD_CFUNC simd_determinant(simd_float3x3 __x);
 static float SIMD_CFUNC simd_determinant(simd_float4x4 __x);
@@ -468,7 +480,11 @@ namespace simd {
   static SIMD_CPPFUNC float4x2 transpose(const float2x4 x) { return ::simd_transpose(x); }
   static SIMD_CPPFUNC float4x3 transpose(const float3x4 x) { return ::simd_transpose(x); }
   static SIMD_CPPFUNC float4x4 transpose(const float4x4 x) { return ::simd_transpose(x); }
-  
+
+  static SIMD_CPPFUNC float trace(const float2x2 x) { return ::simd_trace(x); }
+  static SIMD_CPPFUNC float trace(const float3x3 x) { return ::simd_trace(x); }
+  static SIMD_CPPFUNC float trace(const float4x4 x) { return ::simd_trace(x); }
+
   static SIMD_CPPFUNC float determinant(const float2x2 x) { return ::simd_determinant(x); }
   static SIMD_CPPFUNC float determinant(const float3x3 x) { return ::simd_determinant(x); }
   static SIMD_CPPFUNC float determinant(const float4x4 x) { return ::simd_determinant(x); }
@@ -656,7 +672,11 @@ namespace simd {
   static SIMD_CPPFUNC double4x2 transpose(const double2x4 x) { return ::simd_transpose(x); }
   static SIMD_CPPFUNC double4x3 transpose(const double3x4 x) { return ::simd_transpose(x); }
   static SIMD_CPPFUNC double4x4 transpose(const double4x4 x) { return ::simd_transpose(x); }
-  
+
+  static SIMD_CPPFUNC double trace(const double2x2 x) { return ::simd_trace(x); }
+  static SIMD_CPPFUNC double trace(const double3x3 x) { return ::simd_trace(x); }
+  static SIMD_CPPFUNC double trace(const double4x4 x) { return ::simd_trace(x); }
+
   static SIMD_CPPFUNC double determinant(const double2x2 x) { return ::simd_determinant(x); }
   static SIMD_CPPFUNC double determinant(const double3x3 x) { return ::simd_determinant(x); }
   static SIMD_CPPFUNC double determinant(const double4x4 x) { return ::simd_determinant(x); }
@@ -1292,6 +1312,13 @@ static simd_double4 SIMD_CFUNC __rotate1(simd_double4 __x) { return __builtin_sh
 static simd_double4 SIMD_CFUNC __rotate2(simd_double4 __x) { return __builtin_shufflevector(__x,__x,2,3,0,1); }
 static simd_double4 SIMD_CFUNC __rotate3(simd_double4 __x) { return __builtin_shufflevector(__x,__x,3,0,1,2); }
 
+static  float SIMD_CFUNC simd_trace( simd_float2x2 __x) { return __x.columns[0][0] + __x.columns[1][1]; }
+static double SIMD_CFUNC simd_trace(simd_double2x2 __x) { return __x.columns[0][0] + __x.columns[1][1]; }
+static  float SIMD_CFUNC simd_trace( simd_float3x3 __x) { return __x.columns[0][0] + __x.columns[1][1] + __x.columns[2][2]; }
+static double SIMD_CFUNC simd_trace(simd_double3x3 __x) { return __x.columns[0][0] + __x.columns[1][1] + __x.columns[2][2]; }
+static  float SIMD_CFUNC simd_trace( simd_float4x4 __x) { return __x.columns[0][0] + __x.columns[1][1] + __x.columns[2][2] + __x.columns[3][3]; }
+static double SIMD_CFUNC simd_trace(simd_double4x4 __x) { return __x.columns[0][0] + __x.columns[1][1] + __x.columns[2][2] + __x.columns[3][3]; }
+
 static  float SIMD_CFUNC simd_determinant( simd_float2x2 __x) { return __x.columns[0][0]*__x.columns[1][1] - __x.columns[0][1]*__x.columns[1][0]; }
 static double SIMD_CFUNC simd_determinant(simd_double2x2 __x) { return __x.columns[0][0]*__x.columns[1][1] - __x.columns[0][1]*__x.columns[1][0]; }
 static  float SIMD_CFUNC simd_determinant( simd_float3x3 __x) { return simd_reduce_add(__x.columns[0]*(__rotate1(__x.columns[1])*__rotate2(__x.columns[2]) - __rotate2(__x.columns[1])*__rotate1(__x.columns[2]))); }

@@ -30,6 +30,7 @@
 #define SIMD_MATRIX_TYPES_HEADER
 
 #include <simd/types.h>
+#include <simd/vector_make.h>
 #if SIMD_COMPILER_HAS_REQUIRED_FEATURES
 
 /*  Matrix types available in C, Objective-C, and C++                         */
@@ -258,6 +259,234 @@ namespace simd {
     double4x4(::simd_quatd q) : ::simd_double4x4(::simd_matrix4x4(q)) { }
 #endif
   };
+
+/*! @abstract Templated Matrix struct based on scalar type and number of columns and rows.  */
+template <typename ScalarType, size_t col, size_t row> struct Matrix {
+    //  static const size_t col
+    //  static const size_t row
+    //  typedef scalar_t
+    //  typedef type
+};
+/*! @abstract Helper type to access the simd type easily.                     */
+template <typename ScalarType, size_t col, size_t row>
+using Matrix_t = typename Matrix<ScalarType, col, row>::type;
+
+template<> struct Matrix<float, 2, 2> {
+    static const size_t col = 2;
+    static const size_t row = 2;
+    typedef float scalar_t;
+    typedef float2x2 type;
+};
+
+template<> struct Matrix<float, 3, 2> {
+    static const size_t col = 3;
+    static const size_t row = 2;
+    typedef float scalar_t;
+    typedef float3x2 type;
+};
+
+template<> struct Matrix<float, 4, 2> {
+    static const size_t col = 4;
+    static const size_t row = 2;
+    typedef float scalar_t;
+    typedef float4x2 type;
+};
+
+template<> struct Matrix<float, 2, 3> {
+    static const size_t col = 2;
+    static const size_t row = 3;
+    typedef float scalar_t;
+    typedef float2x3 type;
+};
+
+template<> struct Matrix<float, 3, 3> {
+    static const size_t col = 3;
+    static const size_t row = 3;
+    typedef float scalar_t;
+    typedef float3x3 type;
+};
+
+template<> struct Matrix<float, 4, 3> {
+    static const size_t col = 4;
+    static const size_t row = 3;
+    typedef float scalar_t;
+    typedef float4x3 type;
+};
+
+template<> struct Matrix<float, 2, 4> {
+    static const size_t col = 2;
+    static const size_t row = 4;
+    typedef float scalar_t;
+    typedef float2x4 type;
+};
+
+template<> struct Matrix<float, 3, 4> {
+    static const size_t col = 3;
+    static const size_t row = 4;
+    typedef float scalar_t;
+    typedef float3x4 type;
+};
+
+template<> struct Matrix<float, 4, 4> {
+    static const size_t col = 4;
+    static const size_t row = 4;
+    typedef float scalar_t;
+    typedef float4x4 type;
+};
+
+template<> struct Matrix<double, 2, 2> {
+    static const size_t col = 2;
+    static const size_t row = 2;
+    typedef double scalar_t;
+    typedef double2x2 type;
+};
+
+template<> struct Matrix<double, 3, 2> {
+    static const size_t col = 3;
+    static const size_t row = 2;
+    typedef double scalar_t;
+    typedef double3x2 type;
+};
+
+template<> struct Matrix<double, 4, 2> {
+    static const size_t col = 4;
+    static const size_t row = 2;
+    typedef double scalar_t;
+    typedef double4x2 type;
+};
+
+template<> struct Matrix<double, 2, 3> {
+    static const size_t col = 2;
+    static const size_t row = 3;
+    typedef double scalar_t;
+    typedef double2x3 type;
+};
+
+template<> struct Matrix<double, 3, 3> {
+    static const size_t col = 3;
+    static const size_t row = 3;
+    typedef double scalar_t;
+    typedef double3x3 type;
+};
+
+template<> struct Matrix<double, 4, 3> {
+    static const size_t col = 4;
+    static const size_t row = 3;
+    typedef double scalar_t;
+    typedef double4x3 type;
+};
+
+template<> struct Matrix<double, 2, 4> {
+    static const size_t col = 2;
+    static const size_t row = 4;
+    typedef double scalar_t;
+    typedef double2x4 type;
+};
+
+template<> struct Matrix<double, 3, 4> {
+    static const size_t col = 3;
+    static const size_t row = 4;
+    typedef double scalar_t;
+    typedef double3x4 type;
+};
+
+template<> struct Matrix<double, 4, 4> {
+    static const size_t col = 4;
+    static const size_t row = 4;
+    typedef double scalar_t;
+    typedef double4x4 type;
+};
+
+template <> struct get_traits<float2x2>
+{
+    using type = Matrix<float, 2, 2>;
+};
+
+template <> struct get_traits<float3x2>
+{
+    using type = Matrix<float, 3, 2>;
+};
+
+template <> struct get_traits<float4x2>
+{
+    using type = Matrix<float, 4, 2>;
+};
+
+template <> struct get_traits<float2x3>
+{
+    using type = Matrix<float, 2, 3>;
+};
+
+template <> struct get_traits<float3x3>
+{
+    using type = Matrix<float, 3, 3>;
+};
+
+template <> struct get_traits<float4x3>
+{
+    using type = Matrix<float, 4, 3>;
+};
+
+template <> struct get_traits<float2x4>
+{
+    using type = Matrix<float, 2, 4>;
+};
+
+template <> struct get_traits<float3x4>
+{
+    using type = Matrix<float, 3, 4>;
+};
+
+template <> struct get_traits<float4x4>
+{
+    using type = Matrix<float, 4, 4>;
+};
+
+template <> struct get_traits<double2x2>
+{
+    using type = Matrix<double, 2, 2>;
+};
+
+template <> struct get_traits<double3x2>
+{
+    using type = Matrix<double, 3, 2>;
+};
+
+template <> struct get_traits<double4x2>
+{
+    using type = Matrix<double, 4, 2>;
+};
+
+template <> struct get_traits<double2x3>
+{
+    using type = Matrix<double, 2, 3>;
+};
+
+template <> struct get_traits<double3x3>
+{
+    using type = Matrix<double, 3, 3>;
+};
+
+template <> struct get_traits<double4x3>
+{
+    using type = Matrix<double, 4, 3>;
+};
+
+template <> struct get_traits<double2x4>
+{
+    using type = Matrix<double, 2, 4>;
+};
+
+template <> struct get_traits<double3x4>
+{
+    using type = Matrix<double, 3, 4>;
+};
+
+template <> struct get_traits<double4x4>
+{
+    using type = Matrix<double, 4, 4>;
+};
+
 }
 #endif /* __cplusplus */
 #endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */

@@ -34,6 +34,35 @@
  *  simd_float3 vector = simd_make_float3(ab, 3);
  *  ~~~
  *
+ *  In C++ the above functions are templated in the simd:: namespace.
+ *
+ *      C++ Function                            Equivalent C Function
+ *      -------------------------------------------------------------------
+ *      simd::make<simd::typeN>(x ...)          simd_make_typeN(x ...)
+ *      simd::make_undef<simd::typeN>(x ...)    simd_make_typeN_undef(x ...)
+ *
+ *
+ *  In addition, templated Vector<ScalarType, count> struct is available for
+ *  templated code based on the scalar type.
+ *
+ *      template <typename ScalarType, size_t count> struct simd::Vector {
+ *        //  static const size_t count
+ *        //  typedef scalar_t
+ *        //  typedef type
+ *        //  typedef packed_t
+ *      };
+ *
+ *  Lookup the equivalent Vector struct according to typeN:
+ *      template <typename typeN> struct simd::get_traits
+ *      {
+ *      //    using type = Vector<ScalarType, count>;
+ *      };
+ *
+ *  This is commonly used to get the type traits of typeN, so a helper type,
+ *  namely traits, is available to query the type traits easily.
+ *      simd::traits<typeN>::count
+ *      simd::traits<typeN>::scalar_t
+ *
  *  @copyright 2014-2016 Apple, Inc. All rights reserved.
  *  @unsorted                                                                 */
 
@@ -5278,6 +5307,9 @@ static inline SIMD_CFUNC simd_double8 simd_make_double8(simd_double8 other) {
 #ifdef __cplusplus
 } /* extern "C" */
 
+#include <tuple>
+#include <simd/packed.h>
+
 namespace simd {
 /*! @abstract Concatenates `x` and `y` to form a vector of two 8-bit signed
  *  (twos-complement) integers.                                               */
@@ -6762,6 +6794,1080 @@ template <typename typeN> static SIMD_CPPFUNC double8 make_double8_undef(typeN o
   return ::simd_make_double8_undef(other);
 }
 
+/*! @struct Vector
+ *  @abstract Templated Vector struct based on scalar type and number of
+ *  elements
+ *  @field count Number of elements in the vector
+ *  @field scalar_t The scalar type of each element
+ *  @field type The inferred simd::typeN type
+ *  @field packed_t The inferred simd::packed::typeN type
+ *  @field mask_t The return type of comparison operations                    */
+template <typename ScalarType, size_t count> struct Vector {
+  //  static const size_t count
+  //  typedef scalar_t
+  //  typedef type
+  //  typedef packed_t
+  //  typedef mask_t
+};
+/*! @abstract Helper type to access the simd type easily.                     */
+template <typename ScalarType, size_t count>
+using Vector_t = typename Vector<ScalarType, count>::type;
+
+/*! @abstract Look up the equivalent Vector struct according to the simd
+ *  type.                                                                     */
+template <typename typeN> struct get_traits
+{
+//    using type = Vector<ScalarType, count>;
+};
+/*! @abstract Helper type to access the Vector struct easily.
+ *  @discussion This is commonly used to query the type traits of a simd
+ *  type.
+ *  For example, simd::traits<simd::float4>::count is 4.                      */
+template<typename typeN>
+using traits = typename get_traits<typeN>::type;
+
+template<> struct Vector<char1, 1> {
+  static const size_t count = 1;
+  typedef char1 scalar_t;
+  typedef char1 type;
+  typedef char1 mask_t;
+};
+
+template <> struct get_traits<char1>
+{
+    using type = Vector<char1, 1>;
+};
+
+template<> struct Vector<char1, 2> {
+  static const size_t count = 2;
+  typedef char1 scalar_t;
+  typedef char2 type;
+  typedef packed::char2 packed_t;
+  typedef char2 mask_t;
+};
+
+template <> struct get_traits<char2>
+{
+    using type = Vector<char1, 2>;
+};
+
+template<> struct Vector<char1, 3> {
+  static const size_t count = 3;
+  typedef char1 scalar_t;
+  typedef char3 type;
+  typedef char3 mask_t;
+};
+
+template <> struct get_traits<char3>
+{
+    using type = Vector<char1, 3>;
+};
+
+template<> struct Vector<char1, 4> {
+  static const size_t count = 4;
+  typedef char1 scalar_t;
+  typedef char4 type;
+  typedef packed::char4 packed_t;
+  typedef char4 mask_t;
+};
+
+template <> struct get_traits<char4>
+{
+    using type = Vector<char1, 4>;
+};
+
+template<> struct Vector<char1, 8> {
+  static const size_t count = 8;
+  typedef char1 scalar_t;
+  typedef char8 type;
+  typedef packed::char8 packed_t;
+  typedef char8 mask_t;
+};
+
+template <> struct get_traits<char8>
+{
+    using type = Vector<char1, 8>;
+};
+
+template<> struct Vector<char1, 16> {
+  static const size_t count = 16;
+  typedef char1 scalar_t;
+  typedef char16 type;
+  typedef packed::char16 packed_t;
+  typedef char16 mask_t;
+};
+
+template <> struct get_traits<char16>
+{
+    using type = Vector<char1, 16>;
+};
+
+template<> struct Vector<char1, 32> {
+  static const size_t count = 32;
+  typedef char1 scalar_t;
+  typedef char32 type;
+  typedef packed::char32 packed_t;
+  typedef char32 mask_t;
+};
+
+template <> struct get_traits<char32>
+{
+    using type = Vector<char1, 32>;
+};
+
+template<> struct Vector<char1, 64> {
+  static const size_t count = 64;
+  typedef char1 scalar_t;
+  typedef char64 type;
+  typedef packed::char64 packed_t;
+  typedef char64 mask_t;
+};
+
+template <> struct get_traits<char64>
+{
+    using type = Vector<char1, 64>;
+};
+
+template<> struct Vector<uchar1, 1> {
+  static const size_t count = 1;
+  typedef uchar1 scalar_t;
+  typedef uchar1 type;
+  typedef char1 mask_t;
+};
+
+template <> struct get_traits<uchar1>
+{
+    using type = Vector<uchar1, 1>;
+};
+
+template<> struct Vector<uchar1, 2> {
+  static const size_t count = 2;
+  typedef uchar1 scalar_t;
+  typedef uchar2 type;
+  typedef packed::uchar2 packed_t;
+  typedef char2 mask_t;
+};
+
+template <> struct get_traits<uchar2>
+{
+    using type = Vector<uchar1, 2>;
+};
+
+template<> struct Vector<uchar1, 3> {
+  static const size_t count = 3;
+  typedef uchar1 scalar_t;
+  typedef uchar3 type;
+  typedef char3 mask_t;
+};
+
+template <> struct get_traits<uchar3>
+{
+    using type = Vector<uchar1, 3>;
+};
+
+template<> struct Vector<uchar1, 4> {
+  static const size_t count = 4;
+  typedef uchar1 scalar_t;
+  typedef uchar4 type;
+  typedef packed::uchar4 packed_t;
+  typedef char4 mask_t;
+};
+
+template <> struct get_traits<uchar4>
+{
+    using type = Vector<uchar1, 4>;
+};
+
+template<> struct Vector<uchar1, 8> {
+  static const size_t count = 8;
+  typedef uchar1 scalar_t;
+  typedef uchar8 type;
+  typedef packed::uchar8 packed_t;
+  typedef char8 mask_t;
+};
+
+template <> struct get_traits<uchar8>
+{
+    using type = Vector<uchar1, 8>;
+};
+
+template<> struct Vector<uchar1, 16> {
+  static const size_t count = 16;
+  typedef uchar1 scalar_t;
+  typedef uchar16 type;
+  typedef packed::uchar16 packed_t;
+  typedef char16 mask_t;
+};
+
+template <> struct get_traits<uchar16>
+{
+    using type = Vector<uchar1, 16>;
+};
+
+template<> struct Vector<uchar1, 32> {
+  static const size_t count = 32;
+  typedef uchar1 scalar_t;
+  typedef uchar32 type;
+  typedef packed::uchar32 packed_t;
+  typedef char32 mask_t;
+};
+
+template <> struct get_traits<uchar32>
+{
+    using type = Vector<uchar1, 32>;
+};
+
+template<> struct Vector<uchar1, 64> {
+  static const size_t count = 64;
+  typedef uchar1 scalar_t;
+  typedef uchar64 type;
+  typedef packed::uchar64 packed_t;
+  typedef char64 mask_t;
+};
+
+template <> struct get_traits<uchar64>
+{
+    using type = Vector<uchar1, 64>;
+};
+
+template<> struct Vector<short1, 1> {
+  static const size_t count = 1;
+  typedef short1 scalar_t;
+  typedef short1 type;
+  typedef short1 mask_t;
+};
+
+template <> struct get_traits<short1>
+{
+    using type = Vector<short1, 1>;
+};
+
+template<> struct Vector<short1, 2> {
+  static const size_t count = 2;
+  typedef short1 scalar_t;
+  typedef short2 type;
+  typedef packed::short2 packed_t;
+  typedef short2 mask_t;
+};
+
+template <> struct get_traits<short2>
+{
+    using type = Vector<short1, 2>;
+};
+
+template<> struct Vector<short1, 3> {
+  static const size_t count = 3;
+  typedef short1 scalar_t;
+  typedef short3 type;
+  typedef short3 mask_t;
+};
+
+template <> struct get_traits<short3>
+{
+    using type = Vector<short1, 3>;
+};
+
+template<> struct Vector<short1, 4> {
+  static const size_t count = 4;
+  typedef short1 scalar_t;
+  typedef short4 type;
+  typedef packed::short4 packed_t;
+  typedef short4 mask_t;
+};
+
+template <> struct get_traits<short4>
+{
+    using type = Vector<short1, 4>;
+};
+
+template<> struct Vector<short1, 8> {
+  static const size_t count = 8;
+  typedef short1 scalar_t;
+  typedef short8 type;
+  typedef packed::short8 packed_t;
+  typedef short8 mask_t;
+};
+
+template <> struct get_traits<short8>
+{
+    using type = Vector<short1, 8>;
+};
+
+template<> struct Vector<short1, 16> {
+  static const size_t count = 16;
+  typedef short1 scalar_t;
+  typedef short16 type;
+  typedef packed::short16 packed_t;
+  typedef short16 mask_t;
+};
+
+template <> struct get_traits<short16>
+{
+    using type = Vector<short1, 16>;
+};
+
+template<> struct Vector<short1, 32> {
+  static const size_t count = 32;
+  typedef short1 scalar_t;
+  typedef short32 type;
+  typedef packed::short32 packed_t;
+  typedef short32 mask_t;
+};
+
+template <> struct get_traits<short32>
+{
+    using type = Vector<short1, 32>;
+};
+
+template<> struct Vector<ushort1, 1> {
+  static const size_t count = 1;
+  typedef ushort1 scalar_t;
+  typedef ushort1 type;
+  typedef short1 mask_t;
+};
+
+template <> struct get_traits<ushort1>
+{
+    using type = Vector<ushort1, 1>;
+};
+
+template<> struct Vector<ushort1, 2> {
+  static const size_t count = 2;
+  typedef ushort1 scalar_t;
+  typedef ushort2 type;
+  typedef packed::ushort2 packed_t;
+  typedef short2 mask_t;
+};
+
+template <> struct get_traits<ushort2>
+{
+    using type = Vector<ushort1, 2>;
+};
+
+template<> struct Vector<ushort1, 3> {
+  static const size_t count = 3;
+  typedef ushort1 scalar_t;
+  typedef ushort3 type;
+  typedef short3 mask_t;
+};
+
+template <> struct get_traits<ushort3>
+{
+    using type = Vector<ushort1, 3>;
+};
+
+template<> struct Vector<ushort1, 4> {
+  static const size_t count = 4;
+  typedef ushort1 scalar_t;
+  typedef ushort4 type;
+  typedef packed::ushort4 packed_t;
+  typedef short4 mask_t;
+};
+
+template <> struct get_traits<ushort4>
+{
+    using type = Vector<ushort1, 4>;
+};
+
+template<> struct Vector<ushort1, 8> {
+  static const size_t count = 8;
+  typedef ushort1 scalar_t;
+  typedef ushort8 type;
+  typedef packed::ushort8 packed_t;
+  typedef short8 mask_t;
+};
+
+template <> struct get_traits<ushort8>
+{
+    using type = Vector<ushort1, 8>;
+};
+
+template<> struct Vector<ushort1, 16> {
+  static const size_t count = 16;
+  typedef ushort1 scalar_t;
+  typedef ushort16 type;
+  typedef packed::ushort16 packed_t;
+  typedef short16 mask_t;
+};
+
+template <> struct get_traits<ushort16>
+{
+    using type = Vector<ushort1, 16>;
+};
+
+template<> struct Vector<ushort1, 32> {
+  static const size_t count = 32;
+  typedef ushort1 scalar_t;
+  typedef ushort32 type;
+  typedef packed::ushort32 packed_t;
+  typedef short32 mask_t;
+};
+
+template <> struct get_traits<ushort32>
+{
+    using type = Vector<ushort1, 32>;
+};
+
+template<> struct Vector<int1, 1> {
+  static const size_t count = 1;
+  typedef int1 scalar_t;
+  typedef int1 type;
+  typedef int1 mask_t;
+};
+
+template <> struct get_traits<int1>
+{
+    using type = Vector<int1, 1>;
+};
+
+template<> struct Vector<int1, 2> {
+  static const size_t count = 2;
+  typedef int1 scalar_t;
+  typedef int2 type;
+  typedef packed::int2 packed_t;
+  typedef int2 mask_t;
+};
+
+template <> struct get_traits<int2>
+{
+    using type = Vector<int1, 2>;
+};
+
+template<> struct Vector<int1, 3> {
+  static const size_t count = 3;
+  typedef int1 scalar_t;
+  typedef int3 type;
+  typedef int3 mask_t;
+};
+
+template <> struct get_traits<int3>
+{
+    using type = Vector<int1, 3>;
+};
+
+template<> struct Vector<int1, 4> {
+  static const size_t count = 4;
+  typedef int1 scalar_t;
+  typedef int4 type;
+  typedef packed::int4 packed_t;
+  typedef int4 mask_t;
+};
+
+template <> struct get_traits<int4>
+{
+    using type = Vector<int1, 4>;
+};
+
+template<> struct Vector<int1, 8> {
+  static const size_t count = 8;
+  typedef int1 scalar_t;
+  typedef int8 type;
+  typedef packed::int8 packed_t;
+  typedef int8 mask_t;
+};
+
+template <> struct get_traits<int8>
+{
+    using type = Vector<int1, 8>;
+};
+
+template<> struct Vector<int1, 16> {
+  static const size_t count = 16;
+  typedef int1 scalar_t;
+  typedef int16 type;
+  typedef packed::int16 packed_t;
+  typedef int16 mask_t;
+};
+
+template <> struct get_traits<int16>
+{
+    using type = Vector<int1, 16>;
+};
+
+template<> struct Vector<uint1, 1> {
+  static const size_t count = 1;
+  typedef uint1 scalar_t;
+  typedef uint1 type;
+  typedef int1 mask_t;
+};
+
+template <> struct get_traits<uint1>
+{
+    using type = Vector<uint1, 1>;
+};
+
+template<> struct Vector<uint1, 2> {
+  static const size_t count = 2;
+  typedef uint1 scalar_t;
+  typedef uint2 type;
+  typedef packed::uint2 packed_t;
+  typedef int2 mask_t;
+};
+
+template <> struct get_traits<uint2>
+{
+    using type = Vector<uint1, 2>;
+};
+
+template<> struct Vector<uint1, 3> {
+  static const size_t count = 3;
+  typedef uint1 scalar_t;
+  typedef uint3 type;
+  typedef int3 mask_t;
+};
+
+template <> struct get_traits<uint3>
+{
+    using type = Vector<uint1, 3>;
+};
+
+template<> struct Vector<uint1, 4> {
+  static const size_t count = 4;
+  typedef uint1 scalar_t;
+  typedef uint4 type;
+  typedef packed::uint4 packed_t;
+  typedef int4 mask_t;
+};
+
+template <> struct get_traits<uint4>
+{
+    using type = Vector<uint1, 4>;
+};
+
+template<> struct Vector<uint1, 8> {
+  static const size_t count = 8;
+  typedef uint1 scalar_t;
+  typedef uint8 type;
+  typedef packed::uint8 packed_t;
+  typedef int8 mask_t;
+};
+
+template <> struct get_traits<uint8>
+{
+    using type = Vector<uint1, 8>;
+};
+
+template<> struct Vector<uint1, 16> {
+  static const size_t count = 16;
+  typedef uint1 scalar_t;
+  typedef uint16 type;
+  typedef packed::uint16 packed_t;
+  typedef int16 mask_t;
+};
+
+template <> struct get_traits<uint16>
+{
+    using type = Vector<uint1, 16>;
+};
+
+template<> struct Vector<float1, 1> {
+  static const size_t count = 1;
+  typedef float1 scalar_t;
+  typedef float1 type;
+  typedef int1 mask_t;
+};
+
+template <> struct get_traits<float1>
+{
+    using type = Vector<float1, 1>;
+};
+
+template<> struct Vector<float1, 2> {
+  static const size_t count = 2;
+  typedef float1 scalar_t;
+  typedef float2 type;
+  typedef packed::float2 packed_t;
+  typedef int2 mask_t;
+};
+
+template <> struct get_traits<float2>
+{
+    using type = Vector<float1, 2>;
+};
+
+template<> struct Vector<float1, 3> {
+  static const size_t count = 3;
+  typedef float1 scalar_t;
+  typedef float3 type;
+  typedef int3 mask_t;
+};
+
+template <> struct get_traits<float3>
+{
+    using type = Vector<float1, 3>;
+};
+
+template<> struct Vector<float1, 4> {
+  static const size_t count = 4;
+  typedef float1 scalar_t;
+  typedef float4 type;
+  typedef packed::float4 packed_t;
+  typedef int4 mask_t;
+};
+
+template <> struct get_traits<float4>
+{
+    using type = Vector<float1, 4>;
+};
+
+template<> struct Vector<float1, 8> {
+  static const size_t count = 8;
+  typedef float1 scalar_t;
+  typedef float8 type;
+  typedef packed::float8 packed_t;
+  typedef int8 mask_t;
+};
+
+template <> struct get_traits<float8>
+{
+    using type = Vector<float1, 8>;
+};
+
+template<> struct Vector<float1, 16> {
+  static const size_t count = 16;
+  typedef float1 scalar_t;
+  typedef float16 type;
+  typedef packed::float16 packed_t;
+  typedef int16 mask_t;
+};
+
+template <> struct get_traits<float16>
+{
+    using type = Vector<float1, 16>;
+};
+
+template<> struct Vector<long1, 1> {
+  static const size_t count = 1;
+  typedef long1 scalar_t;
+  typedef long1 type;
+  typedef long1 mask_t;
+};
+
+template <> struct get_traits<long1>
+{
+    using type = Vector<long1, 1>;
+};
+
+template<> struct Vector<long1, 2> {
+  static const size_t count = 2;
+  typedef long1 scalar_t;
+  typedef long2 type;
+  typedef packed::long2 packed_t;
+  typedef long2 mask_t;
+};
+
+template <> struct get_traits<long2>
+{
+    using type = Vector<long1, 2>;
+};
+
+template<> struct Vector<long1, 3> {
+  static const size_t count = 3;
+  typedef long1 scalar_t;
+  typedef long3 type;
+  typedef long3 mask_t;
+};
+
+template <> struct get_traits<long3>
+{
+    using type = Vector<long1, 3>;
+};
+
+template<> struct Vector<long1, 4> {
+  static const size_t count = 4;
+  typedef long1 scalar_t;
+  typedef long4 type;
+  typedef packed::long4 packed_t;
+  typedef long4 mask_t;
+};
+
+template <> struct get_traits<long4>
+{
+    using type = Vector<long1, 4>;
+};
+
+template<> struct Vector<long1, 8> {
+  static const size_t count = 8;
+  typedef long1 scalar_t;
+  typedef long8 type;
+  typedef packed::long8 packed_t;
+  typedef long8 mask_t;
+};
+
+template <> struct get_traits<long8>
+{
+    using type = Vector<long1, 8>;
+};
+
+template<> struct Vector<ulong1, 1> {
+  static const size_t count = 1;
+  typedef ulong1 scalar_t;
+  typedef ulong1 type;
+  typedef long1 mask_t;
+};
+
+template <> struct get_traits<ulong1>
+{
+    using type = Vector<ulong1, 1>;
+};
+
+template<> struct Vector<ulong1, 2> {
+  static const size_t count = 2;
+  typedef ulong1 scalar_t;
+  typedef ulong2 type;
+  typedef packed::ulong2 packed_t;
+  typedef long2 mask_t;
+};
+
+template <> struct get_traits<ulong2>
+{
+    using type = Vector<ulong1, 2>;
+};
+
+template<> struct Vector<ulong1, 3> {
+  static const size_t count = 3;
+  typedef ulong1 scalar_t;
+  typedef ulong3 type;
+  typedef long3 mask_t;
+};
+
+template <> struct get_traits<ulong3>
+{
+    using type = Vector<ulong1, 3>;
+};
+
+template<> struct Vector<ulong1, 4> {
+  static const size_t count = 4;
+  typedef ulong1 scalar_t;
+  typedef ulong4 type;
+  typedef packed::ulong4 packed_t;
+  typedef long4 mask_t;
+};
+
+template <> struct get_traits<ulong4>
+{
+    using type = Vector<ulong1, 4>;
+};
+
+template<> struct Vector<ulong1, 8> {
+  static const size_t count = 8;
+  typedef ulong1 scalar_t;
+  typedef ulong8 type;
+  typedef packed::ulong8 packed_t;
+  typedef long8 mask_t;
+};
+
+template <> struct get_traits<ulong8>
+{
+    using type = Vector<ulong1, 8>;
+};
+
+template<> struct Vector<double1, 1> {
+  static const size_t count = 1;
+  typedef double1 scalar_t;
+  typedef double1 type;
+  typedef long1 mask_t;
+};
+
+template <> struct get_traits<double1>
+{
+    using type = Vector<double1, 1>;
+};
+
+template<> struct Vector<double1, 2> {
+  static const size_t count = 2;
+  typedef double1 scalar_t;
+  typedef double2 type;
+  typedef packed::double2 packed_t;
+  typedef long2 mask_t;
+};
+
+template <> struct get_traits<double2>
+{
+    using type = Vector<double1, 2>;
+};
+
+template<> struct Vector<double1, 3> {
+  static const size_t count = 3;
+  typedef double1 scalar_t;
+  typedef double3 type;
+  typedef long3 mask_t;
+};
+
+template <> struct get_traits<double3>
+{
+    using type = Vector<double1, 3>;
+};
+
+template<> struct Vector<double1, 4> {
+  static const size_t count = 4;
+  typedef double1 scalar_t;
+  typedef double4 type;
+  typedef packed::double4 packed_t;
+  typedef long4 mask_t;
+};
+
+template <> struct get_traits<double4>
+{
+    using type = Vector<double1, 4>;
+};
+
+template<> struct Vector<double1, 8> {
+  static const size_t count = 8;
+  typedef double1 scalar_t;
+  typedef double8 type;
+  typedef packed::double8 packed_t;
+  typedef long8 mask_t;
+};
+
+template <> struct get_traits<double8>
+{
+    using type = Vector<double1, 8>;
+};
+
+#if __has_feature(cxx_constexpr)
+/*! @abstract Templated make function based on return type and argument
+ *  type.                                                                     */
+template<typename typeN, typename... Args>
+static constexpr typeN make(Args... args)
+{
+    if constexpr (traits<typeN>::count == 1)
+    {
+        using FirstArgType = typename std::tuple_element<0, std::tuple<Args...>>::type;
+        if constexpr (std::is_same<FirstArgType, typename traits<FirstArgType>::scalar_t>::value)
+            return typeN(std::get<0>(std::make_tuple(args...)));
+        else
+            return typeN(std::get<0>(std::make_tuple(args...))[0]);
+    }
+    else if constexpr (std::is_same<typeN, char2>::value)
+        return make_char2(args...);
+    else if constexpr (std::is_same<typeN, char3>::value)
+        return make_char3(args...);
+    else if constexpr (std::is_same<typeN, char4>::value)
+        return make_char4(args...);
+    else if constexpr (std::is_same<typeN, char8>::value)
+        return make_char8(args...);
+    else if constexpr (std::is_same<typeN, char16>::value)
+        return make_char16(args...);
+    else if constexpr (std::is_same<typeN, char32>::value)
+        return make_char32(args...);
+    else if constexpr (std::is_same<typeN, char64>::value)
+        return make_char64(args...);
+    else if constexpr (std::is_same<typeN, uchar2>::value)
+        return make_uchar2(args...);
+    else if constexpr (std::is_same<typeN, uchar3>::value)
+        return make_uchar3(args...);
+    else if constexpr (std::is_same<typeN, uchar4>::value)
+        return make_uchar4(args...);
+    else if constexpr (std::is_same<typeN, uchar8>::value)
+        return make_uchar8(args...);
+    else if constexpr (std::is_same<typeN, uchar16>::value)
+        return make_uchar16(args...);
+    else if constexpr (std::is_same<typeN, uchar32>::value)
+        return make_uchar32(args...);
+    else if constexpr (std::is_same<typeN, uchar64>::value)
+        return make_uchar64(args...);
+    else if constexpr (std::is_same<typeN, short2>::value)
+        return make_short2(args...);
+    else if constexpr (std::is_same<typeN, short3>::value)
+        return make_short3(args...);
+    else if constexpr (std::is_same<typeN, short4>::value)
+        return make_short4(args...);
+    else if constexpr (std::is_same<typeN, short8>::value)
+        return make_short8(args...);
+    else if constexpr (std::is_same<typeN, short16>::value)
+        return make_short16(args...);
+    else if constexpr (std::is_same<typeN, short32>::value)
+        return make_short32(args...);
+    else if constexpr (std::is_same<typeN, ushort2>::value)
+        return make_ushort2(args...);
+    else if constexpr (std::is_same<typeN, ushort3>::value)
+        return make_ushort3(args...);
+    else if constexpr (std::is_same<typeN, ushort4>::value)
+        return make_ushort4(args...);
+    else if constexpr (std::is_same<typeN, ushort8>::value)
+        return make_ushort8(args...);
+    else if constexpr (std::is_same<typeN, ushort16>::value)
+        return make_ushort16(args...);
+    else if constexpr (std::is_same<typeN, ushort32>::value)
+        return make_ushort32(args...);
+    else if constexpr (std::is_same<typeN, int2>::value)
+        return make_int2(args...);
+    else if constexpr (std::is_same<typeN, int3>::value)
+        return make_int3(args...);
+    else if constexpr (std::is_same<typeN, int4>::value)
+        return make_int4(args...);
+    else if constexpr (std::is_same<typeN, int8>::value)
+        return make_int8(args...);
+    else if constexpr (std::is_same<typeN, int16>::value)
+        return make_int16(args...);
+    else if constexpr (std::is_same<typeN, uint2>::value)
+        return make_uint2(args...);
+    else if constexpr (std::is_same<typeN, uint3>::value)
+        return make_uint3(args...);
+    else if constexpr (std::is_same<typeN, uint4>::value)
+        return make_uint4(args...);
+    else if constexpr (std::is_same<typeN, uint8>::value)
+        return make_uint8(args...);
+    else if constexpr (std::is_same<typeN, uint16>::value)
+        return make_uint16(args...);
+    else if constexpr (std::is_same<typeN, float2>::value)
+        return make_float2(args...);
+    else if constexpr (std::is_same<typeN, float3>::value)
+        return make_float3(args...);
+    else if constexpr (std::is_same<typeN, float4>::value)
+        return make_float4(args...);
+    else if constexpr (std::is_same<typeN, float8>::value)
+        return make_float8(args...);
+    else if constexpr (std::is_same<typeN, float16>::value)
+        return make_float16(args...);
+    else if constexpr (std::is_same<typeN, long2>::value)
+        return make_long2(args...);
+    else if constexpr (std::is_same<typeN, long3>::value)
+        return make_long3(args...);
+    else if constexpr (std::is_same<typeN, long4>::value)
+        return make_long4(args...);
+    else if constexpr (std::is_same<typeN, long8>::value)
+        return make_long8(args...);
+    else if constexpr (std::is_same<typeN, ulong2>::value)
+        return make_ulong2(args...);
+    else if constexpr (std::is_same<typeN, ulong3>::value)
+        return make_ulong3(args...);
+    else if constexpr (std::is_same<typeN, ulong4>::value)
+        return make_ulong4(args...);
+    else if constexpr (std::is_same<typeN, ulong8>::value)
+        return make_ulong8(args...);
+    else if constexpr (std::is_same<typeN, double2>::value)
+        return make_double2(args...);
+    else if constexpr (std::is_same<typeN, double3>::value)
+        return make_double3(args...);
+    else if constexpr (std::is_same<typeN, double4>::value)
+        return make_double4(args...);
+    else if constexpr (std::is_same<typeN, double8>::value)
+        return make_double8(args...);
+}
+
+/*! @abstract Templated make_undef function based on return type and
+ *  argument type.                                                            */
+template<typename typeN, typename... Args>
+static constexpr typeN make_undef(Args... args)
+{
+    if constexpr (traits<typeN>::count == 1)
+    {
+        using FirstArgType = typename std::tuple_element<0, std::tuple<Args...>>::type;
+        if constexpr (std::is_same<FirstArgType, typename traits<FirstArgType>::scalar_t>::value)
+            return typeN(std::get<0>(std::make_tuple(args...)));
+        else
+            return typeN(std::get<0>(std::make_tuple(args...))[0]);
+    }
+    else if constexpr (std::is_same<typeN, char2>::value)
+        return make_char2_undef(args...);
+    else if constexpr (std::is_same<typeN, char3>::value)
+        return make_char3_undef(args...);
+    else if constexpr (std::is_same<typeN, char4>::value)
+        return make_char4_undef(args...);
+    else if constexpr (std::is_same<typeN, char8>::value)
+        return make_char8_undef(args...);
+    else if constexpr (std::is_same<typeN, char16>::value)
+        return make_char16_undef(args...);
+    else if constexpr (std::is_same<typeN, char32>::value)
+        return make_char32_undef(args...);
+    else if constexpr (std::is_same<typeN, char64>::value)
+        return make_char64_undef(args...);
+    else if constexpr (std::is_same<typeN, uchar2>::value)
+        return make_uchar2_undef(args...);
+    else if constexpr (std::is_same<typeN, uchar3>::value)
+        return make_uchar3_undef(args...);
+    else if constexpr (std::is_same<typeN, uchar4>::value)
+        return make_uchar4_undef(args...);
+    else if constexpr (std::is_same<typeN, uchar8>::value)
+        return make_uchar8_undef(args...);
+    else if constexpr (std::is_same<typeN, uchar16>::value)
+        return make_uchar16_undef(args...);
+    else if constexpr (std::is_same<typeN, uchar32>::value)
+        return make_uchar32_undef(args...);
+    else if constexpr (std::is_same<typeN, uchar64>::value)
+        return make_uchar64_undef(args...);
+    else if constexpr (std::is_same<typeN, short2>::value)
+        return make_short2_undef(args...);
+    else if constexpr (std::is_same<typeN, short3>::value)
+        return make_short3_undef(args...);
+    else if constexpr (std::is_same<typeN, short4>::value)
+        return make_short4_undef(args...);
+    else if constexpr (std::is_same<typeN, short8>::value)
+        return make_short8_undef(args...);
+    else if constexpr (std::is_same<typeN, short16>::value)
+        return make_short16_undef(args...);
+    else if constexpr (std::is_same<typeN, short32>::value)
+        return make_short32_undef(args...);
+    else if constexpr (std::is_same<typeN, ushort2>::value)
+        return make_ushort2_undef(args...);
+    else if constexpr (std::is_same<typeN, ushort3>::value)
+        return make_ushort3_undef(args...);
+    else if constexpr (std::is_same<typeN, ushort4>::value)
+        return make_ushort4_undef(args...);
+    else if constexpr (std::is_same<typeN, ushort8>::value)
+        return make_ushort8_undef(args...);
+    else if constexpr (std::is_same<typeN, ushort16>::value)
+        return make_ushort16_undef(args...);
+    else if constexpr (std::is_same<typeN, ushort32>::value)
+        return make_ushort32_undef(args...);
+    else if constexpr (std::is_same<typeN, int2>::value)
+        return make_int2_undef(args...);
+    else if constexpr (std::is_same<typeN, int3>::value)
+        return make_int3_undef(args...);
+    else if constexpr (std::is_same<typeN, int4>::value)
+        return make_int4_undef(args...);
+    else if constexpr (std::is_same<typeN, int8>::value)
+        return make_int8_undef(args...);
+    else if constexpr (std::is_same<typeN, int16>::value)
+        return make_int16_undef(args...);
+    else if constexpr (std::is_same<typeN, uint2>::value)
+        return make_uint2_undef(args...);
+    else if constexpr (std::is_same<typeN, uint3>::value)
+        return make_uint3_undef(args...);
+    else if constexpr (std::is_same<typeN, uint4>::value)
+        return make_uint4_undef(args...);
+    else if constexpr (std::is_same<typeN, uint8>::value)
+        return make_uint8_undef(args...);
+    else if constexpr (std::is_same<typeN, uint16>::value)
+        return make_uint16_undef(args...);
+    else if constexpr (std::is_same<typeN, float2>::value)
+        return make_float2_undef(args...);
+    else if constexpr (std::is_same<typeN, float3>::value)
+        return make_float3_undef(args...);
+    else if constexpr (std::is_same<typeN, float4>::value)
+        return make_float4_undef(args...);
+    else if constexpr (std::is_same<typeN, float8>::value)
+        return make_float8_undef(args...);
+    else if constexpr (std::is_same<typeN, float16>::value)
+        return make_float16_undef(args...);
+    else if constexpr (std::is_same<typeN, long2>::value)
+        return make_long2_undef(args...);
+    else if constexpr (std::is_same<typeN, long3>::value)
+        return make_long3_undef(args...);
+    else if constexpr (std::is_same<typeN, long4>::value)
+        return make_long4_undef(args...);
+    else if constexpr (std::is_same<typeN, long8>::value)
+        return make_long8_undef(args...);
+    else if constexpr (std::is_same<typeN, ulong2>::value)
+        return make_ulong2_undef(args...);
+    else if constexpr (std::is_same<typeN, ulong3>::value)
+        return make_ulong3_undef(args...);
+    else if constexpr (std::is_same<typeN, ulong4>::value)
+        return make_ulong4_undef(args...);
+    else if constexpr (std::is_same<typeN, ulong8>::value)
+        return make_ulong8_undef(args...);
+    else if constexpr (std::is_same<typeN, double2>::value)
+        return make_double2_undef(args...);
+    else if constexpr (std::is_same<typeN, double3>::value)
+        return make_double3_undef(args...);
+    else if constexpr (std::is_same<typeN, double4>::value)
+        return make_double4_undef(args...);
+    else if constexpr (std::is_same<typeN, double8>::value)
+        return make_double8_undef(args...);
+}
+#endif /* __has_feature(cxx_constexpr) */
 } /* namespace simd */
 #endif /* __cplusplus */
 #endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */