webruby 0.2.7 → 0.9.1

data/modules/emscripten/system/lib/libcxxabi/src/cxa_exception.hpp

@@ -1,123 +0,0 @@
-//===------------------------- cxa_exception.hpp --------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//  
-//  This file implements the "Exception Handling APIs"
-//  http://www.codesourcery.com/public/cxx-abi/abi-eh.html
-//  
-//===----------------------------------------------------------------------===//
-
-#ifndef _CXA_EXCEPTION_H
-#define _CXA_EXCEPTION_H
-
-#include <exception> // for std::unexpected_handler and std::terminate_handler
-#include <cxxabi.h>
-#include "unwind.h"
-
-namespace __cxxabiv1 {
-
-#pragma GCC visibility push(hidden)
-
-static const uint64_t kOurExceptionClass          = 0x434C4E47432B2B00; // CLNGC++\0
-static const uint64_t kOurDependentExceptionClass = 0x434C4E47432B2B01; // CLNGC++\1
-static const uint64_t get_vendor_and_language =     0xFFFFFFFFFFFFFF00; // mask for CLNGC++
-                                                    
-    struct __cxa_exception { 
-#if __LP64__
-    // This is a new field to support C++ 0x exception_ptr.
-    // For binary compatibility it is at the start of this
-    // struct which is prepended to the object thrown in
-    // __cxa_allocate_exception.
-        size_t referenceCount;
-#endif
-    
-    //  Manage the exception object itself.
-        std::type_info *exceptionType;
-        void (*exceptionDestructor)(void *); 
-        std::unexpected_handler unexpectedHandler;
-        std::terminate_handler  terminateHandler;
-        
-         __cxa_exception *nextException;
-        
-         int handlerCount;
-    
-#ifdef __ARM_EABI_UNWINDER__
-         __cxa_exception* nextPropagatingException;
-         int propagationCount;
-#else
-         int handlerSwitchValue;
-         const unsigned char *actionRecord;
-         const unsigned char *languageSpecificData;
-         void *catchTemp;
-         void *adjustedPtr;
-#endif
-
-#if !__LP64__
-    // This is a new field to support C++ 0x exception_ptr.
-    // For binary compatibility it is placed where the compiler
-    // previously adding padded to 64-bit align unwindHeader.
-        size_t referenceCount;
-#endif
-    
-        _Unwind_Exception unwindHeader;
-        };
-
-// http://sourcery.mentor.com/archives/cxx-abi-dev/msg01924.html
-    
-    struct __cxa_dependent_exception {
-#if __LP64__
-        void* primaryException;
-#endif
-    
-        std::type_info *exceptionType;
-        void (*exceptionDestructor)(void *); 
-        std::unexpected_handler unexpectedHandler;
-        std::terminate_handler terminateHandler;
-    
-        __cxa_exception *nextException;
-    
-        int handlerCount;
-    
-#ifdef __ARM_EABI_UNWINDER__
-        __cxa_exception* nextPropagatingException;
-        int propagationCount;
-#else
-        int handlerSwitchValue;
-        const unsigned char *actionRecord;
-        const unsigned char *languageSpecificData;
-        void * catchTemp;
-        void *adjustedPtr;
-#endif
-    
-#if !__LP64__
-        void* primaryException;
-#endif
-    
-        _Unwind_Exception unwindHeader;
-        };
-        
-    struct __cxa_eh_globals {
-        __cxa_exception *   caughtExceptions;
-        unsigned int        uncaughtExceptions;
-#ifdef __ARM_EABI_UNWINDER__
-        __cxa_exception* propagatingExceptions;
-#endif
-    };
-
-#pragma GCC visibility pop
-#pragma GCC visibility push(default)
-
-    extern "C" __cxa_eh_globals * __cxa_get_globals      ();
-    extern "C" __cxa_eh_globals * __cxa_get_globals_fast ();
-
-    extern "C" void * __cxa_allocate_dependent_exception ();
-    extern "C" void __cxa_free_dependent_exception (void * dependent_exception);
-
-#pragma GCC visibility pop
-}
-
-#endif  // _CXA_EXCEPTION_H

data/modules/emscripten/system/lib/libcxxabi/src/cxa_exception_storage.cpp

@@ -1,91 +0,0 @@
-//===--------------------- cxa_exception_storage.cpp ----------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//  
-//  This file implements the storage for the "Caught Exception Stack"
-//  http://www.codesourcery.com/public/cxx-abi/abi-eh.html (section 2.2.2)
-//  
-//===----------------------------------------------------------------------===//
-
-#include "cxa_exception.hpp"
-
-#ifdef HAS_THREAD_LOCAL
-
-namespace __cxxabiv1 {
-
-namespace {
-    __cxa_eh_globals * __globals () {
-        static thread_local __cxa_eh_globals eh_globals;
-        return &eh_globals;
-        }
-    }
-
-extern "C" {
-    __cxa_eh_globals * __cxa_get_globals      () { return __globals (); }
-    __cxa_eh_globals * __cxa_get_globals_fast () { return __globals (); }
-    }
-}
-
-#else
-
-#include <pthread.h>
-#include <cstdlib>          // for calloc, free
-#include "abort_message.h"
-
-//  In general, we treat all pthread errors as fatal.
-//  We cannot call std::terminate() because that will in turn
-//  call __cxa_get_globals() and cause infinite recursion.
-
-namespace __cxxabiv1 {
-namespace {
-    pthread_key_t  key_;
-    pthread_once_t flag_ = PTHREAD_ONCE_INIT;
-
-    void destruct_ (void *p) {
-        std::free ( p );
-        if ( 0 != ::pthread_setspecific ( key_, NULL ) ) 
-            abort_message("cannot zero out thread value for __cxa_get_globals()");
-        }
-
-    void construct_ () {
-        if ( 0 != pthread_key_create ( &key_, destruct_ ) )
-            abort_message("cannot create pthread key for __cxa_get_globals()");
-        }
-}   
-
-extern "C" {
-    __cxa_eh_globals * __cxa_get_globals () {
-    //  Try to get the globals for this thread
-        __cxa_eh_globals* retVal = __cxa_get_globals_fast ();
-    
-    //  If this is the first time we've been asked for these globals, create them
-        if ( NULL == retVal ) {
-            retVal = static_cast<__cxa_eh_globals*>
-                        (std::calloc (1, sizeof (__cxa_eh_globals)));
-            if ( NULL == retVal )
-                abort_message("cannot allocate __cxa_eh_globals");
-            if ( 0 != pthread_setspecific ( key_, retVal ) )
-               abort_message("pthread_setspecific failure in __cxa_get_globals()");
-           }
-        return retVal;
-        }
-
-    // Note that this implementation will reliably return NULL if not
-    // preceded by a call to __cxa_get_globals().  This is an extension
-    // to the Itanium ABI and is taken advantage of in several places in
-    // libc++abi.
-    __cxa_eh_globals * __cxa_get_globals_fast () {
-    //  First time through, create the key.
-        if (0 != pthread_once(&flag_, construct_))
-            abort_message("pthread_once failure in __cxa_get_globals_fast()");
-//        static int init = construct_();
-        return static_cast<__cxa_eh_globals*>(::pthread_getspecific(key_));
-        }
-    
-}
-}
-#endif

data/modules/emscripten/system/lib/libcxxabi/src/cxa_guard.cpp

@@ -1,231 +0,0 @@
-//===---------------------------- cxa_guard.cpp ---------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "abort_message.h"
-
-#include <pthread.h>
-#include <stdint.h>
-
-/*
-    This implementation must be careful to not call code external to this file
-    which will turn around and try to call __cxa_guard_acquire reentrantly.
-    For this reason, the headers of this file are as restricted as possible.
-    Previous implementations of this code for __APPLE__ have used
-    pthread_mutex_lock and the abort_message utility without problem.  This
-    implementation also uses pthread_cond_wait which has tested to not be a
-    problem.
-*/
-
-namespace __cxxabiv1
-{
-
-namespace
-{
-
-#if __arm__
-
-// A 32-bit, 4-byte-aligned static data value. The least significant 2 bits must
-// be statically initialized to 0.
-typedef uint32_t guard_type;
-
-// Test the lowest bit.
-inline bool is_initialized(guard_type* guard_object) {
-    return (*guard_object) & 1;
-}
-
-inline void set_initialized(guard_type* guard_object) {
-    *guard_object |= 1;
-}
-
-#else
-
-typedef uint64_t guard_type;
-
-bool is_initialized(guard_type* guard_object) {
-    char* initialized = (char*)guard_object;
-    return *initialized;
-}
-
-void set_initialized(guard_type* guard_object) {
-    char* initialized = (char*)guard_object;
-    *initialized = 1;
-}
-
-#endif
-
-pthread_mutex_t guard_mut = PTHREAD_MUTEX_INITIALIZER;
-pthread_cond_t  guard_cv  = PTHREAD_COND_INITIALIZER;
-
-#if defined(__APPLE__) && !defined(__arm__)
-
-typedef uint32_t lock_type;
-
-#if __LITTLE_ENDIAN__
-
-inline
-lock_type
-get_lock(uint64_t x)
-{
-    return static_cast<lock_type>(x >> 32);
-}
-
-inline
-void
-set_lock(uint64_t& x, lock_type y)
-{
-    x = static_cast<uint64_t>(y) << 32;
-}
-
-#else  // __LITTLE_ENDIAN__
-
-inline
-lock_type
-get_lock(uint64_t x)
-{
-    return static_cast<lock_type>(x);
-}
-
-inline
-void
-set_lock(uint64_t& x, lock_type y)
-{
-    x = y;
-}
-
-#endif  // __LITTLE_ENDIAN__
-
-#else  // !__APPLE__ || __arm__
-
-typedef bool lock_type;
-
-inline
-lock_type
-get_lock(uint64_t x)
-{
-    union
-    {
-        uint64_t guard;
-        uint8_t lock[2];
-    } f = {x};
-    return f.lock[1] != 0;
-}
-
-inline
-void
-set_lock(uint64_t& x, lock_type y)
-{
-    union
-    {
-        uint64_t guard;
-        uint8_t lock[2];
-    } f = {0};
-    f.lock[1] = y;
-    x = f.guard;
-}
-
-inline
-lock_type
-get_lock(uint32_t x)
-{
-    union
-    {
-        uint32_t guard;
-        uint8_t lock[2];
-    } f = {x};
-    return f.lock[1] != 0;
-}
-
-inline
-void
-set_lock(uint32_t& x, lock_type y)
-{
-    union
-    {
-        uint32_t guard;
-        uint8_t lock[2];
-    } f = {0};
-    f.lock[1] = y;
-    x = f.guard;
-}
-
-#endif  // __APPLE__
-
-}  // unnamed namespace
-
-extern "C"
-{
-
-int __cxa_guard_acquire(guard_type* guard_object)
-{
-    char* initialized = (char*)guard_object;
-    if (pthread_mutex_lock(&guard_mut))
-        abort_message("__cxa_guard_acquire failed to acquire mutex");
-    int result = *initialized == 0;
-    if (result)
-    {
-#if defined(__APPLE__) && !defined(__arm__)
-        const lock_type id = pthread_mach_thread_np(pthread_self());
-        lock_type lock = get_lock(*guard_object);
-        if (lock)
-        {
-            // if this thread set lock for this same guard_object, abort
-            if (lock == id)
-                abort_message("__cxa_guard_acquire detected deadlock");
-            do
-            {
-                if (pthread_cond_wait(&guard_cv, &guard_mut))
-                    abort_message("__cxa_guard_acquire condition variable wait failed");
-                lock = get_lock(*guard_object);
-            } while (lock);
-            result = !is_initialized(guard_object);
-            if (result)
-                set_lock(*guard_object, id);
-        }
-        else
-            set_lock(*guard_object, id);
-#else  // !__APPLE__ || __arm__
-        while (get_lock(*guard_object))
-            if (pthread_cond_wait(&guard_cv, &guard_mut))
-                abort_message("__cxa_guard_acquire condition variable wait failed");
-        result = *initialized == 0;
-        if (result)
-            set_lock(*guard_object, true);
-#endif  // !__APPLE__ || __arm__
-    }
-    if (pthread_mutex_unlock(&guard_mut))
-        abort_message("__cxa_guard_acquire failed to release mutex");
-    return result;
-}
-
-void __cxa_guard_release(guard_type* guard_object)
-{
-    if (pthread_mutex_lock(&guard_mut))
-        abort_message("__cxa_guard_release failed to acquire mutex");
-    *guard_object = 0;
-    set_initialized(guard_object);
-    if (pthread_mutex_unlock(&guard_mut))
-        abort_message("__cxa_guard_release failed to release mutex");
-    if (pthread_cond_broadcast(&guard_cv))
-        abort_message("__cxa_guard_release failed to broadcast condition variable");
-}
-
-void __cxa_guard_abort(guard_type* guard_object)
-{
-    if (pthread_mutex_lock(&guard_mut))
-        abort_message("__cxa_guard_abort failed to acquire mutex");
-    *guard_object = 0;
-    if (pthread_mutex_unlock(&guard_mut))
-        abort_message("__cxa_guard_abort failed to release mutex");
-    if (pthread_cond_broadcast(&guard_cv))
-        abort_message("__cxa_guard_abort failed to broadcast condition variable");
-}
-
-}  // extern "C"
-
-}  // __cxxabiv1

data/modules/emscripten/system/lib/libcxxabi/src/cxa_handlers.cpp

@@ -1,125 +0,0 @@
-//===------------------------- cxa_handlers.cpp ---------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//
-// This file implements the functionality associated with the terminate_handler,
-//   unexpected_handler, and new_handler.
-//===----------------------------------------------------------------------===//
-
-#include <stdexcept>
-#include <new>
-#include <exception>
-#include "abort_message.h"
-#include "cxxabi.h"
-#include "cxa_handlers.hpp"
-#include "cxa_exception.hpp"
-#include "private_typeinfo.h"
-
-namespace std
-{
-
-unexpected_handler
-get_unexpected() _NOEXCEPT
-{
-    return __sync_fetch_and_add(&__cxa_unexpected_handler, (unexpected_handler)0);
-//  The above is safe but overkill on x86
-//  Using of C++11 atomics this should be rewritten
-//  return __cxa_unexpected_handler.load(memory_order_acq);
-}
-
-__attribute__((visibility("hidden"), noreturn))
-void
-__unexpected(unexpected_handler func)
-{
-    func();
-    // unexpected handler should not return
-    abort_message("unexpected_handler unexpectedly returned");
-}
-
-__attribute__((noreturn))
-void
-unexpected()
-{
-    __unexpected(get_unexpected());
-}
-
-terminate_handler
-get_terminate() _NOEXCEPT
-{
-    return __sync_fetch_and_add(&__cxa_terminate_handler, (terminate_handler)0);
-//  The above is safe but overkill on x86
-//  Using of C++11 atomics this should be rewritten
-//  return __cxa_terminate_handler.load(memory_order_acq);
-}
-
-__attribute__((visibility("hidden"), noreturn))
-void
-__terminate(terminate_handler func) _NOEXCEPT
-{
-#if __has_feature(cxx_exceptions)
-    try
-    {
-#endif  // __has_feature(cxx_exceptions)
-        func();
-        // handler should not return
-        abort_message("terminate_handler unexpectedly returned");
-#if __has_feature(cxx_exceptions)
-    }
-    catch (...)
-    {
-        // handler should not throw exception
-        abort_message("terminate_handler unexpectedly threw an exception");
-    }
-#endif  // #if __has_feature(cxx_exceptions)
-}
-
-__attribute__((noreturn))
-void
-terminate() _NOEXCEPT
-{
-    // If there might be an uncaught exception
-    using namespace __cxxabiv1;
-    __cxa_eh_globals* globals = __cxa_get_globals_fast();
-    if (globals)
-    {
-        __cxa_exception* exception_header = globals->caughtExceptions;
-        if (exception_header)
-        {
-            _Unwind_Exception* unwind_exception =
-                reinterpret_cast<_Unwind_Exception*>(exception_header + 1) - 1;
-            bool native_exception =
-                (unwind_exception->exception_class & get_vendor_and_language) ==
-                               (kOurExceptionClass & get_vendor_and_language);
-            if (native_exception)
-                __terminate(exception_header->terminateHandler);
-        }
-    }
-    __terminate(get_terminate());
-}
-
-extern "C" new_handler __cxa_new_handler = 0;
-// In the future these will become:
-// std::atomic<std::new_handler>  __cxa_new_handler(0);
-
-new_handler
-set_new_handler(new_handler handler) _NOEXCEPT
-{
-    return __sync_swap(&__cxa_new_handler, handler);
-//  Using of C++11 atomics this should be rewritten
-//  return __cxa_new_handler.exchange(handler, memory_order_acq_rel);
-}
-
-new_handler
-get_new_handler() _NOEXCEPT
-{
-    return __sync_fetch_and_add(&__cxa_new_handler, (new_handler)0);
-//  The above is safe but overkill on x86
-//  Using of C++11 atomics this should be rewritten
-//  return __cxa_new_handler.load(memory_order_acq);
-}
-
-}  // std

data/modules/emscripten/system/lib/libcxxabi/src/cxa_handlers.hpp

@@ -1,54 +0,0 @@
-//===------------------------- cxa_handlers.cpp ---------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//
-// This file implements the functionality associated with the terminate_handler,
-//   unexpected_handler, and new_handler.
-//===----------------------------------------------------------------------===//
-
-#ifndef _CXA_HANDLERS_H
-#define _CXA_HANDLERS_H
-
-#include <exception>
-
-namespace std
-{
-
-__attribute__((visibility("hidden"), noreturn))
-void
-__unexpected(unexpected_handler func);
-
-__attribute__((visibility("hidden"), noreturn))
-void
-__terminate(terminate_handler func) _NOEXCEPT;
-
-}  // std
-
-extern "C"
-{
-
-extern void (*__cxa_terminate_handler)();
-extern void (*__cxa_unexpected_handler)();
-extern void (*__cxa_new_handler)();
-
-/*
-
-    At some point in the future these three symbols will become
-    C++11 atomic variables:
-
-    extern std::atomic<std::terminate_handler>  __cxa_terminate_handler;
-    extern std::atomic<std::unexpected_handler> __cxa_unexpected_handler;
-    extern std::atomic<std::new_handler>        __cxa_new_handler;
-
-    This change will not impact their ABI.  But it will allow for a
-    portable performance optimization.
-
-*/
-
-} // extern "C"
-
-#endif  // _CXA_HANDLERS_H