Author: theraven
Date: Sat Nov 26 18:46:33 2011
New Revision: 228004
URL: http://svn.freebsd.org/changeset/base/228004
Log:
Update libcxxrt to remove the pthread dependency.
Also add the license from upstream to contrib.
Approved by: dim (mentor)
Added:
head/contrib/libcxxrt/LICENSE
- copied unchanged from r227996, vendor/libcxxrt/dist/LICENSE
Modified:
head/contrib/libcxxrt/exception.cc
head/contrib/libcxxrt/memory.cc
head/lib/libcxxrt/Makefile
Directory Properties:
head/contrib/libcxxrt/ (props changed)
Copied: head/contrib/libcxxrt/LICENSE (from r227996,
vendor/libcxxrt/dist/LICENSE)
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/contrib/libcxxrt/LICENSE Sat Nov 26 18:46:33 2011
(r228004, copy of r227996, vendor/libcxxrt/dist/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.
Modified: head/contrib/libcxxrt/exception.cc
==============================================================================
--- head/contrib/libcxxrt/exception.cc Sat Nov 26 18:02:39 2011
(r228003)
+++ head/contrib/libcxxrt/exception.cc Sat Nov 26 18:46:33 2011
(r228004)
@@ -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_
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 siz
// 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 siz
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 siz
// 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 *
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)
Modified: head/contrib/libcxxrt/memory.cc
==============================================================================
--- head/contrib/libcxxrt/memory.cc Sat Nov 26 18:02:39 2011
(r228003)
+++ head/contrib/libcxxrt/memory.cc Sat Nov 26 18:46:33 2011
(r228004)
@@ -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);
}
Modified: head/lib/libcxxrt/Makefile
==============================================================================
--- head/lib/libcxxrt/Makefile Sat Nov 26 18:02:39 2011 (r228003)
+++ head/lib/libcxxrt/Makefile Sat Nov 26 18:46:33 2011 (r228004)
@@ -21,6 +21,5 @@ SRCS+= libelftc_dem_gnu3.c\
WARNS= 0
CFLAGS+= -I${SRCDIR}
-LDADD+= -pthread
.include <bsd.lib.mk>
_______________________________________________
svn-src-head@freebsd.org mailing list
http://lists.freebsd.org/mailman/listinfo/svn-src-head
To unsubscribe, send any mail to "svn-src-head-unsubscr...@freebsd.org"
