@zigc/lib 0.17.0-dev.76 → 0.17.0-dev.813

package/libcxx/libc/include/llvm-libc-macros/cfloat16-macros.h

@@ -0,0 +1,20 @@
+//===-- Detection of _Complex _Float16 compiler builtin type --------------===//
+//
+// 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 LLVM_LIBC_MACROS_CFLOAT16_MACROS_H
+#define LLVM_LIBC_MACROS_CFLOAT16_MACROS_H
+
+#if defined(__FLT16_MANT_DIG__) &&                                             \
+    (!defined(__GNUC__) || __GNUC__ >= 13 ||                                   \
+     (defined(__clang__) && __clang_major__ >= 14)) &&                         \
+    !defined(__arm__) && !defined(_M_ARM) && !defined(__riscv) &&              \
+    !defined(_WIN32)
+#define LIBC_TYPES_HAS_CFLOAT16
+#endif
+
+#endif // LLVM_LIBC_MACROS_CFLOAT16_MACROS_H

package/libcxx/libc/include/llvm-libc-macros/wchar-macros.h

@@ -0,0 +1,18 @@
+//===-- Macros defined in wchar.h header file -----------------------------===//
+//
+// 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 LLVM_LIBC_MACROS_WCHAR_MACROS_H
+#define LLVM_LIBC_MACROS_WCHAR_MACROS_H
+
+#include "../llvm-libc-types/wint_t.h"
+
+#ifndef WEOF
+#define WEOF ((wint_t)(0xffffffffu))
+#endif
+
+#endif // LLVM_LIBC_MACROS_WCHAR_MACROS_H

package/libcxx/libc/include/llvm-libc-types/cfloat128.h

@@ -9,36 +9,19 @@
 #ifndef LLVM_LIBC_TYPES_CFLOAT128_H
 #define LLVM_LIBC_TYPES_CFLOAT128_H
 
-#include "../llvm-libc-macros/float-macros.h" // LDBL_MANT_DIG
+#include "../llvm-libc-macros/cfloat128-macros.h"
 
-// Currently, the complex variant of C23 `_Float128` type is only defined as a
-// built-in type in GCC 7 or later, for C and in GCC 13 or later, for C++. For
-// clang, the complex variant of `__float128` is defined instead, and only on
-// x86-64 targets for clang 11 or later.
-//
-// TODO: Update the complex variant of C23 `_Float128` type detection again when
-// clang supports it.
-#ifdef __clang__
-#if (__clang_major__ >= 11) &&                                                 \
-    (defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__))
-// Use _Complex __float128 type. clang uses __SIZEOF_FLOAT128__ or __FLOAT128__
-// macro to notify the availability of __float128 type:
-// https://reviews.llvm.org/D15120
-#define LIBC_TYPES_HAS_CFLOAT128
+#ifdef LIBC_TYPES_HAS_CFLOAT128
+#ifndef LIBC_TYPES_CFLOAT128_IS_COMPLEX_LONG_DOUBLE
+#if defined(__GNUC__) && !defined(__clang__)
+// Remove the workaround when https://gcc.gnu.org/PR32187 gets fixed.
+typedef __typeof__(_Complex __float128) cfloat128;
+#else  // ^^^ workaround / no workaround vvv
 typedef _Complex __float128 cfloat128;
-#endif
-#elif defined(__GNUC__)
-#if (defined(__STDC_IEC_60559_COMPLEX__) || defined(__SIZEOF_FLOAT128__)) &&   \
-    (__GNUC__ >= 13 || (!defined(__cplusplus)))
-#define LIBC_TYPES_HAS_CFLOAT128
-typedef _Complex _Float128 cfloat128;
-#endif
-#endif
-
-#if !defined(LIBC_TYPES_HAS_CFLOAT128) && (LDBL_MANT_DIG == 113)
-#define LIBC_TYPES_HAS_CFLOAT128
-#define LIBC_TYPES_CFLOAT128_IS_COMPLEX_LONG_DOUBLE
+#endif // ^^^ no workaround ^^^
+#else
 typedef _Complex long double cfloat128;
-#endif
+#endif // LIBC_TYPES_CFLOAT128_IS_COMPLEX_LONG_DOUBLE
+#endif // LIBC_TYPES_HAS_CFLOAT128
 
 #endif // LLVM_LIBC_TYPES_CFLOAT128_H

package/libcxx/libc/include/llvm-libc-types/cfloat16.h

@@ -9,13 +9,10 @@
 #ifndef LLVM_LIBC_TYPES_CFLOAT16_H
 #define LLVM_LIBC_TYPES_CFLOAT16_H
 
-#if defined(__FLT16_MANT_DIG__) &&                                             \
-    (!defined(__GNUC__) || __GNUC__ >= 13 ||                                   \
-     (defined(__clang__) && __clang_major__ >= 14)) &&                         \
-    !defined(__arm__) && !defined(_M_ARM) && !defined(__riscv) &&              \
-    !defined(_WIN32)
-#define LIBC_TYPES_HAS_CFLOAT16
+#include "../llvm-libc-macros/cfloat16-macros.h"
+
+#ifdef LIBC_TYPES_HAS_CFLOAT16
 typedef _Complex _Float16 cfloat16;
-#endif
+#endif // LIBC_TYPES_HAS_CFLOAT16
 
 #endif // LLVM_LIBC_TYPES_CFLOAT16_H

package/libcxx/libc/include/llvm-libc-types/wint_t.h

@@ -0,0 +1,14 @@
+//===-- Definition of wint_t types ----------------------------------------===//
+//
+// 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 LLVM_LIBC_TYPES_WINT_T_H
+#define LLVM_LIBC_TYPES_WINT_T_H
+
+typedef __WINT_TYPE__ wint_t;
+
+#endif // LLVM_LIBC_TYPES_WINT_T_H

package/libcxx/libc/shared/libc_common.h

@@ -19,6 +19,11 @@
 #define LIBC_ERRNO_MODE LIBC_ERRNO_MODE_SYSTEM_INLINE
 #endif // LIBC_ERRNO_MODE
 
+// Use system fenv functions in math implementations.
+#ifndef LIBC_MATH_USE_SYSTEM_FENV
+#define LIBC_MATH_USE_SYSTEM_FENV
+#endif // LIBC_MATH_USE_SYSTEM_FENV
+
 #ifndef LIBC_NAMESPACE
 #define LIBC_NAMESPACE __llvm_libc
 #endif // LIBC_NAMESPACE

package/libcxx/libc/src/__support/CPP/bit.h

@@ -11,14 +11,14 @@
 #ifndef LLVM_LIBC_SRC___SUPPORT_CPP_BIT_H
 #define LLVM_LIBC_SRC___SUPPORT_CPP_BIT_H
 
+#include "hdr/stdint_proxy.h"
 #include "src/__support/CPP/limits.h" // numeric_limits
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/macros/attributes.h"
 #include "src/__support/macros/config.h"
+#include "src/__support/macros/properties/compiler.h"
 #include "src/__support/macros/sanitizer.h"
 
-#include <stdint.h>
-
 namespace LIBC_NAMESPACE_DECL {
 namespace cpp {
 
@@ -26,6 +26,16 @@ namespace cpp {
 #define LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE
 #endif
 
+template <unsigned N>
+LIBC_INLINE static void inline_copy(const char *from, char *to) {
+#if __has_builtin(__builtin_memcpy_inline)
+  __builtin_memcpy_inline(to, from, N);
+#else
+  for (unsigned i = 0; i < N; ++i)
+    to[i] = from[i];
+#endif // __has_builtin(__builtin_memcpy_inline)
+}
+
 // This implementation of bit_cast requires trivially-constructible To, to avoid
 // UB in the implementation.
 template <typename To, typename From>
@@ -37,22 +47,32 @@ LIBC_INLINE constexpr cpp::enable_if_t<
     To>
 bit_cast(const From &from) {
   MSAN_UNPOISON(&from, sizeof(From));
-#if __has_builtin(__builtin_bit_cast)
+#if __has_builtin(__builtin_bit_cast) || defined(LIBC_COMPILER_IS_MSVC)
   return __builtin_bit_cast(To, from);
 #else
-  To to;
+  To to{};
   char *dst = reinterpret_cast<char *>(&to);
   const char *src = reinterpret_cast<const char *>(&from);
-#if __has_builtin(__builtin_memcpy_inline)
-  __builtin_memcpy_inline(dst, src, sizeof(To));
-#else
-  for (unsigned i = 0; i < sizeof(To); ++i)
-    dst[i] = src[i];
-#endif // __has_builtin(__builtin_memcpy_inline)
+  inline_copy<sizeof(From)>(src, dst);
   return to;
 #endif // __has_builtin(__builtin_bit_cast)
 }
 
+// The following simple bit copy from a smaller type to maybe-larger type.
+template <typename To, typename From>
+LIBC_INLINE constexpr cpp::enable_if_t<
+    (sizeof(To) >= sizeof(From)) &&
+        cpp::is_trivially_constructible<To>::value &&
+        cpp::is_trivially_copyable<To>::value &&
+        cpp::is_trivially_copyable<From>::value,
+    void>
+bit_copy(const From &from, To &to) {
+  MSAN_UNPOISON(&from, sizeof(From));
+  char *dst = reinterpret_cast<char *>(&to);
+  const char *src = reinterpret_cast<const char *>(&from);
+  inline_copy<sizeof(From)>(src, dst);
+}
+
 template <typename T>
 [[nodiscard]] LIBC_INLINE constexpr cpp::enable_if_t<cpp::is_unsigned_v<T>,
                                                      bool>
@@ -105,10 +125,16 @@ countr_zero(T value) {
 }
 #if __has_builtin(__builtin_ctzs)
 ADD_SPECIALIZATION(countr_zero, unsigned short, __builtin_ctzs)
-#endif
+#endif // __has_builtin(__builtin_ctzs)
+#if __has_builtin(__builtin_ctz)
 ADD_SPECIALIZATION(countr_zero, unsigned int, __builtin_ctz)
+#endif // __has_builtin(__builtin_ctz)
+#if __has_builtin(__builtin_ctzl)
 ADD_SPECIALIZATION(countr_zero, unsigned long, __builtin_ctzl)
+#endif // __has_builtin(__builtin_ctzl)
+#if __has_builtin(__builtin_ctzll)
 ADD_SPECIALIZATION(countr_zero, unsigned long long, __builtin_ctzll)
+#endif // __has_builtin(__builtin_ctzll)
 #endif // __has_builtin(__builtin_ctzg)
 
 /// Count number of 0's from the most significant bit to the least
@@ -144,10 +170,16 @@ countl_zero(T value) {
 }
 #if __has_builtin(__builtin_clzs)
 ADD_SPECIALIZATION(countl_zero, unsigned short, __builtin_clzs)
-#endif
+#endif // __has_builtin(__builtin_clzs)
+#if __has_builtin(__builtin_clz)
 ADD_SPECIALIZATION(countl_zero, unsigned int, __builtin_clz)
+#endif // __has_builtin(__builtin_clz)
+#if __has_builtin(__builtin_clzl)
 ADD_SPECIALIZATION(countl_zero, unsigned long, __builtin_clzl)
+#endif // __has_builtin(__builtin_clzl)
+#if __has_builtin(__builtin_clzll)
 ADD_SPECIALIZATION(countl_zero, unsigned long long, __builtin_clzll)
+#endif // __has_builtin(__builtin_clzll)
 #endif // __has_builtin(__builtin_clzg)
 
 #undef ADD_SPECIALIZATION
@@ -284,11 +316,17 @@ popcount(T value) {
   [[nodiscard]] LIBC_INLINE constexpr int popcount<TYPE>(TYPE value) {         \
     return BUILTIN(value);                                                     \
   }
+#if __has_builtin(__builtin_popcount)
 ADD_SPECIALIZATION(unsigned char, __builtin_popcount)
 ADD_SPECIALIZATION(unsigned short, __builtin_popcount)
 ADD_SPECIALIZATION(unsigned, __builtin_popcount)
+#endif // __builtin_popcount
+#if __has_builtin(__builtin_popcountl)
 ADD_SPECIALIZATION(unsigned long, __builtin_popcountl)
+#endif // __builtin_popcountl
+#if __has_builtin(__builtin_popcountll)
 ADD_SPECIALIZATION(unsigned long long, __builtin_popcountll)
+#endif // __builtin_popcountll
 #endif // __builtin_popcountg
 #undef ADD_SPECIALIZATION
 

package/libcxx/libc/src/__support/CPP/type_traits/is_complex.h

@@ -13,12 +13,17 @@
 #include "src/__support/macros/attributes.h"
 #include "src/__support/macros/config.h"
 // LIBC_TYPES_HAS_CFLOAT16 && LIBC_TYPES_HAS_CFLOAT128
+#include "src/__support/macros/properties/compiler.h"
 #include "src/__support/macros/properties/complex_types.h"
 
 namespace LIBC_NAMESPACE_DECL {
 namespace cpp {
 
 // is_complex
+#ifdef LIBC_COMPILER_IS_MSVC
+// TODO: Add support for complex types with MSVC.
+template <typename T> struct is_complex : false_type {};
+#else
 template <typename T> struct is_complex {
 private:
   template <typename Head, typename... Args>
@@ -40,6 +45,8 @@ public:
 #endif
                               >();
 };
+#endif // LIBC_COMPILER_IS_MSVC
+
 template <typename T>
 LIBC_INLINE_VAR constexpr bool is_complex_v = is_complex<T>::value;
 template <typename T1, typename T2>

package/libcxx/libc/src/__support/CPP/type_traits/is_destructible.h

@@ -15,6 +15,7 @@
 #include "src/__support/CPP/type_traits/remove_all_extents.h"
 #include "src/__support/CPP/type_traits/true_type.h"
 #include "src/__support/CPP/type_traits/type_identity.h"
+#include "src/__support/CPP/utility/declval.h"
 #include "src/__support/macros/attributes.h"
 #include "src/__support/macros/config.h"
 
@@ -22,7 +23,7 @@ namespace LIBC_NAMESPACE_DECL {
 namespace cpp {
 
 // is_destructible
-#if __has_builtin(__is_destructible)
+#if __has_builtin(__is_destructible) || defined(LIBC_COMPILER_IS_MSVC)
 template <typename T>
 struct is_destructible : bool_constant<__is_destructible(T)> {};
 #else

package/libcxx/libc/src/__support/CPP/type_traits/is_unsigned.h

@@ -16,6 +16,8 @@
 #include "src/__support/macros/attributes.h"
 #include "src/__support/macros/config.h"
 
+#include <stddef.h>
+
 namespace LIBC_NAMESPACE_DECL {
 namespace cpp {
 
@@ -46,6 +48,10 @@ public:
   LIBC_INLINE constexpr bool operator()() const { return is_unsigned::value; }
 };
 #endif // LIBC_COMPILER_HAS_FIXED_POINT
+#if LIBC_HAS_VECTOR_TYPE
+template <typename T, size_t N>
+struct is_unsigned<T [[clang::ext_vector_type(N)]]> : bool_constant<false> {};
+#endif
 
 template <typename T>
 LIBC_INLINE_VAR constexpr bool is_unsigned_v = is_unsigned<T>::value;

package/libcxx/libc/src/__support/CPP/utility/integer_sequence.h

@@ -5,12 +5,15 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+
 #ifndef LLVM_LIBC_SRC___SUPPORT_CPP_UTILITY_INTEGER_SEQUENCE_H
 #define LLVM_LIBC_SRC___SUPPORT_CPP_UTILITY_INTEGER_SEQUENCE_H
 
 #include "src/__support/CPP/type_traits/is_integral.h"
 #include "src/__support/macros/config.h"
 
+#include <stddef.h>
+
 namespace LIBC_NAMESPACE_DECL {
 namespace cpp {
 
@@ -34,6 +37,13 @@ template <typename T, int N>
 using make_integer_sequence =
     typename detail::make_integer_sequence<T, N - 1>::type;
 
+// index sequence
+template <size_t... Ints>
+using index_sequence = integer_sequence<size_t, Ints...>;
+template <int N>
+using make_index_sequence =
+    typename detail::make_integer_sequence<size_t, N - 1>::type;
+
 } // namespace cpp
 } // namespace LIBC_NAMESPACE_DECL
 

package/libcxx/libc/src/__support/FPUtil/FPBits.h

@@ -15,6 +15,7 @@
 #ifndef LLVM_LIBC_SRC___SUPPORT_FPUTIL_FPBITS_H
 #define LLVM_LIBC_SRC___SUPPORT_FPUTIL_FPBITS_H
 
+#include "hdr/stdint_proxy.h"
 #include "src/__support/CPP/bit.h"
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/common.h"
@@ -26,8 +27,6 @@
 #include "src/__support/sign.h"                    // Sign
 #include "src/__support/uint128.h"
 
-#include <stdint.h>
-
 namespace LIBC_NAMESPACE_DECL {
 namespace fputil {
 
@@ -790,16 +789,16 @@ struct FPRep : public FPRepImpl<fp_type, FPRep<fp_type>> {
 // Returns the FPType corresponding to C++ type T on the host.
 template <typename T> LIBC_INLINE static constexpr FPType get_fp_type() {
   using UnqualT = cpp::remove_cv_t<T>;
-  if constexpr (cpp::is_same_v<UnqualT, float> && __FLT_MANT_DIG__ == 24)
+  if constexpr (cpp::is_same_v<UnqualT, float> && FLT_MANT_DIG == 24)
     return FPType::IEEE754_Binary32;
-  else if constexpr (cpp::is_same_v<UnqualT, double> && __DBL_MANT_DIG__ == 53)
+  else if constexpr (cpp::is_same_v<UnqualT, double> && DBL_MANT_DIG == 53)
     return FPType::IEEE754_Binary64;
   else if constexpr (cpp::is_same_v<UnqualT, long double>) {
-    if constexpr (__LDBL_MANT_DIG__ == 53)
+    if constexpr (LDBL_MANT_DIG == 53)
       return FPType::IEEE754_Binary64;
-    else if constexpr (__LDBL_MANT_DIG__ == 64)
+    else if constexpr (LDBL_MANT_DIG == 64)
       return FPType::X86_Binary80;
-    else if constexpr (__LDBL_MANT_DIG__ == 113)
+    else if constexpr (LDBL_MANT_DIG == 113)
       return FPType::IEEE754_Binary128;
   }
 #if defined(LIBC_TYPES_HAS_FLOAT16)

package/libcxx/libc/src/__support/FPUtil/rounding_mode.h

@@ -10,18 +10,21 @@
 #define LLVM_LIBC_SRC___SUPPORT_FPUTIL_ROUNDING_MODE_H
 
 #include "hdr/fenv_macros.h"
+#include "src/__support/CPP/type_traits.h"   // is_constant_evaluated
 #include "src/__support/macros/attributes.h" // LIBC_INLINE
 #include "src/__support/macros/config.h"
 
 namespace LIBC_NAMESPACE_DECL {
 namespace fputil {
 
+namespace generic {
+
 // Quick free-standing test whether fegetround() == FE_UPWARD.
 // Using the following observation:
 //   1.0f + 2^-25 = 1.0f        for FE_TONEAREST, FE_DOWNWARD, FE_TOWARDZERO
 //                = 0x1.000002f for FE_UPWARD.
 LIBC_INLINE bool fenv_is_round_up() {
-  volatile float x = 0x1.0p-25f;
+  static volatile float x = 0x1.0p-25f;
   return (1.0f + x != 1.0f);
 }
 
@@ -30,7 +33,7 @@ LIBC_INLINE bool fenv_is_round_up() {
 //   -1.0f - 2^-25 = -1.0f        for FE_TONEAREST, FE_UPWARD, FE_TOWARDZERO
 //                 = -0x1.000002f for FE_DOWNWARD.
 LIBC_INLINE bool fenv_is_round_down() {
-  volatile float x = 0x1.0p-25f;
+  static volatile float x = 0x1.0p-25f;
   return (-1.0f - x != -1.0f);
 }
 
@@ -42,8 +45,8 @@ LIBC_INLINE bool fenv_is_round_down() {
 //                = 0x1.0ffffep-1f for FE_DOWNWARD, FE_TOWARDZERO
 LIBC_INLINE bool fenv_is_round_to_nearest() {
   static volatile float x = 0x1.0p-24f;
-  float y = x;
-  return (1.5f + y == 1.5f - y);
+  float y = 1.5f + x;
+  return (y == 1.5f - x);
 }
 
 // Quick free-standing test whether fegetround() == FE_TOWARDZERO.
@@ -75,6 +78,49 @@ LIBC_INLINE int quick_get_round() {
   return (2.0f + y == 2.0f) ? FE_TONEAREST : FE_UPWARD;
 }
 
+} // namespace generic
+
+LIBC_INLINE static constexpr bool fenv_is_round_up() {
+  if (cpp::is_constant_evaluated()) {
+    return false;
+  } else {
+    return generic::fenv_is_round_up();
+  }
+}
+
+LIBC_INLINE static constexpr bool fenv_is_round_down() {
+  if (cpp::is_constant_evaluated()) {
+    return false;
+  } else {
+    return generic::fenv_is_round_down();
+  }
+}
+
+LIBC_INLINE static constexpr bool fenv_is_round_to_nearest() {
+  if (cpp::is_constant_evaluated()) {
+    return true;
+  } else {
+    return generic::fenv_is_round_to_nearest();
+  }
+}
+
+LIBC_INLINE static constexpr bool fenv_is_round_to_zero() {
+  if (cpp::is_constant_evaluated()) {
+    return false;
+  } else {
+    return generic::fenv_is_round_to_zero();
+  }
+}
+
+// Quick free standing get rounding mode based on the above observations.
+LIBC_INLINE static constexpr int quick_get_round() {
+  if (cpp::is_constant_evaluated()) {
+    return FE_TONEAREST;
+  } else {
+    return generic::quick_get_round();
+  }
+}
+
 } // namespace fputil
 } // namespace LIBC_NAMESPACE_DECL
 

package/libcxx/libc/src/__support/big_int.h

@@ -9,6 +9,7 @@
 #ifndef LLVM_LIBC_SRC___SUPPORT_BIG_INT_H
 #define LLVM_LIBC_SRC___SUPPORT_BIG_INT_H
 
+#include "hdr/stdint_proxy.h"
 #include "src/__support/CPP/array.h"
 #include "src/__support/CPP/bit.h" // countl_zero
 #include "src/__support/CPP/limits.h"
@@ -23,7 +24,6 @@
 #include "src/__support/number_pair.h"
 
 #include <stddef.h> // For size_t
-#include <stdint.h>
 
 namespace LIBC_NAMESPACE_DECL {
 
@@ -95,10 +95,10 @@ LIBC_INLINE constexpr DoubleWide<word> mul2(word a, word b) {
 #endif
   else {
     using half_word = half_width_t<word>;
-    const auto shiftl = [](word value) -> word {
+    constexpr auto shiftl = [](word value) -> word {
       return value << cpp::numeric_limits<half_word>::digits;
     };
-    const auto shiftr = [](word value) -> word {
+    constexpr auto shiftr = [](word value) -> word {
       return value >> cpp::numeric_limits<half_word>::digits;
     };
     // Here we do a one digit multiplication where 'a' and 'b' are of type
@@ -111,19 +111,19 @@ LIBC_INLINE constexpr DoubleWide<word> mul2(word a, word b) {
     //    c         result
     // We convert 'lo' and 'hi' from 'half_word' to 'word' so multiplication
     // doesn't overflow.
-    const word a_lo = lo(a);
-    const word b_lo = lo(b);
-    const word a_hi = hi(a);
-    const word b_hi = hi(b);
-    const word step1 = b_lo * a_lo; // no overflow;
-    const word step2 = b_lo * a_hi; // no overflow;
-    const word step3 = b_hi * a_lo; // no overflow;
-    const word step4 = b_hi * a_hi; // no overflow;
+    word a_lo = lo(a);
+    word b_lo = lo(b);
+    word a_hi = hi(a);
+    word b_hi = hi(b);
+    word step1 = b_lo * a_lo; // no overflow;
+    word step2 = b_lo * a_hi; // no overflow;
+    word step3 = b_hi * a_lo; // no overflow;
+    word step4 = b_hi * a_hi; // no overflow;
     word lo_digit = step1;
     word hi_digit = step4;
-    const word no_carry = 0;
-    word carry;
-    word _; // unused carry variable.
+    word no_carry = 0;
+    word carry = 0;
+    [[maybe_unused]] word _ = 0; // unused carry variable.
     lo_digit = add_with_carry<word>(lo_digit, shiftl(step2), no_carry, carry);
     hi_digit = add_with_carry<word>(hi_digit, shiftr(step2), carry, _);
     lo_digit = add_with_carry<word>(lo_digit, shiftl(step3), no_carry, carry);

package/libcxx/libc/src/__support/common.h

@@ -16,6 +16,7 @@
 #include "src/__support/macros/attributes.h"
 #include "src/__support/macros/config.h"
 #include "src/__support/macros/properties/architectures.h"
+#include "src/__support/macros/properties/compiler.h"
 
 #ifndef LLVM_LIBC_FUNCTION_ATTR
 #define LLVM_LIBC_FUNCTION_ATTR
@@ -41,12 +42,12 @@
 // to cleanly export and alias the C++ symbol `LIBC_NAMESPACE::func` with the C
 // symbol `func`.  So for public packaging on MacOS, we will only export the C
 // symbol.  Moreover, a C symbol `func` in macOS is mangled as `_func`.
-#if defined(LIBC_COPT_PUBLIC_PACKAGING)
+#if defined(LIBC_COPT_PUBLIC_PACKAGING) && !defined(LIBC_COMPILER_IS_MSVC)
 #ifndef __APPLE__
 #define LLVM_LIBC_FUNCTION_IMPL(type, name, arglist)                           \
   LLVM_LIBC_ATTR(name)                                                         \
   LLVM_LIBC_FUNCTION_ATTR decltype(LIBC_NAMESPACE::name)                       \
-      __##name##_impl__ __asm__(#name);                                        \
+      __##name##_impl__ asm(#name);                                            \
   decltype(LIBC_NAMESPACE::name) name [[gnu::alias(#name)]];                   \
   type __##name##_impl__ arglist
 #else // __APPLE__