llvm-runtime-resources-darwin 22.1.8 → 23.1.1

package/include/riscv_vector.h

@@ -20,6 +20,35 @@ extern "C" {
 
 #pragma clang riscv intrinsic vector
 
+#define __riscv_intrinsic_v 1
+#define __riscv_intrinsic_zvabd 1
+#define __riscv_intrinsic_zvbb 1
+#define __riscv_intrinsic_zvbc 1
+#define __riscv_intrinsic_zvdot4a8i 1
+#define __riscv_intrinsic_zve32f 1
+#define __riscv_intrinsic_zve32x 1
+#define __riscv_intrinsic_zve64d 1
+#define __riscv_intrinsic_zve64f 1
+#define __riscv_intrinsic_zve64x 1
+#define __riscv_intrinsic_zvfbfa 1
+#define __riscv_intrinsic_zvfbfmin 1
+#define __riscv_intrinsic_zvfbfwma 1
+#define __riscv_intrinsic_zvfh 1
+#define __riscv_intrinsic_zvfhmin 1
+#define __riscv_intrinsic_zvfofp8min 1
+#define __riscv_intrinsic_zvkb 1
+#define __riscv_intrinsic_zvkg 1
+#define __riscv_intrinsic_zvkn 1
+#define __riscv_intrinsic_zvknc 1
+#define __riscv_intrinsic_zvkned 1
+#define __riscv_intrinsic_zvkng 1
+#define __riscv_intrinsic_zvknha 1
+#define __riscv_intrinsic_zvknhb 1
+#define __riscv_intrinsic_zvks 1
+#define __riscv_intrinsic_zvksc 1
+#define __riscv_intrinsic_zvksed 1
+#define __riscv_intrinsic_zvksg 1
+#define __riscv_intrinsic_zvksh 1
 
 enum __RISCV_FRM {
   __RISCV_FRM_RNE = 0,
@@ -415,6 +444,20 @@ typedef __rvv_bfloat16m2x4_t vbfloat16m2x4_t;
 typedef __rvv_bfloat16m4_t vbfloat16m4_t;
 typedef __rvv_bfloat16m4x2_t vbfloat16m4x2_t;
 typedef __rvv_bfloat16m8_t vbfloat16m8_t;
+typedef __rvv_float8e4m3mf8_t vfloat8e4m3mf8_t;
+typedef __rvv_float8e4m3mf4_t vfloat8e4m3mf4_t;
+typedef __rvv_float8e4m3mf2_t vfloat8e4m3mf2_t;
+typedef __rvv_float8e4m3m1_t vfloat8e4m3m1_t;
+typedef __rvv_float8e4m3m2_t vfloat8e4m3m2_t;
+typedef __rvv_float8e4m3m4_t vfloat8e4m3m4_t;
+typedef __rvv_float8e4m3m8_t vfloat8e4m3m8_t;
+typedef __rvv_float8e5m2mf8_t vfloat8e5m2mf8_t;
+typedef __rvv_float8e5m2mf4_t vfloat8e5m2mf4_t;
+typedef __rvv_float8e5m2mf2_t vfloat8e5m2mf2_t;
+typedef __rvv_float8e5m2m1_t vfloat8e5m2m1_t;
+typedef __rvv_float8e5m2m2_t vfloat8e5m2m2_t;
+typedef __rvv_float8e5m2m4_t vfloat8e5m2m4_t;
+typedef __rvv_float8e5m2m8_t vfloat8e5m2m8_t;
 
 #ifdef __cplusplus
 }

package/include/sanitizer/asan_interface.h

@@ -102,7 +102,7 @@ int SANITIZER_CDECL __asan_address_is_poisoned(void const volatile *addr);
 /// address of the first such byte. Otherwise returns 0.
 ///
 /// \param beg Start of memory region.
-/// \param size Start of memory region.
+/// \param size Size of memory region.
 /// \returns Address of first poisoned byte.
 void *SANITIZER_CDECL __asan_region_is_poisoned(void *beg, size_t size);
 
@@ -174,6 +174,56 @@ int SANITIZER_CDECL __asan_get_report_access_type(void);
 /// \returns Access size in bytes.
 size_t SANITIZER_CDECL __asan_get_report_access_size(void);
 
+/// Gets the source address or address range involved in the current error
+/// (e.g., memcpy source, or the address being read from).
+///
+/// \param out_addr [out] Storage for the address.
+/// \param out_size [out] Storage for the range size.
+///
+/// \returns 1 if found, 0 otherwise.
+int SANITIZER_CDECL __asan_get_report_src_address(const void **out_addr,
+                                                  size_t *out_size);
+
+/// Gets the destination address or address range involved in the current error
+/// (e.g., memcpy dest, or the address being written to).
+///
+/// \param out_addr [out] Storage for the address.
+/// \param out_size [out] Storage for the range size.
+///
+/// \returns 1 if found, 0 otherwise.
+int SANITIZER_CDECL __asan_get_report_dest_address(const void **out_addr,
+                                                   size_t *out_size);
+
+/// Gets the address or address range being deallocated in the current error
+/// (lifetime is terminated).
+///
+/// \param out_addr [out] Storage for the address.
+/// \param out_size [out] Storage for the range size.
+///
+/// \returns 1 if found, 0 otherwise.
+int SANITIZER_CDECL __asan_get_report_dealloc_address(const void **out_addr,
+                                                      size_t *out_size);
+
+/// Gets the first non-dereferenced operand address involved in the current
+/// error (e.g., pointer comparison or ODR violation).
+///
+/// \param out_addr [out] Storage for the address.
+/// \param out_size [out] Storage for the range size. Zero may be reported.
+///
+/// \returns 1 if found, 0 otherwise.
+int SANITIZER_CDECL __asan_get_report_first_address(const void **out_addr,
+                                                    size_t *out_size);
+
+/// Gets the second non-dereferenced operand address involved in the current
+/// error (e.g., pointer comparison or ODR violation).
+///
+/// \param out_addr [out] Storage for the address.
+/// \param out_size [out] Storage for the range size. Zero may be reported.
+///
+/// \returns 1 if found, 0 otherwise.
+int SANITIZER_CDECL __asan_get_report_second_address(const void **out_addr,
+                                                     size_t *out_size);
+
 /// Gets the bug description of an ASan error (useful for calling from a
 /// debugger).
 ///

package/include/sanitizer/common_interface_defs.h

@@ -208,51 +208,6 @@ void SANITIZER_CDECL __sanitizer_annotate_double_ended_contiguous_container(
     const void *new_container_beg, const void *new_container_end);
 #endif
 
-/// Copies memory annotations from a source storage region to a destination
-/// storage region. After the operation, the destination region has the same
-/// memory annotations as the source region, as long as sanitizer limitations
-/// allow it (more bytes may be unpoisoned than in the source region, resulting
-/// in more false negatives, but never false positives). If the source and
-/// destination regions overlap, only the minimal required changes are made to
-/// preserve the correct annotations. Old storage bytes that are not in the new
-/// storage should have the same annotations, as long as sanitizer limitations
-/// allow it.
-///
-/// This function is primarily designed to be used when moving trivially
-/// relocatable objects that may have poisoned memory, making direct copying
-/// problematic under sanitizer. However, this function does not move memory
-/// content itself, only annotations.
-///
-/// A contiguous container is a container that keeps all of its elements in a
-/// contiguous region of memory. The container owns the region of memory
-/// <c>[src_begin, src_end)</c> and <c>[dst_begin, dst_end)</c>. The memory
-/// within these regions may be alternately poisoned and non-poisoned, with
-/// possibly smaller poisoned and unpoisoned regions.
-///
-/// If this function fully poisons a granule, it is marked as "container
-/// overflow".
-///
-/// Argument requirements: The destination container must have the same size as
-/// the source container, which is inferred from the beginning and end of the
-/// source region. Addresses may be granule-unaligned, but this may affect
-/// performance.
-///
-/// \param src_begin Begin of the source container region.
-/// \param src_end End of the source container region.
-/// \param dst_begin Begin of the destination container region.
-/// \param dst_end End of the destination container region.
-#ifdef __SANITIZER_DISABLE_CONTAINER_OVERFLOW__
-__attribute__((__internal_linkage__)) inline void SANITIZER_CDECL
-__sanitizer_copy_contiguous_container_annotations(const void *src_begin,
-                                                  const void *src_end,
-                                                  const void *dst_begin,
-                                                  const void *dst_end) {}
-#else
-void SANITIZER_CDECL __sanitizer_copy_contiguous_container_annotations(
-    const void *src_begin, const void *src_end, const void *dst_begin,
-    const void *dst_end);
-#endif
-
 /// Returns true if the contiguous container <c>[beg, end)</c> is properly
 /// poisoned.
 ///
@@ -273,7 +228,9 @@ void SANITIZER_CDECL __sanitizer_copy_contiguous_container_annotations(
 __attribute__((__internal_linkage__)) inline int
     SANITIZER_CDECL __sanitizer_verify_contiguous_container(const void *beg,
                                                             const void *mid,
-                                                            const void *end) {}
+                                                            const void *end) {
+  return 1;
+}
 #else
 int SANITIZER_CDECL __sanitizer_verify_contiguous_container(const void *beg,
                                                             const void *mid,
@@ -306,7 +263,9 @@ __attribute__((__internal_linkage__)) inline int SANITIZER_CDECL
 __sanitizer_verify_double_ended_contiguous_container(const void *storage_beg,
                                                      const void *container_beg,
                                                      const void *container_end,
-                                                     const void *storage_end) {}
+                                                     const void *storage_end) {
+  return 1;
+}
 #else
 int SANITIZER_CDECL __sanitizer_verify_double_ended_contiguous_container(
     const void *storage_beg, const void *container_beg,
@@ -327,7 +286,9 @@ int SANITIZER_CDECL __sanitizer_verify_double_ended_contiguous_container(
 __attribute__((__internal_linkage__)) inline const void *SANITIZER_CDECL
 __sanitizer_contiguous_container_find_bad_address(const void *beg,
                                                   const void *mid,
-                                                  const void *end) {}
+                                                  const void *end) {
+  return NULL;
+}
 #else
 const void *SANITIZER_CDECL __sanitizer_contiguous_container_find_bad_address(
     const void *beg, const void *mid, const void *end);
@@ -347,7 +308,9 @@ const void *SANITIZER_CDECL __sanitizer_contiguous_container_find_bad_address(
 __attribute__((__internal_linkage__)) inline const void *SANITIZER_CDECL
 __sanitizer_double_ended_contiguous_container_find_bad_address(
     const void *storage_beg, const void *container_beg,
-    const void *container_end, const void *storage_end) {}
+    const void *container_end, const void *storage_end) {
+  return NULL;
+}
 #else
 const void *SANITIZER_CDECL
 __sanitizer_double_ended_contiguous_container_find_bad_address(

package/include/sanitizer/safestack_interface.h

@@ -0,0 +1,50 @@
+//===-- sanitizer/safestack_interface.h -------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of SafeStack.
+//
+// Public interface header.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_SAFESTACK_INTERFACE_H
+#define SANITIZER_SAFESTACK_INTERFACE_H
+
+#include <sanitizer/common_interface_defs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Returns the current unsafe stack pointer of the current thread.
+const void *SANITIZER_CDECL __safestack_get_unsafe_stack_ptr(void);
+
+/// Returns a pointer to the bottom of the unsafe stack of the current thread.
+const void *SANITIZER_CDECL __safestack_get_unsafe_stack_bottom(void);
+
+/// Returns a pointer to the top of the unsafe stack of the current thread.
+const void *SANITIZER_CDECL __safestack_get_unsafe_stack_top(void);
+
+/// Returns a pointer to the top of the unsafe sigalt stack of the current
+/// thread.
+const void *SANITIZER_CDECL __safestack_get_unsafe_sigalt_stack_ptr(void);
+
+/// Returns a pointer to the bottom of the unsafe sigalt stack of the current
+/// thread.
+const void *SANITIZER_CDECL __safestack_get_unsafe_sigalt_stack_bottom(void);
+
+/// Returns a pointer to the top of the unsafe sigalt stack of the current
+/// thread.
+const void *SANITIZER_CDECL __safestack_get_unsafe_sigalt_stack_top(void);
+
+/// Set a new unsafe signal stack context to be used if SA_ONSTACK is set.
+int SANITIZER_CDECL __safestack_unsafe_sigaltstack(size_t ss_size);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // SANITIZER_SAFESTACK_INTERFACE_H

package/include/sanitizer/tysan_interface.h

@@ -0,0 +1,36 @@
+//===-- tysan_interface.h ---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of TypeSanitizer.
+//
+// Public interface header for TySan.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_TYSAN_INTERFACE_H
+#define SANITIZER_TYSAN_INTERFACE_H
+
+#include <sanitizer/common_interface_defs.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Marks a memory region (<c>[addr, addr+size)</c>) as not yet having a type.
+///
+/// TySan will take the next read/write to the memory region to be the correct
+/// type for the memory, and use that for its checks from then on.
+///
+/// \param addr Start of memory region.
+/// \param size Size of memory region.
+void SANITIZER_CDECL __tysan_set_type_unknown(void const *addr, size_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/include/sanitizer/ubsan_interface.h

@@ -27,6 +27,36 @@ extern "C" {
 /// \returns Default options string.
 const char *SANITIZER_CDECL __ubsan_default_options(void);
 
+/// User-provided default suppressions.
+///
+/// You can provide your own implementation of this function to return a string
+/// containing UBSan suppressions.
+///
+/// \returns Default suppressions string.
+const char *SANITIZER_CDECL __ubsan_default_suppressions(void);
+
+/// Set up an interval timer and install a SIGPROF signal handler that crashes
+/// the program if it is stuck in a trap loop generated by -fsanitize-trap-loop.
+///
+/// This function is only intended to be called by single-threaded programs.
+/// Because interval timers are delivered to an arbitrary thread in the process,
+/// it is possible that a thread in a trap loop will never have the signal
+/// delivered to it. For multi-threaded programs, it is recommended to call
+/// OS-specific APIs such as timer_create(CLOCK_THREAD_CPUTIME_ID) on Linux to
+/// install a timer on each thread.
+///
+/// Programs with their own signal handlers can call __ubsan_is_trap_loop from
+/// the signal handler to implement trap loop handling.
+///
+/// This function is currently only supported on Linux/x86.
+void __ubsan_install_trap_loop_detection(void);
+
+/// Returns whether uc (actually a pointer to ucontext_t) indicates that the
+/// thread is stuck in a trap loop generated by -fsanitize-trap-loop.
+///
+/// This function is currently only supported on Linux/x86.
+int __ubsan_is_trap_loop(void *uc);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

package/include/sifive_vector.h

@@ -13,6 +13,24 @@
 
 #pragma clang riscv intrinsic sifive_vector
 
+#define __riscv_intrinsic_xsfmm32a16f 1
+#define __riscv_intrinsic_xsfmm32a32f 1
+#define __riscv_intrinsic_xsfmm32a8f 1
+#define __riscv_intrinsic_xsfmm32a8i 1
+#define __riscv_intrinsic_xsfmm32a 1
+#define __riscv_intrinsic_xsfmm64a64f 1
+#define __riscv_intrinsic_xsfmmbase 1
+#define __riscv_intrinsic_xsfvcp 1
+#define __riscv_intrinsic_xsfvfbfexp16e 1
+#define __riscv_intrinsic_xsfvfexp16e 1
+#define __riscv_intrinsic_xsfvfexp32e 1
+#define __riscv_intrinsic_xsfvfexpa 1
+#define __riscv_intrinsic_xsfvfexpa64e 1
+#define __riscv_intrinsic_xsfvfnrclipxfqf 1
+#define __riscv_intrinsic_xsfvfwmaccqqq 1
+#define __riscv_intrinsic_xsfvqmaccdod 1
+#define __riscv_intrinsic_xsfvqmaccqoq 1
+
 #define __riscv_sf_vc_x_se_u8mf4(p27_26, p24_20, p11_7, rs1, vl)               \
   __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint8_t)rs1, 8, 6, vl)
 #define __riscv_sf_vc_x_se_u8mf2(p27_26, p24_20, p11_7, rs1, vl)               \

package/include/spirvintrin.h

@@ -27,9 +27,6 @@ _Pragma("omp begin declare variant match(device = {arch(spirv64)})");
 #define __gpu_global __attribute__((address_space(1)))
 #define __gpu_generic __attribute__((address_space(4)))
 
-// Attribute to declare a function as a kernel.
-#define __gpu_kernel __attribute__((device_kernel, visibility("protected")))
-
 // Returns the number of workgroups in the 'x' dimension of the grid.
 _DEFAULT_FN_ATTRS static __inline__ uint32_t __gpu_num_blocks_x(void) {
   return __builtin_spirv_num_workgroups(0);
@@ -146,37 +143,13 @@ __gpu_shuffle_idx_u32(uint64_t __lane_mask, uint32_t __idx, uint32_t __x,
   return __builtin_spirv_subgroup_shuffle(__x, __lane);
 }
 
-// Returns a bitmask marking all lanes that have the same value of __x.
-_DEFAULT_FN_ATTRS static __inline__ uint64_t
-__gpu_match_any_u32(uint64_t __lane_mask, uint32_t __x) {
-  return __gpu_match_any_u32_impl(__lane_mask, __x);
-}
-
-// Returns a bitmask marking all lanes that have the same value of __x.
-_DEFAULT_FN_ATTRS static __inline__ uint64_t
-__gpu_match_any_u64(uint64_t __lane_mask, uint64_t __x) {
-  return __gpu_match_any_u64_impl(__lane_mask, __x);
-}
-
-// Returns the current lane mask if every lane contains __x.
-_DEFAULT_FN_ATTRS static __inline__ uint64_t
-__gpu_match_all_u32(uint64_t __lane_mask, uint32_t __x) {
-  return __gpu_match_all_u32_impl(__lane_mask, __x);
-}
-
-// Returns the current lane mask if every lane contains __x.
-_DEFAULT_FN_ATTRS static __inline__ uint64_t
-__gpu_match_all_u64(uint64_t __lane_mask, uint64_t __x) {
-  return __gpu_match_all_u64_impl(__lane_mask, __x);
-}
-
 // SPIR-V does not expose this, always return false.
-_DEFAULT_FN_ATTRS static __inline__ bool __gpu_is_ptr_local(void *ptr) {
+_DEFAULT_FN_ATTRS static __inline__ bool __gpu_is_ptr_local(const void *ptr) {
   return 0;
 }
 
 // SPIR-V does not expose this, always return false.
-_DEFAULT_FN_ATTRS static __inline__ bool __gpu_is_ptr_private(void *ptr) {
+_DEFAULT_FN_ATTRS static __inline__ bool __gpu_is_ptr_private(const void *ptr) {
   return 0;
 }
 

package/include/stdint.h

@@ -805,25 +805,16 @@ typedef __UINTMAX_TYPE__ uintmax_t;
 #endif
 
 /* C99 7.18.3 Limits of other integer types. */
-#define SIG_ATOMIC_MIN __INTN_MIN(__SIG_ATOMIC_WIDTH__)
-#define SIG_ATOMIC_MAX __INTN_MAX(__SIG_ATOMIC_WIDTH__)
-#ifdef __WINT_UNSIGNED__
-# define WINT_MIN       __UINTN_C(__WINT_WIDTH__, 0)
-# define WINT_MAX       __UINTN_MAX(__WINT_WIDTH__)
-#else
-# define WINT_MIN       __INTN_MIN(__WINT_WIDTH__)
-# define WINT_MAX       __INTN_MAX(__WINT_WIDTH__)
-#endif
+#define SIG_ATOMIC_MIN __SIG_ATOMIC_MIN__
+#define SIG_ATOMIC_MAX __SIG_ATOMIC_MAX__
+#define WINT_MIN __WINT_MIN__
+#define WINT_MAX __WINT_MAX__
 
 #ifndef WCHAR_MAX
 # define WCHAR_MAX __WCHAR_MAX__
 #endif
 #ifndef WCHAR_MIN
-# if __WCHAR_MAX__ == __INTN_MAX(__WCHAR_WIDTH__)
-#  define WCHAR_MIN __INTN_MIN(__WCHAR_WIDTH__)
-# else
-#  define WCHAR_MIN __UINTN_C(__WCHAR_WIDTH__, 0)
-# endif
+#define WCHAR_MIN __WCHAR_MIN__
 #endif
 
 /* 7.18.4.2 Macros for greatest-width integer constants. */

package/include/vecintrin.h

@@ -207,7 +207,7 @@ vec_insert(unsigned long long __scalar, __vector unsigned long long __vec,
 #if __ARCH__ >= 12
 static inline __ATTRS_o_ai __vector float
 vec_insert(float __scalar, __vector float __vec, int __index) {
-  __vec[__index & 1] = __scalar;
+  __vec[__index & 3] = __scalar;
   return __vec;
 }
 #endif

package/include/wasm_simd128.h

@@ -45,6 +45,7 @@ typedef int __i32x2 __attribute__((__vector_size__(8), __aligned__(8)));
 typedef unsigned int __u32x2
     __attribute__((__vector_size__(8), __aligned__(8)));
 typedef float __f32x2 __attribute__((__vector_size__(8), __aligned__(8)));
+typedef __fp16 __f16x4 __attribute__((__vector_size__(8), __aligned__(8)));
 
 #define __DEFAULT_FN_ATTRS                                                     \
   __attribute__((__always_inline__, __nodebug__, __target__("simd128"),        \
@@ -2010,6 +2011,22 @@ static __inline__ v128_t __FP16_FN_ATTRS wasm_f16x8_convert_u16x8(v128_t __a) {
   return (v128_t) __builtin_convertvector((__u16x8)__a, __f16x8);
 }
 
+static __inline__ v128_t __FP16_FN_ATTRS
+wasm_f32x4_promote_low_f16x8(v128_t __a) {
+  return (v128_t) __builtin_convertvector(
+      (__f16x4){((__f16x8)__a)[0], ((__f16x8)__a)[1], ((__f16x8)__a)[2],
+                ((__f16x8)__a)[3]},
+      __f32x4);
+}
+
+static __inline__ v128_t __FP16_FN_ATTRS
+wasm_f16x8_demote_f32x4_zero(v128_t __a) {
+  return (v128_t) __builtin_convertvector(
+      __builtin_shufflevector((__f32x4)__a, (__f32x4){0, 0, 0, 0}, 0, 1, 2, 3,
+                              4, 5, 6, 7),
+      __f16x8);
+}
+
 static __inline__ v128_t __FP16_FN_ATTRS wasm_f16x8_relaxed_madd(v128_t __a,
                                                                  v128_t __b,
                                                                  v128_t __c) {

package/include/xmmintrin.h

@@ -341,7 +341,8 @@ _mm_rsqrt_ps(__m128 __a)
 /// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
 ///    minimum value between both operands. The upper 96 bits are copied from
 ///    the upper 96 bits of the first source operand.
-static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_min_ss(__m128 __a, __m128 __b) {
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_min_ss(__m128 __a,
+                                                                 __m128 __b) {
   return __builtin_ia32_minss((__v4sf)__a, (__v4sf)__b);
 }
 
@@ -384,7 +385,8 @@ static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_min_ps(__m128 __a,
 /// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
 ///    maximum value between both operands. The upper 96 bits are copied from
 ///    the upper 96 bits of the first source operand.
-static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_max_ss(__m128 __a, __m128 __b) {
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_max_ss(__m128 __a,
+                                                                 __m128 __b) {
   return __builtin_ia32_maxss((__v4sf)__a, (__v4sf)__b);
 }
 
@@ -2569,11 +2571,10 @@ _mm_avg_pu16(__m64 __a, __m64 __b) {
 /// \returns A 64-bit integer vector whose lower 16 bits contain the sums of the
 ///    sets of absolute differences between both operands. The upper bits are
 ///    cleared.
-static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2
-_mm_sad_pu8(__m64 __a, __m64 __b)
-{
-  return __trunc64(__builtin_ia32_psadbw128((__v16qi)__zext128(__a),
-                                            (__v16qi)__zext128(__b)));
+static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2_CONSTEXPR
+_mm_sad_pu8(__m64 __a, __m64 __b) {
+  return __trunc64(__builtin_ia32_psadbw128((__v16qu)__zext128(__a),
+                                            (__v16qu)__zext128(__b)));
 }
 
 #if defined(__cplusplus)

package/include/zos_wrappers/grp.h

@@ -0,0 +1,19 @@
+/*===----------------------------- grp.h ----------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ZOS_WRAPPERS_GRP_H
+#define __ZOS_WRAPPERS_GRP_H
+#if __has_include_next(<grp.h>)
+#include_next <grp.h>
+#ifdef __grp
+#undef __grp
+#define __grp __grp
+#endif
+#endif /* __has_include_next(<grp.h>) */
+#endif /* __ZOS_WRAPPERS_GRP_H */

package/include/zos_wrappers/locale.h

@@ -0,0 +1,19 @@
+/*===----------------------------- locale.h ---------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ZOS_WRAPPERS_LOCALE_H
+#define __ZOS_WRAPPERS_LOCALE_H
+#if __has_include_next(<locale.h>)
+#include_next <locale.h>
+#ifdef __locale
+#undef __locale
+#define __locale __locale
+#endif
+#endif /* __has_include_next(<locale.h>) */
+#endif /* __ZOS_WRAPPERS_LOCALE_H */

package/include/zos_wrappers/math.h

@@ -0,0 +1,31 @@
+/*===----------------------------- math.h ----------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ZOS_WRAPPERS_MATH_H
+#define __ZOS_WRAPPERS_MATH_H
+#if __has_include_next(<math.h>)
+#include_next <math.h>
+#ifdef __math
+#undef __math
+#define __math __math
+#endif
+#ifndef __BFP__
+#ifdef __cplusplus
+extern "C"
+#endif
+    double fabs(double x) __THROW;
+#endif
+#if !defined(__LP64__) && !defined(__BFP__)
+#ifdef __C99
+#pragma map(tgammaf, "\174\174TGMFH9")
+#pragma map(tgamma, "\174\174TGMAH9")
+#endif
+#endif
+#endif /* __has_include_next(<math.h>) */
+#endif /* __ZOS_WRAPPERS_MATH_H */

package/include/zos_wrappers/poll.h

@@ -0,0 +1,19 @@
+/*===----------------------------- poll.h ----------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ZOS_WRAPPERS_POLL_H
+#define __ZOS_WRAPPERS_POLL_H
+#if __has_include_next(<poll.h>)
+#include_next <poll.h>
+#ifdef __poll
+#undef __poll
+#define __poll __poll
+#endif
+#endif /* __has_include_next(<poll.h>) */
+#endif /* __ZOS_WRAPPERS_POLL_H */

package/include/zos_wrappers/stdlib.h

@@ -0,0 +1,20 @@
+/*===----------------------------- stdlib.h --------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ZOS_WRAPPERS_STDLIB_H
+#define __ZOS_WRAPPERS_STDLIB_H
+#if __has_include_next(<stdlib.h>)
+#include_next <stdlib.h>
+#ifdef _EXT
+#ifndef __CS1
+#undef __cs
+#endif
+#endif /* _EXT */
+#endif /* __has_include_next(<stdlib.h>) */
+#endif /* __ZOS_WRAPPERS_STDLIB_H */

package/include/zos_wrappers/string.h

@@ -0,0 +1,19 @@
+/*===--------------------------- string.h ----------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ZOS_WRAPPERS_STRING_H
+#define __ZOS_WRAPPERS_STRING_H
+#if __has_include_next(<string.h>)
+#include_next <string.h>
+#ifdef __string
+#undef __string
+#define __string __string
+#endif
+#endif /* __has_include_next(<string.h>) */
+#endif /* __ZOS_WRAPPERS_STRING_H */