vendor/libcxxrt/8931d9e5180830a5433d16ae6b3ad8dd9e629512

3 files changed, 89 insertions, 9 deletions

diff --git a/LICENSE b/LICENSE
new file mode 100644
index 000000000000..cda1ea2f7b74
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,14 @@
+The BSD License
+
+Copyright 2010-2011 PathScale, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those of the authors and should not be interpreted as representing official policies, either expressed or implied, of PathScale, Inc.
diff --git a/exception.cc b/exception.cc
index abf6a10b3b48..2da7454910a8 100644
--- a/exception.cc
+++ b/exception.cc
@@ -8,6 +8,17 @@
 #include "dwarf_eh.h"
 #include "cxxabi.h"
 
+#pragma weak pthread_key_create
+#pragma weak pthread_setspecific
+#pragma weak pthread_getspecific
+#pragma weak pthread_once
+#pragma weak pthread_once
+#pragma weak pthread_cond_signal
+#pragma weak pthread_cond_wait
+#pragma weak pthread_mutex_lock
+#pragma weak pthread_mutex_unlock
+
+
 using namespace ABI_NAMESPACE;
 
 /**
@@ -289,11 +300,31 @@ static void thread_cleanup(void* thread_info)
 static pthread_once_t once_control = PTHREAD_ONCE_INIT;
 
 /**
+ * We may not be linked against a full pthread implementation.  If we're not,
+ * then we need to fake the thread-local storage by storing 'thread-local'
+ * things in a global.
+ */
+static bool fakeTLS;
+/**
+ * Thread-local storage for a single-threaded program.
+ */
+static __cxa_thread_info singleThreadInfo;
+/**
  * Initialise eh_key.
  */
 static void init_key(void)
 {
+	if ((0 == pthread_key_create) ||
+	    (0 == pthread_setspecific) ||
+	    (0 == pthread_getspecific))
+	{
+		fakeTLS = true;
+		return;
+	}
 	pthread_key_create(&eh_key, thread_cleanup);
+	pthread_setspecific(eh_key, (void*)0x42);
+	fakeTLS = (pthread_getspecific(eh_key) != (void*)0x42);
+	pthread_setspecific(eh_key, 0);
 }
 
 /**
@@ -301,7 +332,11 @@ static void init_key(void)
  */
 static __cxa_thread_info *thread_info()
 {
-	pthread_once(&once_control, init_key);
+	if ((0 == pthread_once) || pthread_once(&once_control, init_key))
+	{
+		fakeTLS = true;
+	}
+	if (fakeTLS) { return &singleThreadInfo; }
 	__cxa_thread_info *info = (__cxa_thread_info*)pthread_getspecific(eh_key);
 	if (0 == info)
 	{
@@ -316,6 +351,7 @@ static __cxa_thread_info *thread_info()
  */
 static __cxa_thread_info *thread_info_fast()
 {
+	if (fakeTLS) { return &singleThreadInfo; }
 	return (__cxa_thread_info*)pthread_getspecific(eh_key);
 }
 /**
@@ -367,7 +403,10 @@ static char *emergency_malloc(size_t size)
 	// Only 4 emergency buffers allowed per thread!
 	if (info->emergencyBuffersHeld > 3) { return 0; }
 
-	pthread_mutex_lock(&emergency_malloc_lock);
+	if (pthread_mutex_lock)
+	{
+		pthread_mutex_lock(&emergency_malloc_lock);
+	}
 	int buffer = -1;
 	while (buffer < 0)
 	{
@@ -378,7 +417,10 @@ static char *emergency_malloc(size_t size)
 		void *m = calloc(1, size);
 		if (0 != m)
 		{
-			pthread_mutex_unlock(&emergency_malloc_lock);
+			if (pthread_mutex_unlock)
+			{
+				pthread_mutex_unlock(&emergency_malloc_lock);
+			}
 			return (char*)m;
 		}
 		for (int i=0 ; i<16 ; i++)
@@ -395,10 +437,24 @@ static char *emergency_malloc(size_t size)
 		// of the emergency buffers.
 		if (buffer < 0)
 		{
+			// If we don't have pthread_cond_wait, then there is only one
+			// thread and it's already used all of the emergency buffers, so we
+			// have no alternative but to die.  Calling abort() instead of
+			// terminate, because terminate can throw exceptions, which can
+			// bring us back here and infinite loop.
+			if (!pthread_cond_wait)
+			{
+				fputs("Terminating while out of memory trying to throw an exception",
+				      stderr);
+				abort();
+			}
 			pthread_cond_wait(&emergency_malloc_wait, &emergency_malloc_lock);
 		}
 	}
-	pthread_mutex_unlock(&emergency_malloc_lock);
+	if (pthread_mutex_unlock)
+	{
+		pthread_mutex_unlock(&emergency_malloc_lock);
+	}
 	info->emergencyBuffersHeld++;
 	return emergency_buffer + (1024 * buffer);
 }
@@ -431,13 +487,19 @@ static void emergency_malloc_free(char *ptr)
 	memset((void*)ptr, 0, 1024);
 	// Signal the condition variable to wake up any threads that are blocking
 	// waiting for some space in the emergency buffer
-	pthread_mutex_lock(&emergency_malloc_lock);
+	if (pthread_mutex_lock)
+	{
+		pthread_mutex_lock(&emergency_malloc_lock);
+	}
 	// In theory, we don't need to do this with the lock held.  In practice,
 	// our array of bools will probably be updated using 32-bit or 64-bit
 	// memory operations, so this update may clobber adjacent values.
 	buffer_allocated[buffer] = false;
-	pthread_cond_signal(&emergency_malloc_wait);
-	pthread_mutex_unlock(&emergency_malloc_lock);
+	if (pthread_cond_signal && pthread_mutex_unlock)
+	{
+		pthread_cond_signal(&emergency_malloc_wait);
+		pthread_mutex_unlock(&emergency_malloc_lock);
+	}
 }
 
 static char *alloc_or_die(size_t size)
diff --git a/memory.cc b/memory.cc
index 655c76107a13..027bc3fef7fa 100644
--- a/memory.cc
+++ b/memory.cc
@@ -11,6 +11,10 @@
 #include <stdlib.h>
 #include "stdexcept.h"
 
+#if !__has_builtin(__sync_swap)
+#define __sync_swap __sync_lock_test_and_set
+#endif
+
 namespace std
 {
 	struct nothrow_t {};
@@ -33,7 +37,7 @@ namespace std
 	__attribute__((weak))
 	new_handler set_new_handler(new_handler handler)
 	{
-		return __sync_lock_test_and_set(&new_handl, handler);
+		return __sync_swap(&new_handl, handler);
 	}
 }
 
@@ -103,7 +107,7 @@ void * operator new[](size_t size)
 
 
 __attribute__((weak))
-void operator delete[](void * ptr)
+void operator delete[](void * ptr) throw()
 {
 	::operator delete(ptr);
 }