<pre style='margin:0'>
Jeremy Huddleston Sequoia (jeremyhu) pushed a commit to branch master
in repository macports-ports.

</pre>
<p><a href="https://github.com/macports/macports-ports/commit/f666e2c7c3e3a58743ee3aab27b1c16675e7e4e0">https://github.com/macports/macports-ports/commit/f666e2c7c3e3a58743ee3aab27b1c16675e7e4e0</a></p>
<pre style="white-space: pre; background: #F8F8F8"><span style='display:block; white-space:pre;color:#808000;'>commit f666e2c7c3e3a58743ee3aab27b1c16675e7e4e0
</span>Author: Jeremy Huddleston Sequoia <jeremyhu@macports.org>
AuthorDate: Sun Jul 7 14:31:42 2019 -0700

<span style='display:block; white-space:pre;color:#404040;'>    llvm-devel: Add missing patches from previous commit
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    Signed-off-by: Jeremy Huddleston Sequoia <jeremyhu@macports.org>
</span>---
 ...-long-long-math-prototypes-when-using-the.patch |  51 ++++
 ...tomic-using-mutex-lock_guard-for-64b-ops-.patch | 316 +++++++++++++++++++++
 2 files changed, 367 insertions(+)

<span style='display:block; white-space:pre;color:#808080;'>diff --git a/lang/llvm-devel/files/3001-Fix-missing-long-long-math-prototypes-when-using-the.patch b/lang/llvm-devel/files/3001-Fix-missing-long-long-math-prototypes-when-using-the.patch
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 0000000..4d2e8f0
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/lang/llvm-devel/files/3001-Fix-missing-long-long-math-prototypes-when-using-the.patch
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,51 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+From f632702961bff5e226cc09aa9f992e53b95697b2 Mon Sep 17 00:00:00 2001
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+From: Jeremy Huddleston Sequoia <jeremyhu@apple.com>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Date: Sat, 17 Jan 2015 16:26:20 -0800
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Subject: [PATCH 3001/3002] Fix missing long long math prototypes when using
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ the Snow Leopard SDK
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Signed-off-by: Jeremy Huddleston Sequoia <jeremyhu@apple.com>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+---
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ include/math.h | 26 ++++++++++++++++++++++++++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 1 file changed, 26 insertions(+)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+diff --git llvm_master/projects/libcxx/include/math.h macports_master/projects/libcxx/include/math.h
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+index 194df2077..14d14fe08 100644
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- llvm_master/projects/libcxx/include/math.h
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ macports_master/projects/libcxx/include/math.h
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -302,6 +302,32 @@ long double    truncl(long double x);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #include_next <math.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifdef __APPLE__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++# if __has_include(<Availability.h>)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#  include <Availability.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#  if __MAC_OS_X_VERSION_MAX_ALLOWED < 1070
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#    define __APPLE_BAD_MATH_H 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#  else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#    define __APPLE_BAD_MATH_H 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#  endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#  define __APPLE_BAD_MATH_H 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++# if __APPLE_BAD_MATH_H
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* These prototypes are incorrectly omitted from <math.h> on Snow Leopard despite being available */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++extern "C" {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    extern long long int llrintl(long double);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    extern long long int llrint(double);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    extern long long int llrintf(float);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    extern long long int llroundl(long double);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    extern long long int llround(double);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    extern long long int llroundf(float);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++# endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif // __APPLE__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifdef __cplusplus
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // We support including .h headers inside 'extern "C"' contexts, so switch
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-- 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+2.21.0 (Apple Git-120)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;color:#808080;'>diff --git a/lang/llvm-devel/files/3002-implement-atomic-using-mutex-lock_guard-for-64b-ops-.patch b/lang/llvm-devel/files/3002-implement-atomic-using-mutex-lock_guard-for-64b-ops-.patch
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 0000000..2a8ae64
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/lang/llvm-devel/files/3002-implement-atomic-using-mutex-lock_guard-for-64b-ops-.patch
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,316 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+From 6c90424e035a24f3653b1b44f7239925b9e932ac Mon Sep 17 00:00:00 2001
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+From: David Fang <fang@csl.cornell.edu>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Date: Wed, 15 Jan 2014 21:27:34 -0800
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Subject: [PATCH 3002/3002] implement atomic<> using mutex/lock_guard for 64b
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ops on 32b PPC not pretty, not fast, but passes atomic tests
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+---
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ include/__atomic_locked | 240 ++++++++++++++++++++++++++++++++++++++++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ include/atomic          |  46 ++++++++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 2 files changed, 286 insertions(+)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ create mode 100644 include/__atomic_locked
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+diff --git llvm_master/projects/libcxx/include/__atomic_locked macports_master/projects/libcxx/include/__atomic_locked
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+new file mode 100644
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+index 000000000..f10dd747e
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ macports_master/projects/libcxx/include/__atomic_locked
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -0,0 +1,240 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++// -*- C++ -*-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++//===--------------------------- __atomic_locked --------------------------===//
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++//
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++//                     The LLVM Compiler Infrastructure
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++//
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++// This file is distributed under the University of Illinois Open Source
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++// License. See LICENSE.TXT for details.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++//
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++//===----------------------------------------------------------------------===//
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifndef _LIBCPP_ATOMIC_LOCKED
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _LIBCPP_ATOMIC_LOCKED
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <__mutex_base>     // for mutex and lock_guard
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/**
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  This provides slow-but-usable lock-based atomic access to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  structures for which atomic lock-free functions are missing.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  This is motivated by the desire for 64b atomic operations
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  on 32b PowerPC architectures.  
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++**/
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#pragma GCC system_header
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++_LIBCPP_BEGIN_NAMESPACE_STD
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++struct __atomic_mutex_locked  // false
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    mutable _Atomic(_Tp) __a_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    mutable mutex __lock_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    typedef lock_guard<mutex>       lock_type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp& na(void) const { return reinterpret_cast<_Tp&>(__a_); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    volatile _Tp& na(void) const volatile { return reinterpret_cast<volatile _Tp&>(__a_); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    bool is_lock_free() const volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        {return false;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    bool is_lock_free() const _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        {return false;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    void store(_Tp __d, memory_order = memory_order_seq_cst) volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(const_cast<mutex&>(__lock_)); na() = __d; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    void store(_Tp __d, memory_order = memory_order_seq_cst) _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(__lock_); na() = __d; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp load(memory_order = memory_order_seq_cst) const volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(const_cast<mutex&>(__lock_)); return na(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp load(memory_order = memory_order_seq_cst) const _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(__lock_); return na(); }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    operator _Tp() const volatile _NOEXCEPT {return load();}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    operator _Tp() const _NOEXCEPT          {return load();}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp exchange(_Tp __d, memory_order = memory_order_seq_cst) volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(const_cast<mutex&>(__lock_));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  // or use std::swap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++          const _Tp ret = na(); na() = __d; return ret; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp exchange(_Tp __d, memory_order = memory_order_seq_cst) _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(__lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  // or use std::swap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++          const _Tp ret = na(); na() = __d; return ret; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    bool compare_exchange_weak(_Tp& __e, _Tp __d,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                               memory_order __s, memory_order __f) volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(const_cast<mutex&>(__lock_));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (na() == __e) { na() = __d; return true; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    else { __e = na(); return false; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    bool compare_exchange_weak(_Tp& __e, _Tp __d,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                               memory_order __s, memory_order __f) _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(__lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (na() == __e) { na() = __d; return true; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    else { __e = na(); return false; }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    // for now, _weak inditinguishable from _strong
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    bool compare_exchange_strong(_Tp& __e, _Tp __d,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                                 memory_order __s, memory_order __f) volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        {return compare_exchange_weak(__e, __d, __s, __f);}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    bool compare_exchange_strong(_Tp& __e, _Tp __d,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                                 memory_order __s, memory_order __f) _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        {return compare_exchange_weak(__e, __d, __s, __f);}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    bool compare_exchange_weak(_Tp& __e, _Tp __d,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                              memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        {return compare_exchange_weak(__e, __d, __m, __m);}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    bool compare_exchange_weak(_Tp& __e, _Tp __d,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                               memory_order __m = memory_order_seq_cst) _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        {return compare_exchange_weak(__e, __d, __m, __m);}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    bool compare_exchange_strong(_Tp& __e, _Tp __d,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                              memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        {return compare_exchange_strong(__e, __d, __m, __m);}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    bool compare_exchange_strong(_Tp& __e, _Tp __d,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                                 memory_order __m = memory_order_seq_cst) _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        {return compare_exchange_strong(__e, __d, __m, __m);}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    __atomic_mutex_locked() _NOEXCEPT = default;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    __atomic_mutex_locked() _NOEXCEPT : __a_() {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_CONSTEXPR __atomic_mutex_locked(_Tp __d) _NOEXCEPT : __a_(__d) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    __atomic_mutex_locked(const __atomic_mutex_locked&) = delete;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    __atomic_mutex_locked& operator=(const __atomic_mutex_locked&) = delete;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    __atomic_mutex_locked& operator=(const __atomic_mutex_locked&) volatile = delete;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else  // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++private:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    __atomic_mutex_locked(const __atomic_mutex_locked&);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    __atomic_mutex_locked& operator=(const __atomic_mutex_locked&);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    __atomic_mutex_locked& operator=(const __atomic_mutex_locked&) volatile;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif  // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++};        // end struct __atomic_mutex_locked
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++// atomic<Integral>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++template <class _Tp>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++struct __atomic_mutex_locked<_Tp, true>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    : public __atomic_mutex_locked<_Tp, false>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    typedef __atomic_mutex_locked<_Tp, false> __base;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    typedef       typename __base::lock_type      lock_type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    using __base::__lock_;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    using __base::na;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    __atomic_mutex_locked() _NOEXCEPT _LIBCPP_DEFAULT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_CONSTEXPR __atomic_mutex_locked(_Tp __d) _NOEXCEPT : __base(__d) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(const_cast<mutex&>(__lock_));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    const _Tp ret = na(); na() += __op; return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(__lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    const _Tp ret = na(); na() += __op; return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(const_cast<mutex&>(__lock_));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    const _Tp ret = na(); na() -= __op; return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(__lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    const _Tp ret = na(); na() -= __op; return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(const_cast<mutex&>(__lock_));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    const _Tp ret = na(); na() &= __op; return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(__lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    const _Tp ret = na(); na() &= __op; return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(const_cast<mutex&>(__lock_));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    const _Tp ret = na(); na() |= __op; return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(__lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    const _Tp ret = na(); na() |= __op; return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(const_cast<mutex&>(__lock_));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    const _Tp ret = na(); na() ^= __op; return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        { const lock_type g(__lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    const _Tp ret = na(); na() ^= __op; return ret;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator++(int) volatile _NOEXCEPT      {return fetch_add(_Tp(1));}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator++(int) _NOEXCEPT               {return fetch_add(_Tp(1));}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator--(int) volatile _NOEXCEPT      {return fetch_sub(_Tp(1));}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator--(int) _NOEXCEPT               {return fetch_sub(_Tp(1));}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator++() volatile _NOEXCEPT         {return fetch_add(_Tp(1)) + _Tp(1);}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator++() _NOEXCEPT                  {return fetch_add(_Tp(1)) + _Tp(1);}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator--() volatile _NOEXCEPT         {return fetch_sub(_Tp(1)) - _Tp(1);}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator--() _NOEXCEPT                  {return fetch_sub(_Tp(1)) - _Tp(1);}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator+=(_Tp __op) volatile _NOEXCEPT {return fetch_add(__op) + __op;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator+=(_Tp __op) _NOEXCEPT          {return fetch_add(__op) + __op;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator-=(_Tp __op) volatile _NOEXCEPT {return fetch_sub(__op) - __op;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator-=(_Tp __op) _NOEXCEPT          {return fetch_sub(__op) - __op;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator&=(_Tp __op) volatile _NOEXCEPT {return fetch_and(__op) & __op;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator&=(_Tp __op) _NOEXCEPT          {return fetch_and(__op) & __op;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator|=(_Tp __op) volatile _NOEXCEPT {return fetch_or(__op) | __op;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator|=(_Tp __op) _NOEXCEPT          {return fetch_or(__op) | __op;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator^=(_Tp __op) volatile _NOEXCEPT {return fetch_xor(__op) ^ __op;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator^=(_Tp __op) _NOEXCEPT          {return fetch_xor(__op) ^ __op;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++_LIBCPP_END_NAMESPACE_STD
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif  // _LIBCPP_ATOMIC_LOCKED
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+diff --git llvm_master/projects/libcxx/include/atomic macports_master/projects/libcxx/include/atomic
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+index afb431eda..b87307977 100644
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- llvm_master/projects/libcxx/include/atomic
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ macports_master/projects/libcxx/include/atomic
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2439,4 +2439,50 @@ typedef atomic<uintmax_t> atomic_uintmax_t;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ _LIBCPP_END_NAMESPACE_STD
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if       defined(__ppc__) && !defined(__ppc64__)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++// specialize fallback implementation where 64b atomics are missing
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <__atomic_locked>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++_LIBCPP_BEGIN_NAMESPACE_STD
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++template <>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++struct atomic<long long> : public __atomic_mutex_locked<long long>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    typedef long long             _Tp;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    typedef __atomic_mutex_locked<_Tp> __base;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    atomic() _NOEXCEPT _LIBCPP_DEFAULT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_CONSTEXPR atomic(_Tp __d) _NOEXCEPT : __base(__d) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator=(_Tp __d) volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        {__base::store(__d); return __d;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator=(_Tp __d) _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        {__base::store(__d); return __d;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++template <>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++struct atomic<unsigned long long> :
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  public __atomic_mutex_locked<unsigned long long>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    typedef unsigned long long            _Tp;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    typedef __atomic_mutex_locked<_Tp> __base;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    atomic() _NOEXCEPT _LIBCPP_DEFAULT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_CONSTEXPR atomic(_Tp __d) _NOEXCEPT : __base(__d) {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator=(_Tp __d) volatile _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        {__base::store(__d); return __d;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _LIBCPP_INLINE_VISIBILITY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _Tp operator=(_Tp __d) _NOEXCEPT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        {__base::store(__d); return __d;}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++};
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++_LIBCPP_END_NAMESPACE_STD
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif    // defined(__ppc__) && !defined(__ppc64__)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif  // _LIBCPP_ATOMIC
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-- 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+2.21.0 (Apple Git-120)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span></pre><pre style='margin:0'>

</pre>