<pre style='margin:0'>
Ken (kencu) pushed a commit to branch master
in repository macports-ports.

</pre>
<p><a href="https://github.com/macports/macports-ports/commit/01ced2134df8b36eb68236e7183c031c8b86bea7">https://github.com/macports/macports-ports/commit/01ced2134df8b36eb68236e7183c031c8b86bea7</a></p>
<pre style="white-space: pre; background: #F8F8F8"><span style='display:block; white-space:pre;color:#808000;'>commit 01ced2134df8b36eb68236e7183c031c8b86bea7
</span>Author: Ken Cunningham <kencu@macports.org>
AuthorDate: Wed Dec 26 21:31:47 2018 -0500

<span style='display:block; white-space:pre;color:#404040;'>    libcxx: add support for emulated thread_local storage
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    uses all existing technology in libc++ and compiler_rt
</span><span style='display:block; white-space:pre;color:#404040;'>    that is usually purposed to systems such as Android without
</span><span style='display:block; white-space:pre;color:#404040;'>    native TLS, but adds it to darwin 10.6 and earlier that also
</span><span style='display:block; white-space:pre;color:#404040;'>    don't support native TLS in the OS
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    note: we expose cxa_thread_atexit in the cxxabi.h header as well
</span><span style='display:block; white-space:pre;color:#404040;'>    when emulated thread_local storage is enabled
</span>---
 lang/libcxx/Portfile                               |  28 +-
 lang/libcxx/files/0005-libcxxabi-add-emutls.patch  | 871 +++++++++++++++++++++
 .../0006-libcxxabi-buildit-build-emutls.patch      |  14 +
 ...ibcxxabi-include-expose-cxa-thread-atexit.patch |  19 +
 4 files changed, 929 insertions(+), 3 deletions(-)

<span style='display:block; white-space:pre;color:#808080;'>diff --git a/lang/libcxx/Portfile b/lang/libcxx/Portfile
</span><span style='display:block; white-space:pre;color:#808080;'>index 419acd4..cd0ef97 100644
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>--- a/lang/libcxx/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/lang/libcxx/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -4,7 +4,7 @@ PortGroup               compiler_blacklist_versions 1.0
</span> name                    libcxx
 epoch                   1
 version                 5.0.1
<span style='display:block; white-space:pre;background:#ffe0e0;'>-revision                2
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+revision                3
</span> categories              lang
 platforms               darwin
 license                 MIT NCSA
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -72,6 +72,16 @@ if {${os.major} < 11 || [variant_isset replacemnt_libcxx]} {
</span>     variant universal {}
     default_variants +universal
 
<span style='display:block; white-space:pre;background:#e0ffe0;'>+    if {${os.major} < 11} {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        variant emulated_tls description {build libcxxabi and libcxx with support for emulated thread_local storage} {}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    # only selected clang versions support emulated-tls
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    foreach ver {5.0} {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        if {[file exists ${prefix}/bin/clang-mp-${ver}] && ${os.major} < 11} {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            default_variants-append +emulated_tls
</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>     compiler.blacklist *gcc* {clang < 500}
 
     # clang 3.5 and newer are conditionally blacklisted to prevent dependency cycles
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -95,8 +105,11 @@ if {${os.major} < 11 || [variant_isset replacemnt_libcxx]} {
</span>         # but the buildit script just builds every file in the src directory and you can't have both
         delete ${libcxxabi_worksrcpath}/src/cxa_noexception.cpp
 
<span style='display:block; white-space:pre;background:#ffe0e0;'>-        # cmake doesn't include this for darwin builds, so nuke it here as well
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>-        delete ${libcxxabi_worksrcpath}/src/cxa_thread_atexit.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        if {![variant_isset emulated_tls]} {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            # cmake doesn't include this for darwin builds, so nuke it here as well
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            # however, this file is essential for emulated-tls to function
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+            delete ${libcxxabi_worksrcpath}/src/cxa_thread_atexit.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        }
</span> 
         file mkdir ${workpath}/build
         file copy ${filespath}/Makefile ${workpath}/build
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -112,6 +125,15 @@ if {${os.major} < 11 || [variant_isset replacemnt_libcxx]} {
</span>         0003-libcxxabi-buildit-Use-undefined-dynamic_lookup-when-linking.patch    \
         0004-libcxxabi-buildit-add-nostdinc++.diff
 
<span style='display:block; white-space:pre;background:#e0ffe0;'>+    if {[variant_isset emulated_tls]} {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      # add emutls.c support for cxa_thread_atexit directly into libcxxabi
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      # these files were taken from clang-7.0's compiler-rt subproject
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+      patchfiles-append \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        0005-libcxxabi-add-emutls.patch                                           \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        0006-libcxxabi-buildit-build-emutls.patch                                 \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        0007-libcxxabi-include-expose-cxa-thread-atexit.patch
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span>     # restore libc++ buildit and patches for libc++ buildit
     patchfiles-append \
         1001-Revert-Remove-the-buildit-and-testit-scripts-they-ha.patch          \
<span style='display:block; white-space:pre;color:#808080;'>diff --git a/lang/libcxx/files/0005-libcxxabi-add-emutls.patch b/lang/libcxx/files/0005-libcxxabi-add-emutls.patch
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 0000000..0c45474
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/lang/libcxx/files/0005-libcxxabi-add-emutls.patch
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,871 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+diff --git libcxxabi-5.0.1.src/src/emutls.c libcxxabi-5.0.1.src/src/emutls.c
</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 0000000..0907edc
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ libcxxabi-5.0.1.src/src/emutls.c
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -0,0 +1,394 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* ===---------- emutls.c - Implements __emutls_get_address ---------------===
</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 dual licensed under the MIT and the University of Illinois Open
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * Source Licenses. 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;'>++#include <stdint.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <stdlib.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <string.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include "int_lib.h"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include "int_util.h"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifdef __BIONIC__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* There are 4 pthread key cleanup rounds on Bionic. Delay emutls deallocation
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++   to round 2. We need to delay deallocation because:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    - Android versions older than M lack __cxa_thread_atexit_impl, so apps
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++      use a pthread key destructor to call C++ destructors.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    - Apps might use __thread/thread_local variables in pthread destructors.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++   We can't wait until the final two rounds, because jemalloc needs two rounds
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++   after the final malloc/free call to free its thread-specific data (see
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++   https://reviews.llvm.org/D46978#1107507). */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define EMUTLS_SKIP_DESTRUCTOR_ROUNDS 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define EMUTLS_SKIP_DESTRUCTOR_ROUNDS 0
</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;'>++typedef struct emutls_address_array {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    uintptr_t skip_destructor_rounds;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    uintptr_t size;  /* number of elements in the 'data' array */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    void* data[];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++} emutls_address_array;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static void emutls_shutdown(emutls_address_array *array);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifndef _WIN32
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <pthread.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static pthread_mutex_t emutls_mutex = PTHREAD_MUTEX_INITIALIZER;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static pthread_key_t emutls_pthread_key;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef unsigned int gcc_word __attribute__((mode(word)));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef unsigned int gcc_pointer __attribute__((mode(pointer)));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* Default is not to use posix_memalign, so systems like Android
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * can use thread local data without heavier POSIX memory allocators.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifndef EMUTLS_USE_POSIX_MEMALIGN
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define EMUTLS_USE_POSIX_MEMALIGN 0
</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;'>++static __inline void *emutls_memalign_alloc(size_t align, size_t size) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    void *base;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if EMUTLS_USE_POSIX_MEMALIGN
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (posix_memalign(&base, align, size) != 0)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        abort();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    #define EXTRA_ALIGN_PTR_BYTES (align - 1 + sizeof(void*))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    char* object;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if ((object = (char*)malloc(EXTRA_ALIGN_PTR_BYTES + size)) == NULL)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        abort();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    base = (void*)(((uintptr_t)(object + EXTRA_ALIGN_PTR_BYTES))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                    & ~(uintptr_t)(align - 1));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ((void**)base)[-1] = object;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return base;
</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;'>++static __inline void emutls_memalign_free(void *base) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if EMUTLS_USE_POSIX_MEMALIGN
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    free(base);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    /* The mallocated address is in ((void**)base)[-1] */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    free(((void**)base)[-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;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static __inline void emutls_setspecific(emutls_address_array *value) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    pthread_setspecific(emutls_pthread_key, (void*) value);
</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;'>++static __inline emutls_address_array* emutls_getspecific() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return (emutls_address_array*) pthread_getspecific(emutls_pthread_key);
</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;'>++static void emutls_key_destructor(void* ptr) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    emutls_address_array *array = (emutls_address_array*)ptr;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (array->skip_destructor_rounds > 0) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        /* emutls is deallocated using a pthread key destructor. These
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++         * destructors are called in several rounds to accommodate destructor
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++         * functions that (re)initialize key values with pthread_setspecific.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++         * Delay the emutls deallocation to accommodate other end-of-thread
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++         * cleanup tasks like calling thread_local destructors (e.g. the
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++         * __cxa_thread_atexit fallback in libc++abi).
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++         */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        array->skip_destructor_rounds--;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        emutls_setspecific(array);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    } else {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        emutls_shutdown(array);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        free(ptr);
</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;'>++static __inline void emutls_init(void) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (pthread_key_create(&emutls_pthread_key, emutls_key_destructor) != 0)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        abort();
</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;'>++static __inline void emutls_init_once(void) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    static pthread_once_t once = PTHREAD_ONCE_INIT;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    pthread_once(&once, emutls_init);
</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;'>++static __inline void emutls_lock() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    pthread_mutex_lock(&emutls_mutex);
</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;'>++static __inline void emutls_unlock() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    pthread_mutex_unlock(&emutls_mutex);
</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;'>++#else /* _WIN32 */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <windows.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <malloc.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <stdio.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <assert.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static LPCRITICAL_SECTION emutls_mutex;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static DWORD emutls_tls_index = TLS_OUT_OF_INDEXES;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef uintptr_t gcc_word;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef void * gcc_pointer;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static void win_error(DWORD last_err, const char *hint) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    char *buffer = NULL;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                       FORMAT_MESSAGE_FROM_SYSTEM |
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                       FORMAT_MESSAGE_MAX_WIDTH_MASK,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                       NULL, last_err, 0, (LPSTR)&buffer, 1, NULL)) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        fprintf(stderr, "Windows error: %s\n", buffer);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    } else {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        fprintf(stderr, "Unkown Windows error: %s\n", hint);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    LocalFree(buffer);
</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;'>++static __inline void win_abort(DWORD last_err, const char *hint) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    win_error(last_err, hint);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    abort();
</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;'>++static __inline void *emutls_memalign_alloc(size_t align, size_t size) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    void *base = _aligned_malloc(size, align);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (!base)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        win_abort(GetLastError(), "_aligned_malloc");
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return base;
</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;'>++static __inline void emutls_memalign_free(void *base) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    _aligned_free(base);
</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;'>++static void emutls_exit(void) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (emutls_mutex) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        DeleteCriticalSection(emutls_mutex);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        _aligned_free(emutls_mutex);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        emutls_mutex = NULL;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (emutls_tls_index != TLS_OUT_OF_INDEXES) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        emutls_shutdown((emutls_address_array*)TlsGetValue(emutls_tls_index));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        TlsFree(emutls_tls_index);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        emutls_tls_index = TLS_OUT_OF_INDEXES;
</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;'>++#pragma warning (push)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#pragma warning (disable : 4100)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static BOOL CALLBACK emutls_init(PINIT_ONCE p0, PVOID p1, PVOID *p2) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    emutls_mutex = (LPCRITICAL_SECTION)_aligned_malloc(sizeof(CRITICAL_SECTION), 16);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (!emutls_mutex) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        win_error(GetLastError(), "_aligned_malloc");
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        return FALSE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    InitializeCriticalSection(emutls_mutex);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    emutls_tls_index = TlsAlloc();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (emutls_tls_index == TLS_OUT_OF_INDEXES) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        emutls_exit();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        win_error(GetLastError(), "TlsAlloc");
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        return FALSE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    atexit(&emutls_exit);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return TRUE;
</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;'>++static __inline void emutls_init_once(void) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    static INIT_ONCE once;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    InitOnceExecuteOnce(&once, emutls_init, NULL, NULL);
</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;'>++static __inline void emutls_lock() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    EnterCriticalSection(emutls_mutex);
</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;'>++static __inline void emutls_unlock() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    LeaveCriticalSection(emutls_mutex);
</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;'>++static __inline void emutls_setspecific(emutls_address_array *value) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (TlsSetValue(emutls_tls_index, (LPVOID) value) == 0)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        win_abort(GetLastError(), "TlsSetValue");
</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;'>++static __inline emutls_address_array* emutls_getspecific() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    LPVOID value = TlsGetValue(emutls_tls_index);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (value == NULL) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        const DWORD err = GetLastError();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        if (err != ERROR_SUCCESS)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++            win_abort(err, "TlsGetValue");
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return (emutls_address_array*) value;
</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;'>++/* Provide atomic load/store functions for emutls_get_index if built with MSVC.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if !defined(__ATOMIC_RELEASE)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <intrin.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++enum { __ATOMIC_ACQUIRE = 2, __ATOMIC_RELEASE = 3 };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static __inline uintptr_t __atomic_load_n(void *ptr, unsigned type) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    assert(type == __ATOMIC_ACQUIRE);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    // These return the previous value - but since we do an OR with 0,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    // it's equivalent to a plain load.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifdef _WIN64
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return InterlockedOr64(ptr, 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return InterlockedOr(ptr, 0);
</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;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static __inline void __atomic_store_n(void *ptr, uintptr_t val, unsigned type) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    assert(type == __ATOMIC_RELEASE);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    InterlockedExchangePointer((void *volatile *)ptr, (void *)val);
</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;'>++#endif /* __ATOMIC_RELEASE */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#pragma warning (pop)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* _WIN32 */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t emutls_num_object = 0;  /* number of allocated TLS objects */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* Free the allocated TLS data
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static void emutls_shutdown(emutls_address_array *array) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (array) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        uintptr_t i;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        for (i = 0; i < array->size; ++i) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++            if (array->data[i])
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                emutls_memalign_free(array->data[i]);
</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;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* For every TLS variable xyz,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * there is one __emutls_control variable named __emutls_v.xyz.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * If xyz has non-zero initial value, __emutls_v.xyz's "value"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * will point to __emutls_t.xyz, which has the initial value.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef struct __emutls_control {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    /* Must use gcc_word here, instead of size_t, to match GCC.  When
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++       gcc_word is larger than size_t, the upper extra bits are all
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++       zeros.  We can use variables of size_t to operate on size and
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++       align.  */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    gcc_word size;  /* size of the object in bytes */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    gcc_word align;  /* alignment of the object in bytes */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    union {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        uintptr_t index;  /* data[index-1] is the object address */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        void* address;  /* object address, when in single thread env */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    } object;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    void* value;  /* null or non-zero initial value for the object */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++} __emutls_control;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* Emulated TLS objects are always allocated at run-time. */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static __inline void *emutls_allocate_object(__emutls_control *control) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    /* Use standard C types, check with gcc's emutls.o. */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    COMPILE_TIME_ASSERT(sizeof(uintptr_t) == sizeof(gcc_pointer));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    COMPILE_TIME_ASSERT(sizeof(uintptr_t) == sizeof(void*));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    size_t size = control->size;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    size_t align = control->align;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    void* base;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (align < sizeof(void*))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        align = sizeof(void*);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    /* Make sure that align is power of 2. */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if ((align & (align - 1)) != 0)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        abort();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    base = emutls_memalign_alloc(align, size);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (control->value)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        memcpy(base, control->value, size);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        memset(base, 0, size);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return base;
</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;'>++/* Returns control->object.index; set index if not allocated yet. */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static __inline uintptr_t emutls_get_index(__emutls_control *control) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    uintptr_t index = __atomic_load_n(&control->object.index, __ATOMIC_ACQUIRE);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (!index) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        emutls_init_once();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        emutls_lock();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        index = control->object.index;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        if (!index) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++            index = ++emutls_num_object;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++            __atomic_store_n(&control->object.index, index, __ATOMIC_RELEASE);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        emutls_unlock();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return index;
</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;'>++/* Updates newly allocated thread local emutls_address_array. */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static __inline void emutls_check_array_set_size(emutls_address_array *array,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                                                 uintptr_t size) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (array == NULL)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        abort();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    array->size = size;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    emutls_setspecific(array);
</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;'>++/* Returns the new 'data' array size, number of elements,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * which must be no smaller than the given index.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static __inline uintptr_t emutls_new_data_array_size(uintptr_t index) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++   /* Need to allocate emutls_address_array with extra slots
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    * to store the header.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    * Round up the emutls_address_array size to multiple of 16.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    uintptr_t header_words = sizeof(emutls_address_array) / sizeof(void *);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return ((index + header_words + 15) & ~((uintptr_t)15)) - header_words;
</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;'>++/* Returns the size in bytes required for an emutls_address_array with
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * N number of elements for data field.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static __inline uintptr_t emutls_asize(uintptr_t N) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return N * sizeof(void *) + sizeof(emutls_address_array);
</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;'>++/* Returns the thread local emutls_address_array.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * Extends its size if necessary to hold address at index.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static __inline emutls_address_array *
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++emutls_get_address_array(uintptr_t index) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    emutls_address_array* array = emutls_getspecific();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (array == NULL) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        uintptr_t new_size = emutls_new_data_array_size(index);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        array = (emutls_address_array*) malloc(emutls_asize(new_size));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        if (array) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++            memset(array->data, 0, new_size * sizeof(void*));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++            array->skip_destructor_rounds = EMUTLS_SKIP_DESTRUCTOR_ROUNDS;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        emutls_check_array_set_size(array, new_size);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    } else if (index > array->size) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        uintptr_t orig_size = array->size;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        uintptr_t new_size = emutls_new_data_array_size(index);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        array = (emutls_address_array*) realloc(array, emutls_asize(new_size));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        if (array)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++            memset(array->data + orig_size, 0,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                   (new_size - orig_size) * sizeof(void*));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        emutls_check_array_set_size(array, new_size);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return array;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifndef _WIN32
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++__attribute__((visibility("default")))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++void* __emutls_get_address(__emutls_control* control) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    uintptr_t index = emutls_get_index(control);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    emutls_address_array* array = emutls_get_address_array(index--);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    if (array->data[index] == NULL)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        array->data[index] = emutls_allocate_object(control);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return array->data[index];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+diff --git libcxxabi-5.0.1.src/include/int_lib.h libcxxabi-5.0.1.src/include/int_lib.h
</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 0000000..9d09e2d
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ libcxxabi-5.0.1.src/include/int_lib.h
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -0,0 +1,134 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* ===-- int_lib.h - configuration header for compiler-rt  -----------------===
</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 dual licensed under the MIT and the University of Illinois Open
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * Source Licenses. 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;'>++ * This file is a configuration header for compiler-rt.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * This file is not part of the interface of this library.
</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;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifndef INT_LIB_H
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define INT_LIB_H
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* Assumption: Signed integral is 2's complement. */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* Assumption: Right shift of signed negative is arithmetic shift. */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* Assumption: Endianness is little or big (not mixed). */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if defined(__ELF__)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define FNALIAS(alias_name, original_name) \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  void alias_name() __attribute__((__alias__(#original_name)))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define COMPILER_RT_ALIAS(aliasee) __attribute__((__alias__(#aliasee)))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define FNALIAS(alias, name) _Pragma("GCC error(\"alias unsupported on this file format\")")
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define COMPILER_RT_ALIAS(aliasee) _Pragma("GCC error(\"alias unsupported on this file format\")")
</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;'>++/* ABI macro definitions */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if __ARM_EABI__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++# ifdef COMPILER_RT_ARMHF_TARGET
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#   define COMPILER_RT_ABI
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++# else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#   define COMPILER_RT_ABI __attribute__((__pcs__("aapcs")))
</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 COMPILER_RT_ABI
</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;'>++#define AEABI_RTABI __attribute__((__pcs__("aapcs")))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifdef _MSC_VER
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define ALWAYS_INLINE __forceinline
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define NOINLINE __declspec(noinline)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define NORETURN __declspec(noreturn)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define UNUSED
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define ALWAYS_INLINE __attribute__((always_inline))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define NOINLINE __attribute__((noinline))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define NORETURN __attribute__((noreturn))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define UNUSED __attribute__((unused))
</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 defined(__NetBSD__) && (defined(_KERNEL) || defined(_STANDALONE))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/*
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * Kernel and boot environment can't use normal headers,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * so use the equivalent system headers.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#  include <machine/limits.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#  include <sys/stdint.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#  include <sys/types.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* Include the standard compiler builtin headers we use functionality from. */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#  include <limits.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#  include <stdint.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#  include <stdbool.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#  include <float.h>
</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;'>++/* Include the commonly used internal type definitions. */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include "int_types.h"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* Include internal utility function declarations. */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include "int_util.h"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++COMPILER_RT_ABI si_int __paritysi2(si_int a);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++COMPILER_RT_ABI si_int __paritydi2(di_int a);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++COMPILER_RT_ABI di_int __divdi3(di_int a, di_int b);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++COMPILER_RT_ABI si_int __divsi3(si_int a, si_int b);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++COMPILER_RT_ABI su_int __udivsi3(su_int n, su_int d);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++COMPILER_RT_ABI su_int __udivmodsi4(su_int a, su_int b, su_int* rem);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++COMPILER_RT_ABI du_int __udivmoddi4(du_int a, du_int b, du_int* rem);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifdef CRT_HAS_128BIT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++COMPILER_RT_ABI si_int __clzti2(ti_int a);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++COMPILER_RT_ABI tu_int __udivmodti4(tu_int a, tu_int b, tu_int* rem);
</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;'>++/* Definitions for builtins unavailable on MSVC */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if defined(_MSC_VER) && !defined(__clang__)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <intrin.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++uint32_t __inline __builtin_ctz(uint32_t value) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  unsigned long trailing_zero = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  if (_BitScanForward(&trailing_zero, value))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return trailing_zero;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  return 32;
</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;'>++uint32_t __inline __builtin_clz(uint32_t value) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  unsigned long leading_zero = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  if (_BitScanReverse(&leading_zero, value))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return 31 - leading_zero;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  return 32;
</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(_M_ARM) || defined(_M_X64)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++uint32_t __inline __builtin_clzll(uint64_t value) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  unsigned long leading_zero = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  if (_BitScanReverse64(&leading_zero, value))
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return 63 - leading_zero;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  return 64;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++}
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++uint32_t __inline __builtin_clzll(uint64_t value) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  if (value == 0)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return 64;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  uint32_t msh = (uint32_t)(value >> 32);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  uint32_t lsh = (uint32_t)(value & 0xFFFFFFFF);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  if (msh != 0)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return __builtin_clz(msh);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  return 32 + __builtin_clz(lsh);
</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;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define __builtin_clzl __builtin_clzll
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* defined(_MSC_VER) && !defined(__clang__) */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* INT_LIB_H */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+diff --git libcxxabi-5.0.1.src/include/int_util.h libcxxabi-5.0.1.src/include/int_util.h
</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 0000000..a7b20ed
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ libcxxabi-5.0.1.src/include/int_util.h
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -0,0 +1,33 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* ===-- int_util.h - internal utility functions ----------------------------===
</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 dual licensed under the MIT and the University of Illinois Open
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * Source Licenses. 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;'>++ * This file is not part of the interface of this library.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ *
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * This file defines non-inline utilities which are available for use in the
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * library. The function definitions themselves are all contained in int_util.c
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * which will always be compiled into any compiler-rt library.
</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;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifndef INT_UTIL_H
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define INT_UTIL_H
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/** \brief Trigger a program abort (or panic for kernel code). */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define compilerrt_abort() compilerrt_abort_impl(__FILE__, __LINE__, __func__)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++NORETURN void compilerrt_abort_impl(const char *file, int line,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++                                    const char *function);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define COMPILE_TIME_ASSERT(expr) COMPILE_TIME_ASSERT1(expr, __COUNTER__)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define COMPILE_TIME_ASSERT1(expr, cnt) COMPILE_TIME_ASSERT2(expr, cnt)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define COMPILE_TIME_ASSERT2(expr, cnt)                                        \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef char ct_assert_##cnt[(expr) ? 1 : -1] UNUSED
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* INT_UTIL_H */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+diff --git libcxxabi-5.0.1.src/include/int_types.h libcxxabi-5.0.1.src/include/int_types.h
</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 0000000..f53f343
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ libcxxabi-5.0.1.src/include/int_types.h
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -0,0 +1,164 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* ===-- int_lib.h - configuration header for compiler-rt  -----------------===
</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 dual licensed under the MIT and the University of Illinois Open
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * Source Licenses. 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;'>++ * This file is not part of the interface of this library.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ *
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * This file defines various standard types, most importantly a number of unions
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * used to access parts of larger types.
</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;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifndef INT_TYPES_H
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define INT_TYPES_H
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include "int_endianness.h"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* si_int is defined in Linux sysroot's asm-generic/siginfo.h */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifdef si_int
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#undef si_int
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef      int si_int;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef unsigned su_int;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef          long long di_int;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef unsigned long long du_int;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef union
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    di_int all;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    struct
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if _YUGA_LITTLE_ENDIAN
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        su_int low;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        si_int high;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        si_int high;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        su_int low;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* _YUGA_LITTLE_ENDIAN */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    }s;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++} dwords;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef union
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    du_int all;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    struct
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if _YUGA_LITTLE_ENDIAN
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        su_int low;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        su_int high;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        su_int high;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        su_int low;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* _YUGA_LITTLE_ENDIAN */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    }s;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++} udwords;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if (defined(__LP64__) || defined(__wasm__) || defined(__mips64)) || defined(__riscv)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define CRT_HAS_128BIT
</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;'>++#ifdef CRT_HAS_128BIT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef int      ti_int __attribute__ ((mode (TI)));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef unsigned tu_int __attribute__ ((mode (TI)));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef union
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ti_int all;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    struct
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if _YUGA_LITTLE_ENDIAN
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        du_int low;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        di_int high;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        di_int high;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        du_int low;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* _YUGA_LITTLE_ENDIAN */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    }s;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++} twords;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef union
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    tu_int all;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    struct
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if _YUGA_LITTLE_ENDIAN
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        du_int low;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        du_int high;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        du_int high;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        du_int low;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* _YUGA_LITTLE_ENDIAN */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    }s;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++} utwords;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static __inline ti_int make_ti(di_int h, di_int l) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    twords r;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    r.s.high = h;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    r.s.low = l;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return r.all;
</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;'>++static __inline tu_int make_tu(du_int h, du_int l) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    utwords r;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    r.s.high = h;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    r.s.low = l;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    return r.all;
</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;'>++#endif /* CRT_HAS_128BIT */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef union
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    su_int u;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    float f;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++} float_bits;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef union
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    udwords u;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    double  f;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++} double_bits;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef struct
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if _YUGA_LITTLE_ENDIAN
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    udwords low;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    udwords high;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    udwords high;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    udwords low;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* _YUGA_LITTLE_ENDIAN */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++} uqwords;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef union
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++{
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    uqwords     u;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    long double f;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++} long_double_bits;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if __STDC_VERSION__ >= 199901L
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef float _Complex Fcomplex;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef double _Complex Dcomplex;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef long double _Complex Lcomplex;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define COMPLEX_REAL(x) __real__(x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define COMPLEX_IMAGINARY(x) __imag__(x)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef struct { float real, imaginary; } Fcomplex;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef struct { double real, imaginary; } Dcomplex;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef struct { long double real, imaginary; } Lcomplex;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define COMPLEX_REAL(x) (x).real
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define COMPLEX_IMAGINARY(x) (x).imaginary
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* INT_TYPES_H */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+diff --git libcxxabi-5.0.1.src/include/int_endianness.h libcxxabi-5.0.1.src/include/int_endianness.h
</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 0000000..e2586c5
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ libcxxabi-5.0.1.src/include/int_endianness.h
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -0,0 +1,116 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* ===-- int_endianness.h - configuration header for compiler-rt ------------===
</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 dual licensed under the MIT and the University of Illinois Open
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * Source Licenses. 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;'>++ * This file is a configuration header for compiler-rt.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * This file is not part of the interface of this library.
</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;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifndef INT_ENDIANNESS_H
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define INT_ENDIANNESS_H
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    defined(__ORDER_LITTLE_ENDIAN__)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++/* Clang and GCC provide built-in endianness definitions. */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_LITTLE_ENDIAN 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_BIG_ENDIAN    1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_LITTLE_ENDIAN 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_BIG_ENDIAN    0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* __BYTE_ORDER__ */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else /* Compilers other than Clang or GCC. */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if defined(__SVR4) && defined(__sun)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <sys/byteorder.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if defined(_BIG_ENDIAN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_LITTLE_ENDIAN 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_BIG_ENDIAN    1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#elif defined(_LITTLE_ENDIAN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_LITTLE_ENDIAN 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_BIG_ENDIAN    0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else /* !_LITTLE_ENDIAN */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#error "unknown endianness"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* !_LITTLE_ENDIAN */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* Solaris and AuroraUX. */
</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;'>++#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) ||   \
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    defined(__minix)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <sys/endian.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if _BYTE_ORDER == _BIG_ENDIAN
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_LITTLE_ENDIAN 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_BIG_ENDIAN    1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#elif _BYTE_ORDER == _LITTLE_ENDIAN
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_LITTLE_ENDIAN 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_BIG_ENDIAN    0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* _BYTE_ORDER */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* *BSD */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if defined(__OpenBSD__)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <machine/endian.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if _BYTE_ORDER == _BIG_ENDIAN
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_LITTLE_ENDIAN 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_BIG_ENDIAN    1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#elif _BYTE_ORDER == _LITTLE_ENDIAN
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_LITTLE_ENDIAN 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_BIG_ENDIAN    0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* _BYTE_ORDER */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* OpenBSD */
</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;'>++/* Mac OSX has __BIG_ENDIAN__ or __LITTLE_ENDIAN__ automatically set by the
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++ * compiler (at least with GCC) */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if defined(__APPLE__) || defined(__ellcc__ )
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifdef __BIG_ENDIAN__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if __BIG_ENDIAN__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_LITTLE_ENDIAN 0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_BIG_ENDIAN    1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* __BIG_ENDIAN__ */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#ifdef __LITTLE_ENDIAN__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if __LITTLE_ENDIAN__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_LITTLE_ENDIAN 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_BIG_ENDIAN    0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* __LITTLE_ENDIAN__ */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* Mac OSX */
</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;'>++#if defined(_WIN32)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_LITTLE_ENDIAN 1
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define _YUGA_BIG_ENDIAN    0
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* Windows */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* Clang or GCC. */
</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;'>++#if !defined(_YUGA_LITTLE_ENDIAN) || !defined(_YUGA_BIG_ENDIAN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#error Unable to determine endian
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* Check we found an endianness correctly. */
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif /* INT_ENDIANNESS_H */
</span><span style='display:block; white-space:pre;color:#808080;'>diff --git a/lang/libcxx/files/0006-libcxxabi-buildit-build-emutls.patch b/lang/libcxx/files/0006-libcxxabi-buildit-build-emutls.patch
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 0000000..4117abb
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/lang/libcxx/files/0006-libcxxabi-buildit-build-emutls.patch
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,14 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+diff --git libcxxabi-5.0.1.src/lib/buildit.orig libcxxabi-5.0.1.src/lib/buildit
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+index 3690482..a1c3f4e 100755
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- libcxxabi-5.0.1.src/lib/buildit.orig
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ libcxxabi-5.0.1.src/lib/buildit
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -85,6 +85,9 @@ set -x
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ for FILE in ../src/*.cpp; do
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   $CXX -c -g -O3 $RC_CFLAGS $EXTRA_FLAGS -I../include $OPTIONS $FILE
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ done
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++for FILE in ../src/*.c; do
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  $CC -c -g -Os $RC_CFLAGS -I../include $FILE
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++done
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ case $TRIPLE in
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   *-*-mingw*)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for FILE in ../src/support/win32/*.cpp; do
</span><span style='display:block; white-space:pre;color:#808080;'>diff --git a/lang/libcxx/files/0007-libcxxabi-include-expose-cxa-thread-atexit.patch b/lang/libcxx/files/0007-libcxxabi-include-expose-cxa-thread-atexit.patch
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 0000000..eb05e42
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/lang/libcxx/files/0007-libcxxabi-include-expose-cxa-thread-atexit.patch
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,19 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+diff --git libcxxabi-5.0.1.src/include/cxxabi.h libcxxabi-5.0.1.src/include/cxxabi.h
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+index 2596560..8092e73 100644
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- libcxxabi-5.0.1.src/include/cxxabi.h
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ libcxxabi-5.0.1.src/include/cxxabi.h
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -160,12 +160,12 @@ __cxa_decrement_exception_refcount(void *primary_exception) throw();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ extern _LIBCXXABI_FUNC_VIS bool __cxa_uncaught_exception() throw();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ extern _LIBCXXABI_FUNC_VIS unsigned int __cxa_uncaught_exceptions() throw();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#ifdef __linux__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++//#ifdef __linux__
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Linux TLS support. Not yet an official part of the Itanium ABI.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // https://sourceware.org/glibc/wiki/Destructor%20support%20for%20thread_local%20variables
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ extern _LIBCXXABI_FUNC_VIS int __cxa_thread_atexit(void (*)(void *), void *,
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                                                    void *) throw();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#endif
</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;'>+ } // extern "C"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ } // namespace __cxxabiv1
</span></pre><pre style='margin:0'>

</pre>