From b5eb86e24cd51054b40f131ad0bd5e9fa8ea1023 Mon Sep 17 00:00:00 2001 From: Daniel Larimer Date: Thu, 8 Aug 2013 09:49:37 -0400 Subject: [PATCH 1/6] fix broken header reference --- include/fc/ptr.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/fc/ptr.hpp b/include/fc/ptr.hpp index b52da28..afbf8a4 100644 --- a/include/fc/ptr.hpp +++ b/include/fc/ptr.hpp @@ -1,5 +1,5 @@ #pragma once -#include +#include #include #include #include From bd66f1c5affd5f153cb546e4d5de4cd74e8a41fd Mon Sep 17 00:00:00 2001 From: Daniel Larimer Date: Thu, 8 Aug 2013 09:49:49 -0400 Subject: [PATCH 2/6] added time_point_sec(int32) constructor --- include/fc/time.hpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/include/fc/time.hpp b/include/fc/time.hpp index ffb6a9d..6df8e8d 100644 --- a/include/fc/time.hpp +++ b/include/fc/time.hpp @@ -60,6 +60,9 @@ namespace fc { time_point_sec() :utc_seconds(0){} + explicit time_point_sec(uint32_t seconds ) + :utc_seconds(seconds){} + time_point_sec( const time_point& t ) :utc_seconds( t.time_since_epoch().count() / 1000000ll ){} From a69abee4c493411904cc3179291798902c02680c Mon Sep 17 00:00:00 2001 From: Daniel Larimer Date: Thu, 8 Aug 2013 10:20:38 -0400 Subject: [PATCH 3/6] adding new test code --- tests/ecc_test.cpp | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 tests/ecc_test.cpp diff --git a/tests/ecc_test.cpp b/tests/ecc_test.cpp new file mode 100644 index 0000000..982e94b --- /dev/null +++ b/tests/ecc_test.cpp @@ -0,0 +1,23 @@ +#include +#include +#include + +int main( int argc, char** argv ) +{ + std::string pass(argv[1]); + fc::sha256 h = fc::sha256::hash( pass.c_str(), pass.size() ); + fc::ecc::private_key priv = fc::ecc::private_key::generate_from_seed(h); + fc::ecc::public_key pub = priv.get_public_key(); + std::cerr<<"oroginal master pubkey1: "< Date: Thu, 8 Aug 2013 15:12:01 -0400 Subject: [PATCH 4/6] clean up tcp_server accept api, removing unused return value --- include/fc/network/tcp_socket.hpp | 2 +- src/network/http/http_server.cpp | 7 ++++--- src/network/tcp_socket.cpp | 20 ++++++-------------- 3 files changed, 11 insertions(+), 18 deletions(-) diff --git a/include/fc/network/tcp_socket.hpp b/include/fc/network/tcp_socket.hpp index 18fa7af..05adb2d 100644 --- a/include/fc/network/tcp_socket.hpp +++ b/include/fc/network/tcp_socket.hpp @@ -44,7 +44,7 @@ namespace fc { ~tcp_server(); void close(); - bool accept( tcp_socket& s ); + void accept( tcp_socket& s ); void listen( uint16_t port ); private: diff --git a/src/network/http/http_server.cpp b/src/network/http/http_server.cpp index e658a78..1f7578d 100644 --- a/src/network/http/http_server.cpp +++ b/src/network/http/http_server.cpp @@ -58,11 +58,12 @@ namespace fc { namespace http { }catch(...){} } void accept_loop() { - http::connection_ptr con = std::make_shared(); - while( tcp_serv.accept( con->get_socket() ) ) { + while( !accept_complete.canceled() ) + { + http::connection_ptr con = std::make_shared(); + tcp_serv.accept( con->get_socket() ); ilog( "Accept Connection" ); fc::async( [=](){ handle_connection( con, on_req ); } ); - con = std::make_shared(); } } diff --git a/src/network/tcp_socket.cpp b/src/network/tcp_socket.cpp index 9c60c4f..89842b5 100644 --- a/src/network/tcp_socket.cpp +++ b/src/network/tcp_socket.cpp @@ -86,25 +86,17 @@ namespace fc { } - bool tcp_server::accept( tcp_socket& s ) { + void tcp_server::accept( tcp_socket& s ) + { try { - if( !my ) return false; - + FC_ASSERT( my != nullptr ); fc::asio::tcp::accept( my->_accept, s.my->_sock ); - /* - fc::promise::ptr p( new promise("tcp::accept") ); - my->_accept.async_accept( s.my->_sock, [=]( const boost::system::error_code& e ) { - p->set_value(e); - } ); - auto ec = p->wait(); - if( ec ) FC_THROW_EXCEPTION( exception, "system error: ${message}", ("message", fc::string(boost::system::system_error(ec).what()) )); - return true; - */ - return true; } FC_RETHROW_EXCEPTIONS( warn, "Unable to accept connection on socket." ); } - void tcp_server::listen( uint16_t port ) { + + void tcp_server::listen( uint16_t port ) + { if( my ) delete my; my = new impl(port); } From 7b8494d7f8ee886c14b70f3b02080f537b0a3f4a Mon Sep 17 00:00:00 2001 From: Daniel Larimer Date: Thu, 8 Aug 2013 21:31:35 -0400 Subject: [PATCH 5/6] upgrading to a version of boost that includes boost::atomic and boost::context --- CMakeLists.txt | 88 +-- src/thread/context.hpp | 32 +- vendor/boost_1.51/include/boost/atomic.hpp | 217 ------- .../include/boost/atomic/detail/base.hpp | 186 ------ .../include/boost/atomic/detail/builder.hpp | 412 ------------- .../include/boost/atomic/detail/fallback.hpp | 76 --- .../include/boost/atomic/detail/gcc-alpha.hpp | 354 ------------ .../boost/atomic/detail/gcc-armv6+.hpp | 299 ---------- .../include/boost/atomic/detail/gcc-ppc.hpp | 351 ----------- .../include/boost/atomic/detail/gcc-x86.hpp | 546 ------------------ .../boost/atomic/detail/generic-cas.hpp | 192 ------ .../boost/atomic/detail/integral-casts.hpp | 465 --------------- .../boost/atomic/detail/interlocked.hpp | 365 ------------ .../include/boost/atomic/detail/linux-arm.hpp | 171 ------ .../atomic/detail/valid_integral_types.hpp | 45 -- .../include/boost/atomic/platform.hpp | 42 -- .../boost_1.51/include/boost/context/all.hpp | 14 - .../include/boost/context/detail/config.hpp | 42 -- .../boost/context/detail/fcontext_arm.hpp | 66 --- .../boost/context/detail/fcontext_i386.hpp | 68 --- .../context/detail/fcontext_i386_win.hpp | 83 --- .../boost/context/detail/fcontext_mips.hpp | 68 --- .../boost/context/detail/fcontext_ppc.hpp | 70 --- .../boost/context/detail/fcontext_x86_64.hpp | 66 --- .../context/detail/fcontext_x86_64_win.hpp | 90 --- .../include/boost/context/fcontext.hpp | 82 --- .../include/boost/context/stack_allocator.hpp | 37 -- .../include/boost/context/stack_utils.hpp | 41 -- 28 files changed, 31 insertions(+), 4537 deletions(-) delete mode 100644 vendor/boost_1.51/include/boost/atomic.hpp delete mode 100644 vendor/boost_1.51/include/boost/atomic/detail/base.hpp delete mode 100644 vendor/boost_1.51/include/boost/atomic/detail/builder.hpp delete mode 100644 vendor/boost_1.51/include/boost/atomic/detail/fallback.hpp delete mode 100644 vendor/boost_1.51/include/boost/atomic/detail/gcc-alpha.hpp delete mode 100644 vendor/boost_1.51/include/boost/atomic/detail/gcc-armv6+.hpp delete mode 100644 vendor/boost_1.51/include/boost/atomic/detail/gcc-ppc.hpp delete mode 100644 vendor/boost_1.51/include/boost/atomic/detail/gcc-x86.hpp delete mode 100644 vendor/boost_1.51/include/boost/atomic/detail/generic-cas.hpp delete mode 100644 vendor/boost_1.51/include/boost/atomic/detail/integral-casts.hpp delete mode 100644 vendor/boost_1.51/include/boost/atomic/detail/interlocked.hpp delete mode 100644 vendor/boost_1.51/include/boost/atomic/detail/linux-arm.hpp delete mode 100644 vendor/boost_1.51/include/boost/atomic/detail/valid_integral_types.hpp delete mode 100644 vendor/boost_1.51/include/boost/atomic/platform.hpp delete mode 100644 vendor/boost_1.51/include/boost/context/all.hpp delete mode 100644 vendor/boost_1.51/include/boost/context/detail/config.hpp delete mode 100644 vendor/boost_1.51/include/boost/context/detail/fcontext_arm.hpp delete mode 100644 vendor/boost_1.51/include/boost/context/detail/fcontext_i386.hpp delete mode 100644 vendor/boost_1.51/include/boost/context/detail/fcontext_i386_win.hpp delete mode 100644 vendor/boost_1.51/include/boost/context/detail/fcontext_mips.hpp delete mode 100644 vendor/boost_1.51/include/boost/context/detail/fcontext_ppc.hpp delete mode 100644 vendor/boost_1.51/include/boost/context/detail/fcontext_x86_64.hpp delete mode 100644 vendor/boost_1.51/include/boost/context/detail/fcontext_x86_64_win.hpp delete mode 100644 vendor/boost_1.51/include/boost/context/fcontext.hpp delete mode 100644 vendor/boost_1.51/include/boost/context/stack_allocator.hpp delete mode 100644 vendor/boost_1.51/include/boost/context/stack_utils.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 37ce083..91c825c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -18,7 +18,7 @@ SET( DEFAULT_EXECUTABLE_INSTALL_DIR bin/ ) SET( CMAKE_DEBUG_POSTFIX _debug ) SET( BUILD_SHARED_LIBS NO ) SET(Boost_USE_STATIC_LIBS ON) -FIND_PACKAGE(Boost 1.51 COMPONENTS thread date_time system filesystem program_options signals serialization chrono unit_test_framework context ) +FIND_PACKAGE(Boost 1.53 REQUIRED COMPONENTS thread date_time system filesystem program_options signals serialization chrono unit_test_framework context coroutine) if( WIN32 ) set( RPCRT4 Rpcrt4 ) @@ -27,17 +27,13 @@ endif( WIN32 ) LINK_DIRECTORIES( ${Boost_LIBRARY_DIRS} ) IF( WIN32 ) - ADD_DEFINITIONS( -DWIN32 ) - ADD_DEFINITIONS( -DBOOST_CONTEXT_NO_LIB ) ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS ) ADD_DEFINITIONS( -D_WIN32_WINNT=0x0501 ) ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS ) - ADD_DEFINITIONS( -DBOOST_ALL_NO_LIB -DBOOST_THREAD_BUILD_LIB) - ADD_DEFINITIONS( -DWIN32) - # Activate C++ exception handling - IF (NOT CMAKE_CXX_FLAGS MATCHES "/EHsc") - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc") - ENDIF() +# Activate C++ exception handling +# IF (NOT CMAKE_CXX_FLAGS MATCHES "/EHsc") +# SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc") +# ENDIF() ELSE(WIN32) SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x -Wall -Wno-unused-local-typedefs -fmax-errors=3" ) ENDIF(WIN32) @@ -115,84 +111,10 @@ set( fc_sources src/network/url.cpp vendor/cyoencode-1.0.2/src/CyoDecode.c vendor/cyoencode-1.0.2/src/CyoEncode.c -# src/ssh/client.cpp -# src/ssh/process.cpp ) -IF( UNIX ) - IF( ENABLE_ARM ) - SET_PROPERTY( SOURCE - vendor/boost_1.51/libs/context/asm/fcontext_arm_aapcs_elf_gas.S - PROPERTY LANGUAGE C) - SET( boost_context_sources vendor/boost_1.51/libs/context/protected_stack_posix.cpp - vendor/boost_1.51/libs/context/stack_helper_posix.cpp - vendor/boost_1.51/libs/context/asm/fcontext_arm_aapcs_elf_gas.S - ) - ELSE() - - IF( APPLE ) - SET_PROPERTY( SOURCE - vendor/boost_1.51/libs/context/asm/fcontext_x86_64_sysv_macho_gas.S - PROPERTY LANGUAGE C) - SET( boost_context_sources vendor/boost_1.51/libs/context/stack_utils_posix.cpp - vendor/boost_1.51/libs/context/stack_allocator_posix.cpp - vendor/boost_1.51/libs/context/fcontext.cpp - vendor/boost_1.51/libs/context/asm/fcontext_x86_64_sysv_macho_gas.S - ) - ELSE (APPLE) - IF( CMAKE_SIZEOF_VOID_P EQUAL 4 ) - SET_PROPERTY( SOURCE - vendor/boost_1.51/libs/context/asm/fcontext_i386_sysv_elf_gas.S - PROPERTY LANGUAGE C) - SET( fcontext_asm vendor/boost_1.51/libs/context/asm/fcontext_i386_sysv_elf_gas.S ) - ELSE( ) - SET( fcontext_asm vendor/boost_1.51/libs/context/asm/fcontext_x86_64_sysv_elf_gas.S ) - SET_PROPERTY( SOURCE - vendor/boost_1.51/libs/context/asm/fcontext_x86_64_sysv_elf_gas.S - PROPERTY LANGUAGE C) - ENDIF( ) - - SET( boost_context_sources vendor/boost_1.51/libs/context/stack_utils_posix.cpp - vendor/boost_1.51/libs/context/stack_allocator_posix.cpp - vendor/boost_1.51/libs/context/fcontext.cpp - ${fcontext_asm} - ) - ENDIF(APPLE) - - ENDIF() -ENDIF( UNIX ) - -IF( WIN32 ) - ENABLE_LANGUAGE(ASM_MASM) -# SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHa" ) - - SET( boost_context_sources vendor/boost_1.51/libs/context/fcontext.cpp - vendor/boost_1.51/libs/context/seh.cpp - vendor/boost_1.51/libs/context/stack_allocator_windows.cpp - vendor/boost_1.51/libs/context/stack_utils_windows.cpp - vendor/boost_1.51/libs/context/seh.cpp - ) - IF( CMAKE_SIZEOF_VOID_P EQUAL 8 ) - SET( boost_context_sources ${boost_context_sources} - vendor/boost_1.51/libs/context/asm/fcontext_x86_64_ms_pe_masm.asm ) - ELSE() # 32bit - SET( boost_context_sources ${boost_context_sources} - vendor/boost_1.51/libs/context/asm/fcontext_i386_ms_pe_masm.asm ) - SET( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO" ) - message(STATUS "") - message(STATUS "Note for Visual Studio 2012 projects:") - message(STATUS " Each time CMake regenerates your projects, you will need to:") - message(STATUS " Right-click on the 'fc' project and select 'Build Customizations', and") - message(STATUS " check the 'masm' customization.") - message(STATUS " then, go to the 'Properties' for the fcontext*.asm file, and change its ") - message(STATUS " item type from 'Does not participate in build' to 'Microsoft Macro Assembler'") - ENDIF() - -ENDIF(WIN32) - set( sources ${fc_sources} - ${boost_context_sources} ) setup_library( fc SOURCES ${sources} LIBRARY_TYPE STATIC ) diff --git a/src/thread/context.hpp b/src/thread/context.hpp index 6b827b0..59910ba 100644 --- a/src/thread/context.hpp +++ b/src/thread/context.hpp @@ -7,6 +7,7 @@ #include #if BOOST_VERSION >= 105300 + #include #include namespace bc = boost::context; namespace bco = boost::coroutines; @@ -14,7 +15,7 @@ namespace bc = boost::context; #else namespace bc = boost::ctx; - namespace bco = boost::ctx; + namespace bco = boost::coroutine; #endif namespace fc { @@ -30,6 +31,10 @@ namespace fc { struct context { typedef fc::context* ptr; + #ifdef BOOST_VERSION >= 105400 + bco::stack_context stack_ctx; + #endif + context( void (*sf)(intptr_t), bco::stack_allocator& alloc, fc::thread* t ) : caller_context(0), @@ -42,14 +47,19 @@ namespace fc { complete(false), cur_task(0) { -#if BOOST_VERSION >= 105300 +#if BOOST_VERSION >= 105400 + bco::stack_context stack_ctx; size_t stack_size = bco::stack_allocator::default_stacksize(); - my_context = bc::make_fcontext(alloc.allocate(stack_size), stack_size, sf); + alloc.allocate(stack_ctx, stack_size); + my_context = bc::make_fcontext( stack_ctx.sp, stack_ctx.size, sf); +#elif BOOST_VERSION >= 105300 + size_t stack_size = bco::stack_allocator::default_stacksize(); + void* stackptr = alloc.allocate(stack_size); + my_context = bc::make_fcontext( stackptr, stack_size, sf); #else size_t stack_size = bc::default_stacksize(); my_context.fc_stack.base = alloc.allocate( stack_size ); - my_context.fc_stack.limit = - static_cast( my_context.fc_stack.base) - stack_size; + my_context.fc_stack.limit = static_cast( my_context.fc_stack.base) - stack_size; make_fcontext( &my_context, sf ); #endif } @@ -70,8 +80,18 @@ namespace fc { {} ~context() { +#if BOOST_VERSION >= 105400 + if(stack_alloc) + stack_alloc->deallocate( stack_ctx ); + else + delete my_context; +#elif BOOST_VERSION >= 105400 + if(stack_alloc) + stack_alloc->deallocate( my_context->fc_stack.sp, bco::stack_allocator::default_stacksize() ); + else + delete my_context; -#if BOOST_VERSION >= 105300 +#elif BOOST_VERSION >= 105300 if(stack_alloc) stack_alloc->deallocate( my_context->fc_stack.sp, bco::stack_allocator::default_stacksize() ); else diff --git a/vendor/boost_1.51/include/boost/atomic.hpp b/vendor/boost_1.51/include/boost/atomic.hpp deleted file mode 100644 index a8b9c55..0000000 --- a/vendor/boost_1.51/include/boost/atomic.hpp +++ /dev/null @@ -1,217 +0,0 @@ -#ifndef BOOST_ATOMIC_HPP -#define BOOST_ATOMIC_HPP - -// Copyright (c) 2009 Helge Bahmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include - -#include -#include -#include -#include -#include -//#include - -namespace boost { - -template -class atomic : public detail::atomic::internal_atomic { -public: - typedef detail::atomic::internal_atomic super; - - atomic() {} - explicit atomic(T v) : super(v) {} -private: - atomic(const atomic &); - void operator=(const atomic &); -}; - - -template<> -class atomic : private detail::atomic::internal_atomic { -public: - typedef detail::atomic::internal_atomic super; - - atomic() {} - explicit atomic(bool v) : super(v) {} - - using super::load; - using super::store; - using super::compare_exchange_strong; - using super::compare_exchange_weak; - using super::exchange; - using super::is_lock_free; - - operator bool(void) const volatile {return load();} - bool operator=(bool v) volatile {store(v); return v;} -private: - atomic(const atomic &); - void operator=(const atomic &); -}; - -template<> -class atomic : private detail::atomic::internal_atomic { -public: - typedef detail::atomic::internal_atomic super; - - atomic() {} - explicit atomic(void * p) : super(p) {} - using super::load; - using super::store; - using super::compare_exchange_strong; - using super::compare_exchange_weak; - using super::exchange; - using super::is_lock_free; - - operator void *(void) const volatile {return load();} - void * operator=(void * v) volatile {store(v); return v;} - -private: - atomic(const atomic &); - void * operator=(const atomic &); -}; - -/* FIXME: pointer arithmetic still missing */ - -template -class atomic : private detail::atomic::internal_atomic { -public: - typedef detail::atomic::internal_atomic super; - - atomic() {} - explicit atomic(T * p) : super((intptr_t)p) {} - - T *load(memory_order order=memory_order_seq_cst) const volatile - { - return (T*)super::load(order); - } - void store(T *v, memory_order order=memory_order_seq_cst) volatile - { - super::store((intptr_t)v, order); - } - bool compare_exchange_strong( - T * &expected, - T * desired, - memory_order order=memory_order_seq_cst) volatile - { - return compare_exchange_strong(expected, desired, order, detail::atomic::calculate_failure_order(order)); - } - bool compare_exchange_weak( - T * &expected, - T *desired, - memory_order order=memory_order_seq_cst) volatile - { - return compare_exchange_weak(expected, desired, order, detail::atomic::calculate_failure_order(order)); - } - bool compare_exchange_weak( - T * &expected, - T *desired, - memory_order success_order, - memory_order failure_order) volatile - { - intptr_t expected_=(intptr_t)expected; - intptr_t desired_=(intptr_t)desired; - bool success=super::compare_exchange_weak(expected_, desired_, success_order, failure_order); - expected=(T*)expected_; - return success; - } - bool compare_exchange_strong( - T * &expected, - T *desired, - memory_order success_order, - memory_order failure_order) volatile - { - intptr_t expected_=(intptr_t)expected, desired_=(intptr_t)desired; - bool success=super::compare_exchange_strong(expected_, desired_, success_order, failure_order); - expected=(T*)expected_; - return success; - } - T *exchange(T * replacement, memory_order order=memory_order_seq_cst) volatile - { - return (T*)super::exchange((intptr_t)replacement, order); - } - using super::is_lock_free; - - operator T *(void) const volatile {return load();} - T * operator=(T * v) volatile {store(v); return v;} - - T * fetch_add(ptrdiff_t diff, memory_order order=memory_order_seq_cst) volatile - { - return (T*)super::fetch_add(diff*sizeof(T), order); - } - T * fetch_sub(ptrdiff_t diff, memory_order order=memory_order_seq_cst) volatile - { - return (T*)super::fetch_sub(diff*sizeof(T), order); - } - - T *operator++(void) volatile {return fetch_add(1)+1;} - T *operator++(int) volatile {return fetch_add(1);} - T *operator--(void) volatile {return fetch_sub(1)-1;} - T *operator--(int) volatile {return fetch_sub(1);} -private: - atomic(const atomic &); - T * operator=(const atomic &); -}; - -class atomic_flag : private atomic { -public: - typedef atomic super; - using super::is_lock_free; - - atomic_flag(bool initial_state) : super(initial_state?1:0) {} - atomic_flag() {} - - bool test_and_set(memory_order order=memory_order_seq_cst) - { - return super::exchange(1, order) ? true : false; - } - void clear(memory_order order=memory_order_seq_cst) - { - super::store(0, order); - } -}; - -typedef atomic atomic_char; -typedef atomic atomic_uchar; -typedef atomic atomic_schar; -typedef atomic atomic_uint8_t; -typedef atomic atomic_int8_t; -typedef atomic atomic_ushort; -typedef atomic atomic_short; -typedef atomic atomic_uint16_t; -typedef atomic atomic_int16_t; -typedef atomic atomic_uint; -typedef atomic atomic_int; -typedef atomic atomic_uint32_t; -typedef atomic atomic_int32_t; -typedef atomic atomic_ulong; -typedef atomic atomic_long; -typedef atomic atomic_uint64_t; -typedef atomic atomic_int64_t; -#ifdef BOOST_HAS_LONG_LONG -typedef atomic atomic_ullong; -typedef atomic atomic_llong; -#endif -#ifdef BOOST_ATOMIC_HAVE_GNU_128BIT_INTEGERS -typedef atomic<__uint128_t> atomic_uint128_t; -typedef atomic<__int128_t> atomic_int128_t; -#endif -#if BOOST_MSVC >= 1500 && (defined(_M_IA64) || defined(_M_AMD64)) && defined(BOOST_ATOMIC_HAVE_SSE2) -typedef atomic<__m128i> atomic_uint128_t; -typedef atomic<__m128i> atomic_int128_t; -#endif -typedef atomic atomic_address; -typedef atomic atomic_bool; - -static inline void atomic_thread_fence(memory_order order) -{ - detail::atomic::platform_atomic_thread_fence(order); -} - -} - -#endif diff --git a/vendor/boost_1.51/include/boost/atomic/detail/base.hpp b/vendor/boost_1.51/include/boost/atomic/detail/base.hpp deleted file mode 100644 index daa0d94..0000000 --- a/vendor/boost_1.51/include/boost/atomic/detail/base.hpp +++ /dev/null @@ -1,186 +0,0 @@ -#ifndef BOOST_DETAIL_ATOMIC_BASE_HPP -#define BOOST_DETAIL_ATOMIC_BASE_HPP - -// Copyright (c) 2009 Helge Bahmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include -#include - -namespace boost { -namespace detail { -namespace atomic { - -static inline memory_order calculate_failure_order(memory_order order) -{ - switch(order) { - case memory_order_acq_rel: return memory_order_acquire; - case memory_order_release: return memory_order_relaxed; - default: return order; - } -} - -template -class platform_atomic : public fallback_atomic { -public: - typedef fallback_atomic super; - - explicit platform_atomic(T v) : super(v) {} - platform_atomic() {} -protected: - typedef typename super::integral_type integral_type; -}; - -template -class platform_atomic_integral : public build_atomic_from_exchange > { -public: - typedef build_atomic_from_exchange > super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral() {} -protected: - typedef typename super::integral_type integral_type; -}; - -template -static inline void platform_atomic_thread_fence(T order) -{ - /* FIXME: this does not provide - sequential consistency, need one global - variable for that... */ - platform_atomic a; - a.exchange(0, order); -} - -template::test> -class internal_atomic; - -template -class internal_atomic : private detail::atomic::platform_atomic { -public: - typedef detail::atomic::platform_atomic super; - - internal_atomic() {} - explicit internal_atomic(T v) : super(v) {} - - operator T(void) const volatile {return load();} - T operator=(T v) volatile {store(v); return v;} - - using super::is_lock_free; - using super::load; - using super::store; - using super::exchange; - - bool compare_exchange_strong( - T &expected, - T desired, - memory_order order=memory_order_seq_cst) volatile - { - return super::compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order order=memory_order_seq_cst) volatile - { - return super::compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return super::compare_exchange_strong(expected, desired, success_order, failure_order); - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return super::compare_exchange_strong(expected, desired, success_order, failure_order); - } -private: - internal_atomic(const internal_atomic &); - void operator=(const internal_atomic &); -}; - -template -class internal_atomic : private detail::atomic::platform_atomic_integral { -public: - typedef detail::atomic::platform_atomic_integral super; - typedef typename super::integral_type integral_type; - - internal_atomic() {} - explicit internal_atomic(T v) : super(v) {} - - using super::is_lock_free; - using super::load; - using super::store; - using super::exchange; - using super::fetch_add; - using super::fetch_sub; - using super::fetch_and; - using super::fetch_or; - using super::fetch_xor; - - operator integral_type(void) const volatile {return load();} - integral_type operator=(integral_type v) volatile {store(v); return v;} - - integral_type operator&=(integral_type c) volatile {return fetch_and(c)&c;} - integral_type operator|=(integral_type c) volatile {return fetch_or(c)|c;} - integral_type operator^=(integral_type c) volatile {return fetch_xor(c)^c;} - - integral_type operator+=(integral_type c) volatile {return fetch_add(c)+c;} - integral_type operator-=(integral_type c) volatile {return fetch_sub(c)-c;} - - integral_type operator++(void) volatile {return fetch_add(1)+1;} - integral_type operator++(int) volatile {return fetch_add(1);} - integral_type operator--(void) volatile {return fetch_sub(1)-1;} - integral_type operator--(int) volatile {return fetch_sub(1);} - - bool compare_exchange_strong( - integral_type &expected, - integral_type desired, - memory_order order=memory_order_seq_cst) volatile - { - return super::compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); - } - bool compare_exchange_weak( - integral_type &expected, - integral_type desired, - memory_order order=memory_order_seq_cst) volatile - { - return super::compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); - } - bool compare_exchange_strong( - integral_type &expected, - integral_type desired, - memory_order success_order, - memory_order failure_order) volatile - { - return super::compare_exchange_strong(expected, desired, success_order, failure_order); - } - bool compare_exchange_weak( - integral_type &expected, - integral_type desired, - memory_order success_order, - memory_order failure_order) volatile - { - return super::compare_exchange_strong(expected, desired, success_order, failure_order); - } -private: - internal_atomic(const internal_atomic &); - void operator=(const internal_atomic &); -}; - -} -} -} - -#endif diff --git a/vendor/boost_1.51/include/boost/atomic/detail/builder.hpp b/vendor/boost_1.51/include/boost/atomic/detail/builder.hpp deleted file mode 100644 index 19f8b39..0000000 --- a/vendor/boost_1.51/include/boost/atomic/detail/builder.hpp +++ /dev/null @@ -1,412 +0,0 @@ -#ifndef BOOST_DETAIL_ATOMIC_BUILDER_HPP -#define BOOST_DETAIL_ATOMIC_BUILDER_HPP - -// Copyright (c) 2009 Helge Bahmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include - -namespace boost { -namespace detail { -namespace atomic { - -/* -given a Base that implements: - -- load(memory_order order) -- compare_exchange_weak(integral_type &expected, integral_type desired, memory_order order) - -generates exchange and compare_exchange_strong -*/ -template -class build_exchange : public Base { -public: - typedef typename Base::integral_type integral_type; - - using Base::load; - using Base::compare_exchange_weak; - - bool compare_exchange_strong( - integral_type &expected, - integral_type desired, - memory_order success_order, - memory_order failure_order) volatile - { - integral_type expected_save=expected; - while(true) { - if (compare_exchange_weak(expected, desired, success_order, failure_order)) return true; - if (expected_save!=expected) return false; - expected=expected_save; - } - } - - integral_type exchange(integral_type replacement, memory_order order=memory_order_seq_cst) volatile - { - integral_type o=load(memory_order_relaxed); - do {} while(!compare_exchange_weak(o, replacement, order, memory_order_relaxed)); - return o; - } - - build_exchange() {} - explicit build_exchange(integral_type i) : Base(i) {} -}; - -/* -given a Base that implements: - -- fetch_add_var(integral_type c, memory_order order) -- fetch_inc(memory_order order) -- fetch_dec(memory_order order) - -creates a fetch_add method that delegates to fetch_inc/fetch_dec if operand -is constant +1/-1, and uses fetch_add_var otherwise - -the intention is to allow optimizing the incredibly common case of +1/-1 -*/ -template -class build_const_fetch_add : public Base { -public: - typedef typename Base::integral_type integral_type; - - integral_type fetch_add( - integral_type c, - memory_order order=memory_order_seq_cst) volatile - { - if (__builtin_constant_p(c)) { - switch(c) { - case -1: return fetch_dec(order); - case 1: return fetch_inc(order); - } - } - return fetch_add_var(c, order); - } - - build_const_fetch_add() {} - explicit build_const_fetch_add(integral_type i) : Base(i) {} -protected: - using Base::fetch_add_var; - using Base::fetch_inc; - using Base::fetch_dec; -}; - -/* -given a Base that implements: - -- load(memory_order order) -- compare_exchange_weak(integral_type &expected, integral_type desired, memory_order order) - -generates a -- not very efficient, but correct -- fetch_add operation -*/ -template -class build_fetch_add : public Base { -public: - typedef typename Base::integral_type integral_type; - - using Base::compare_exchange_weak; - - integral_type fetch_add( - integral_type c, memory_order order=memory_order_seq_cst) volatile - { - integral_type o=Base::load(memory_order_relaxed), n; - do {n=o+c;} while(!compare_exchange_weak(o, n, order, memory_order_relaxed)); - return o; - } - - build_fetch_add() {} - explicit build_fetch_add(integral_type i) : Base(i) {} -}; - -/* -given a Base that implements: - -- fetch_add(integral_type c, memory_order order) - -generates fetch_sub and post/pre- increment/decrement operators -*/ -template -class build_arithmeticops : public Base { -public: - typedef typename Base::integral_type integral_type; - - using Base::fetch_add; - - integral_type fetch_sub( - integral_type c, - memory_order order=memory_order_seq_cst) volatile - { -#if defined(BOOST_MSVC) -#pragma warning(push) -#pragma warning(disable: 4146) // unary minus operator applied to unsigned type, result still unsigned -#endif - return fetch_add(-c, order); -#if defined(BOOST_MSVC) -#pragma warning(pop) -#endif - } - - build_arithmeticops() {} - explicit build_arithmeticops(integral_type i) : Base(i) {} -}; - -/* -given a Base that implements: - -- load(memory_order order) -- compare_exchange_weak(integral_type &expected, integral_type desired, memory_order order) - -generates -- not very efficient, but correct -- fetch_and, fetch_or and fetch_xor operators -*/ -template -class build_logicops : public Base { -public: - typedef typename Base::integral_type integral_type; - - using Base::compare_exchange_weak; - using Base::load; - - integral_type fetch_and(integral_type c, memory_order order=memory_order_seq_cst) volatile - { - integral_type o=load(memory_order_relaxed), n; - do {n=o&c;} while(!compare_exchange_weak(o, n, order, memory_order_relaxed)); - return o; - } - integral_type fetch_or(integral_type c, memory_order order=memory_order_seq_cst) volatile - { - integral_type o=load(memory_order_relaxed), n; - do {n=o|c;} while(!compare_exchange_weak(o, n, order, memory_order_relaxed)); - return o; - } - integral_type fetch_xor(integral_type c, memory_order order=memory_order_seq_cst) volatile - { - integral_type o=load(memory_order_relaxed), n; - do {n=o^c;} while(!compare_exchange_weak(o, n, order, memory_order_relaxed)); - return o; - } - - build_logicops() {} - build_logicops(integral_type i) : Base(i) {} -}; - -/* -given a Base that implements: - -- load(memory_order order) -- store(integral_type i, memory_order order) -- compare_exchange_weak(integral_type &expected, integral_type desired, memory_order order) - -generates the full set of atomic operations for integral types -*/ -template -class build_atomic_from_minimal : public build_logicops< build_arithmeticops< build_fetch_add< build_exchange > > > { -public: - typedef build_logicops< build_arithmeticops< build_fetch_add< build_exchange > > > super; - typedef typename super::integral_type integral_type; - - build_atomic_from_minimal(void) {} - build_atomic_from_minimal(typename super::integral_type i) : super(i) {} -}; - -/* -given a Base that implements: - -- load(memory_order order) -- store(integral_type i, memory_order order) -- compare_exchange_weak(integral_type &expected, integral_type desired, memory_order order) -- compare_exchange_strong(integral_type &expected, integral_type desired, memory_order order) -- exchange(integral_type replacement, memory_order order) -- fetch_add_var(integral_type c, memory_order order) -- fetch_inc(memory_order order) -- fetch_dec(memory_order order) - -generates the full set of atomic operations for integral types -*/ -template -class build_atomic_from_typical : public build_logicops< build_arithmeticops< build_const_fetch_add > > { -public: - typedef build_logicops< build_arithmeticops< build_const_fetch_add > > super; - typedef typename super::integral_type integral_type; - - build_atomic_from_typical(void) {} - build_atomic_from_typical(typename super::integral_type i) : super(i) {} -}; - -/* -given a Base that implements: - -- load(memory_order order) -- store(integral_type i, memory_order order) -- compare_exchange_weak(integral_type &expected, integral_type desired, memory_order order) -- compare_exchange_strong(integral_type &expected, integral_type desired, memory_order order) -- exchange(integral_type replacement, memory_order order) -- fetch_add(integral_type c, memory_order order) - -generates the full set of atomic operations for integral types -*/ -template -class build_atomic_from_add : public build_logicops< build_arithmeticops > { -public: - typedef build_logicops< build_arithmeticops > super; - typedef typename super::integral_type integral_type; - - build_atomic_from_add(void) {} - build_atomic_from_add(typename super::integral_type i) : super(i) {} -}; - -/* -given a Base that implements: - -- load(memory_order order) -- store(integral_type i, memory_order order) -- compare_exchange_weak(integral_type &expected, integral_type desired, memory_order order) -- compare_exchange_strong(integral_type &expected, integral_type desired, memory_order order) -- exchange(integral_type replacement, memory_order order) - -generates the full set of atomic operations for integral types -*/ -template -class build_atomic_from_exchange : public build_logicops< build_arithmeticops< build_fetch_add > > { -public: - typedef build_logicops< build_arithmeticops< build_fetch_add > > super; - typedef typename super::integral_type integral_type; - - build_atomic_from_exchange(void) {} - build_atomic_from_exchange(typename super::integral_type i) : super(i) {} -}; - - -/* -given a Base that implements: - -- compare_exchange_weak() - -generates load, store and compare_exchange_weak for a smaller -data type (e.g. an atomic "byte" embedded into a temporary -and properly aligned atomic "int"). -*/ -template -class build_base_from_larger_type { -public: - typedef Type integral_type; - - build_base_from_larger_type() {} - build_base_from_larger_type(integral_type t) {store(t, memory_order_relaxed);} - - integral_type load(memory_order order=memory_order_seq_cst) const volatile - { - larger_integral_type v=get_base().load(order); - return extract(v); - } - bool compare_exchange_weak(integral_type &expected, - integral_type desired, - memory_order success_order, - memory_order failure_order) volatile - { - larger_integral_type expected_; - larger_integral_type desired_; - - expected_=get_base().load(memory_order_relaxed); - expected_=insert(expected_, expected); - desired_=insert(expected_, desired); - bool success=get_base().compare_exchange_weak(expected_, desired_, success_order, failure_order); - expected=extract(expected_); - return success; - } - void store(integral_type v, - memory_order order=memory_order_seq_cst) volatile - { - larger_integral_type expected, desired; - expected=get_base().load(memory_order_relaxed); - do { - desired=insert(expected, v); - } while(!get_base().compare_exchange_weak(expected, desired, order, memory_order_relaxed)); - } - - bool is_lock_free(void) - { - return get_base().is_lock_free(); - } -private: - typedef typename Base::integral_type larger_integral_type; - - const Base &get_base(void) const volatile - { - intptr_t address=(intptr_t)this; - address&=~(sizeof(larger_integral_type)-1); - return *reinterpret_cast(address); - } - Base &get_base(void) volatile - { - intptr_t address=(intptr_t)this; - address&=~(sizeof(larger_integral_type)-1); - return *reinterpret_cast(address); - } - unsigned int get_offset(void) const volatile - { - intptr_t address=(intptr_t)this; - address&=(sizeof(larger_integral_type)-1); - return address; - } - - unsigned int get_shift(void) const volatile - { -#if defined(BOOST_LITTLE_ENDIAN) - return get_offset()*8; -#elif defined(BOOST_BIG_ENDIAN) - return (sizeof(larger_integral_type)-sizeof(integral_type)-get_offset())*8; -#else - #error "Unknown endian" -#endif - } - - integral_type extract(larger_integral_type v) const volatile - { - return v>>get_shift(); - } - - larger_integral_type insert(larger_integral_type target, integral_type source) const volatile - { - larger_integral_type tmp=source; - larger_integral_type mask=(larger_integral_type)-1; - - mask=~(mask<<(8*sizeof(integral_type))); - - mask=mask< -class build_atomic_from_larger_type : public build_atomic_from_minimal< build_base_from_larger_type > { -public: - typedef build_atomic_from_minimal< build_base_from_larger_type > super; - //typedef typename super::integral_type integral_type; - typedef Type integral_type; - - build_atomic_from_larger_type() {} - build_atomic_from_larger_type(integral_type v) : super(v) {} -}; - -} -} -} - -#endif diff --git a/vendor/boost_1.51/include/boost/atomic/detail/fallback.hpp b/vendor/boost_1.51/include/boost/atomic/detail/fallback.hpp deleted file mode 100644 index e539099..0000000 --- a/vendor/boost_1.51/include/boost/atomic/detail/fallback.hpp +++ /dev/null @@ -1,76 +0,0 @@ -#ifndef BOOST_DETAIL_ATOMIC_FALLBACK_HPP -#define BOOST_DETAIL_ATOMIC_FALLBACK_HPP - -// Copyright (c) 2009 Helge Bahmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include - -namespace boost { -namespace detail { -namespace atomic { - -template -class fallback_atomic { -public: - fallback_atomic(void) {} - explicit fallback_atomic(const T &t) {memcpy(&i, &t, sizeof(T));} - - void store(const T &t, memory_order order=memory_order_seq_cst) volatile - { - detail::spinlock_pool<0>::scoped_lock guard(const_cast(&i)); - memcpy((void*)&i, &t, sizeof(T)); - } - T load(memory_order /*order*/=memory_order_seq_cst) volatile const - { - detail::spinlock_pool<0>::scoped_lock guard(const_cast(&i)); - T tmp; - memcpy(&tmp, (T*)&i, sizeof(T)); - return tmp; - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order /*success_order*/, - memory_order /*failure_order*/) volatile - { - detail::spinlock_pool<0>::scoped_lock guard(const_cast(&i)); - if (memcmp((void*)&i, &expected, sizeof(T))==0) { - memcpy((void*)&i, &desired, sizeof(T)); - return true; - } else { - memcpy(&expected, (void*)&i, sizeof(T)); - return false; - } - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - T exchange(T replacement, memory_order /*order*/=memory_order_seq_cst) volatile - { - detail::spinlock_pool<0>::scoped_lock guard(const_cast(&i)); - T tmp; - memcpy(&tmp, (void*)&i, sizeof(T)); - memcpy((void*)&i, &replacement, sizeof(T)); - return tmp; - } - bool is_lock_free(void) const volatile {return false;} -protected: - T i; - typedef T integral_type; -}; - -} -} -} - -#endif diff --git a/vendor/boost_1.51/include/boost/atomic/detail/gcc-alpha.hpp b/vendor/boost_1.51/include/boost/atomic/detail/gcc-alpha.hpp deleted file mode 100644 index 8e55f44..0000000 --- a/vendor/boost_1.51/include/boost/atomic/detail/gcc-alpha.hpp +++ /dev/null @@ -1,354 +0,0 @@ -#ifndef BOOST_DETAIL_ATOMIC_GCC_ALPHA_HPP -#define BOOST_DETAIL_ATOMIC_GCC_ALPHA_HPP - -// Copyright (c) 2009 Helge Bahmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include - -/* - Refer to http://h71000.www7.hp.com/doc/82final/5601/5601pro_004.html - (HP OpenVMS systems documentation) and the alpha reference manual. - */ - -/* - NB: The most natural thing would be to write the increment/decrement - operators along the following lines: - - __asm__ __volatile__( - "1: ldl_l %0,%1 \n" - "addl %0,1,%0 \n" - "stl_c %0,%1 \n" - "beq %0,1b\n" - : "=&b" (tmp) - : "m" (value) - : "cc" - ); - - However according to the comments on the HP website and matching - comments in the Linux kernel sources this defies branch prediction, - as the cpu assumes that backward branches are always taken; so - instead copy the trick from the Linux kernel, introduce a forward - branch and back again. - - I have, however, had a hard time measuring the difference between - the two versions in microbenchmarks -- I am leaving it in nevertheless - as it apparently does not hurt either. -*/ - -namespace boost { -namespace detail { -namespace atomic { - -static inline void fence_before(memory_order order) -{ - switch(order) { - case memory_order_consume: - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - __asm__ __volatile__ ("mb" ::: "memory"); - default:; - } -} - -static inline void fence_after(memory_order order) -{ - switch(order) { - case memory_order_acquire: - case memory_order_acq_rel: - case memory_order_seq_cst: - __asm__ __volatile__ ("mb" ::: "memory"); - default:; - } -} - -template<> -inline void platform_atomic_thread_fence(memory_order order) -{ - switch(order) { - case memory_order_acquire: - case memory_order_consume: - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - __asm__ __volatile__ ("mb" ::: "memory"); - default:; - } -} - -template -class atomic_alpha_32 { -public: - typedef T integral_type; - explicit atomic_alpha_32(T v) : i(v) {} - atomic_alpha_32() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v=*reinterpret_cast(&i); - fence_after(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - fence_before(order); - *reinterpret_cast(&i)=(int)v; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - fence_before(success_order); - int current, success; - __asm__ __volatile__( - "1: ldl_l %2, %4\n" - "cmpeq %2, %0, %3\n" - "mov %2, %0\n" - "beq %3, 3f\n" - "stl_c %1, %4\n" - "2:\n" - - ".subsection 2\n" - "3: mov %3, %1\n" - "br 2b\n" - ".previous\n" - - : "+&r" (expected), "+&r" (desired), "=&r"(current), "=&r"(success) - : "m" (i) - : - ); - if (desired) fence_after(success_order); - else fence_after(failure_order); - return desired; - } - - bool is_lock_free(void) const volatile {return true;} -protected: - inline T fetch_add_var(T c, memory_order order) volatile - { - fence_before(order); - T original, modified; - __asm__ __volatile__( - "1: ldl_l %0, %2\n" - "addl %0, %3, %1\n" - "stl_c %1, %2\n" - "beq %1, 2f\n" - - ".subsection 2\n" - "2: br 1b\n" - ".previous\n" - - : "=&r" (original), "=&r" (modified) - : "m" (i), "r" (c) - : - ); - fence_after(order); - return original; - } - inline T fetch_inc(memory_order order) volatile - { - fence_before(order); - int original, modified; - __asm__ __volatile__( - "1: ldl_l %0, %2\n" - "addl %0, 1, %1\n" - "stl_c %1, %2\n" - "beq %1, 2f\n" - - ".subsection 2\n" - "2: br 1b\n" - ".previous\n" - - : "=&r" (original), "=&r" (modified) - : "m" (i) - : - ); - fence_after(order); - return original; - } - inline T fetch_dec(memory_order order) volatile - { - fence_before(order); - int original, modified; - __asm__ __volatile__( - "1: ldl_l %0, %2\n" - "subl %0, 1, %1\n" - "stl_c %1, %2\n" - "beq %1, 2f\n" - - ".subsection 2\n" - "2: br 1b\n" - ".previous\n" - - : "=&r" (original), "=&r" (modified) - : "m" (i) - : - ); - fence_after(order); - return original; - } -private: - T i; -}; - -template -class atomic_alpha_64 { -public: - typedef T integral_type; - explicit atomic_alpha_64(T v) : i(v) {} - atomic_alpha_64() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v=*reinterpret_cast(&i); - fence_after(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - fence_before(order); - *reinterpret_cast(&i)=v; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - fence_before(success_order); - int current, success; - __asm__ __volatile__( - "1: ldq_l %2, %4\n" - "cmpeq %2, %0, %3\n" - "mov %2, %0\n" - "beq %3, 3f\n" - "stq_c %1, %4\n" - "2:\n" - - ".subsection 2\n" - "3: mov %3, %1\n" - "br 2b\n" - ".previous\n" - - : "+&r" (expected), "+&r" (desired), "=&r"(current), "=&r"(success) - : "m" (i) - : - ); - if (desired) fence_after(success_order); - else fence_after(failure_order); - return desired; - } - - bool is_lock_free(void) const volatile {return true;} -protected: - inline T fetch_add_var(T c, memory_order order) volatile - { - fence_before(order); - T original, modified; - __asm__ __volatile__( - "1: ldq_l %0, %2\n" - "addq %0, %3, %1\n" - "stq_c %1, %2\n" - "beq %1, 2f\n" - - ".subsection 2\n" - "2: br 1b\n" - ".previous\n" - - : "=&r" (original), "=&r" (modified) - : "m" (i), "r" (c) - : - ); - fence_after(order); - return original; - } - inline T fetch_inc(memory_order order) volatile - { - fence_before(order); - T original, modified; - __asm__ __volatile__( - "1: ldq_l %0, %2\n" - "addq %0, 1, %1\n" - "stq_c %1, %2\n" - "beq %1, 2f\n" - - ".subsection 2\n" - "2: br 1b\n" - ".previous\n" - - : "=&r" (original), "=&r" (modified) - : "m" (i) - : - ); - fence_after(order); - return original; - } - inline T fetch_dec(memory_order order) volatile - { - fence_before(order); - T original, modified; - __asm__ __volatile__( - "1: ldq_l %0, %2\n" - "subq %0, 1, %1\n" - "stq_c %1, %2\n" - "beq %1, 2f\n" - - ".subsection 2\n" - "2: br 1b\n" - ".previous\n" - - : "=&r" (original), "=&r" (modified) - : "m" (i) - : - ); - fence_after(order); - return original; - } -private: - T i; -}; - -template -class platform_atomic_integral : public build_atomic_from_typical > > { -public: - typedef build_atomic_from_typical > > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral : public build_atomic_from_typical > > { -public: - typedef build_atomic_from_typical > > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral: public build_atomic_from_larger_type, T> { -public: - typedef build_atomic_from_larger_type, T> super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral: public build_atomic_from_larger_type, T> { -public: - typedef build_atomic_from_larger_type, T> super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -} -} -} - -#endif diff --git a/vendor/boost_1.51/include/boost/atomic/detail/gcc-armv6+.hpp b/vendor/boost_1.51/include/boost/atomic/detail/gcc-armv6+.hpp deleted file mode 100644 index 04a5bda..0000000 --- a/vendor/boost_1.51/include/boost/atomic/detail/gcc-armv6+.hpp +++ /dev/null @@ -1,299 +0,0 @@ -#ifndef BOOST_DETAIL_ATOMIC_GCC_ARMV6P_HPP -#define BOOST_DETAIL_ATOMIC_GCC_ARMV6P_HPP - -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// Copyright (c) 2009 Helge Bahmann -// Copyright (c) 2009 Phil Endecott -// ARM Code by Phil Endecott, based on other architectures. - - -#include -#include -#include - -// From the ARM Architecture Reference Manual for architecture v6: -// -// LDREX{} , [] -// Specifies the destination register for the memory word addressed by -// Specifies the register containing the address. -// -// STREX{} , , [] -// Specifies the destination register for the returned status value. -// 0 if the operation updates memory -// 1 if the operation fails to update memory -// Specifies the register containing the word to be stored to memory. -// Specifies the register containing the address. -// Rd must not be the same register is Rm or Rn. -// -// ARM v7 is like ARM v6 plus: -// There are half-word and byte versions of the LDREX and STREX instructions, -// LDREXH, LDREXB, STREXH and STREXB. -// There are also double-word versions, LDREXD and STREXD. -// (Actually it looks like these are available from version 6k onwards.) -// FIXME these are not yet used; should be mostly a matter of copy-and-paste. -// I think you can supply an immediate offset to the address. -// -// A memory barrier is effected using a "co-processor 15" instruction, -// though a separate assembler mnemonic is available for it in v7. - -namespace boost { -namespace detail { -namespace atomic { - - -// "Thumb 1" is a subset of the ARM instruction set that uses a 16-bit encoding. It -// doesn't include all instructions and in particular it doesn't include the co-processor -// instruction used for the memory barrier or the load-locked/store-conditional -// instructions. So, if we're compiling in "Thumb 1" mode, we need to wrap all of our -// asm blocks with code to temporarily change to ARM mode. -// -// You can only change between ARM and Thumb modes when branching using the bx instruction. -// bx takes an address specified in a register. The least significant bit of the address -// indicates the mode, so 1 is added to indicate that the destination code is Thumb. -// A temporary register is needed for the address and is passed as an argument to these -// macros. It must be one of the "low" registers accessible to Thumb code, specified -// usng the "l" attribute in the asm statement. -// -// Architecture v7 introduces "Thumb 2", which does include (almost?) all of the ARM -// instruction set. So in v7 we don't need to change to ARM mode; we can write "universal -// assembler" which will assemble to Thumb 2 or ARM code as appropriate. The only thing -// we need to do to make this "universal" assembler mode work is to insert "IT" instructions -// to annotate the conditional instructions. These are ignored in other modes (e.g. v6), -// so they can always be present. - -#if defined(__thumb__) && !defined(__ARM_ARCH_7A__) -// FIXME also other v7 variants. -#define BOOST_ATOMIC_ARM_ASM_START(TMPREG) "adr " #TMPREG ", 1f\n" "bx " #TMPREG "\n" ".arm\n" ".align 4\n" "1: " -#define BOOST_ATOMIC_ARM_ASM_END(TMPREG) "adr " #TMPREG ", 1f + 1\n" "bx " #TMPREG "\n" ".thumb\n" ".align 2\n" "1: " - -#else -// The tmpreg is wasted in this case, which is non-optimal. -#define BOOST_ATOMIC_ARM_ASM_START(TMPREG) -#define BOOST_ATOMIC_ARM_ASM_END(TMPREG) -#endif - - -#if defined(__ARM_ARCH_7A__) -// FIXME ditto. -#define BOOST_ATOMIC_ARM_DMB "dmb\n" -#else -#define BOOST_ATOMIC_ARM_DMB "mcr\tp15, 0, r0, c7, c10, 5\n" -#endif - -// There is also a "Data Synchronisation Barrier" DSB; this exists in v6 as another co-processor -// instruction like the above. - - -static inline void fence_before(memory_order order) -{ - // FIXME I don't understand enough about barriers to know what this should do. - switch(order) { - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - int brtmp; - __asm__ __volatile__ ( - BOOST_ATOMIC_ARM_ASM_START(%0) - BOOST_ATOMIC_ARM_DMB - BOOST_ATOMIC_ARM_ASM_END(%0) - : "=&l" (brtmp) :: "memory" - ); - default:; - } -} - -static inline void fence_after(memory_order order) -{ - // FIXME I don't understand enough about barriers to know what this should do. - switch(order) { - case memory_order_acquire: - case memory_order_acq_rel: - case memory_order_seq_cst: - int brtmp; - __asm__ __volatile__ ( - BOOST_ATOMIC_ARM_ASM_START(%0) - BOOST_ATOMIC_ARM_DMB - BOOST_ATOMIC_ARM_ASM_END(%0) - : "=&l" (brtmp) :: "memory" - ); - case memory_order_consume: - __asm__ __volatile__ ("" ::: "memory"); - default:; - } -} - -#undef BOOST_ATOMIC_ARM_DMB - - -template -class atomic_arm_4 { -public: - typedef T integral_type; - explicit atomic_arm_4(T v) : i(v) {} - atomic_arm_4() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v=const_cast(i); - fence_after(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - fence_before(order); - const_cast(i)=v; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - fence_before(success_order); - int success; - int tmp; - __asm__ __volatile__( - BOOST_ATOMIC_ARM_ASM_START(%2) - "mov %1, #0\n" // success = 0 - "ldrex %0, [%3]\n" // expected' = *(&i) - "teq %0, %4\n" // flags = expected'==expected - "ittt eq\n" - "strexeq %2, %5, [%3]\n" // if (flags.equal) *(&i) = desired, tmp = !OK - "teqeq %2, #0\n" // if (flags.equal) flags = tmp==0 - "moveq %1, #1\n" // if (flags.equal) success = 1 - BOOST_ATOMIC_ARM_ASM_END(%2) - : "=&r" (expected), // %0 - "=&r" (success), // %1 - "=&l" (tmp) // %2 - : "r" (&i), // %3 - "r" (expected), // %4 - "r" ((int)desired) // %5 - : "cc" - ); - if (success) fence_after(success_order); - else fence_after(failure_order); - return success; - } - - bool is_lock_free(void) const volatile {return true;} -protected: - inline T fetch_add_var(T c, memory_order order) volatile - { - fence_before(order); - T original, tmp; - int tmp2; - __asm__ __volatile__( - BOOST_ATOMIC_ARM_ASM_START(%2) - "1: ldrex %0, [%3]\n" // original = *(&i) - "add %1, %0, %4\n" // tmp = original + c - "strex %2, %1, [%3]\n" // *(&i) = tmp; tmp2 = !OK - "teq %2, #0\n" // flags = tmp2==0 - "it ne\n" - "bne 1b\n" // if (!flags.equal) goto 1 - BOOST_ATOMIC_ARM_ASM_END(%2) - : "=&r" (original), // %0 - "=&r" (tmp), // %1 - "=&l" (tmp2) // %2 - : "r" (&i), // %3 - "r" (c) // %4 - : "cc" - ); - fence_after(order); - return original; - } - inline T fetch_inc(memory_order order) volatile - { - fence_before(order); - T original, tmp; - int tmp2; - __asm__ __volatile__( - BOOST_ATOMIC_ARM_ASM_START(%2) - "1: ldrex %0, [%3]\n" // original = *(&i) - "add %1, %0, #1\n" // tmp = original + 1 - "strex %2, %1, [%3]\n" // *(&i) = tmp; tmp2 = !OK - "teq %2, #0\n" // flags = tmp2==0 - "it ne\n" - "bne 1b\n" // if (!flags.equal) goto 1 - BOOST_ATOMIC_ARM_ASM_END(%2) - : "=&r" (original), // %0 - "=&r" (tmp), // %1 - "=&l" (tmp2) // %2 - : "r" (&i) // %3 - : "cc" - ); - fence_after(order); - return original; - } - inline T fetch_dec(memory_order order) volatile - { - fence_before(order); - T original, tmp; - int tmp2; - __asm__ __volatile__( - BOOST_ATOMIC_ARM_ASM_START(%2) - "1: ldrex %0, [%3]\n" // original = *(&i) - "sub %1, %0, #1\n" // tmp = original - 1 - "strex %2, %1, [%3]\n" // *(&i) = tmp; tmp2 = !OK - "teq %2, #0\n" // flags = tmp2==0 - "it ne\n" - "bne 1b\n" // if (!flags.equal) goto 1 - BOOST_ATOMIC_ARM_ASM_END(%2) - : "=&r" (original), // %0 - "=&r" (tmp), // %1 - "=&l" (tmp2) // %2 - : "r" (&i) // %3 - : "cc" - ); - fence_after(order); - return original; - } -private: - T i; -}; - - -// #ifdef _ARM_ARCH_7 -// FIXME TODO can add native byte and halfword version here - - -template -class platform_atomic_integral : public build_atomic_from_typical > > { -public: - typedef build_atomic_from_typical > > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral: public build_atomic_from_larger_type, T> { -public: - typedef build_atomic_from_larger_type, T> super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral: public build_atomic_from_larger_type, T> { -public: - typedef build_atomic_from_larger_type, T> super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - - - -typedef build_exchange > platform_atomic_address; - -} -} -} - -#undef BOOST_ATOMIC_ARM_ASM_START -#undef BOOST_ATOMIC_ARM_ASM_END - - -#endif diff --git a/vendor/boost_1.51/include/boost/atomic/detail/gcc-ppc.hpp b/vendor/boost_1.51/include/boost/atomic/detail/gcc-ppc.hpp deleted file mode 100644 index 1041e73..0000000 --- a/vendor/boost_1.51/include/boost/atomic/detail/gcc-ppc.hpp +++ /dev/null @@ -1,351 +0,0 @@ -#ifndef BOOST_DETAIL_ATOMIC_GCC_PPC_HPP -#define BOOST_DETAIL_ATOMIC_GCC_PPC_HPP - -// Copyright (c) 2009 Helge Bahmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include - -/* - Refer to: Motorola: "Programming Environments Manual for 32-Bit - Implementations of the PowerPC Architecture", Appendix E: - "Synchronization Programming Examples" for an explanation of what is - going on here (can be found on the web at various places by the - name "MPCFPE32B.pdf", Google is your friend...) - */ - -namespace boost { -namespace detail { -namespace atomic { - -static inline void fence_before(memory_order order) -{ - switch(order) { - case memory_order_release: - case memory_order_acq_rel: -#if defined(__powerpc64__) - __asm__ __volatile__ ("lwsync" ::: "memory"); - break; -#endif - case memory_order_seq_cst: - __asm__ __volatile__ ("sync" ::: "memory"); - default:; - } -} - -/* Note on the barrier instructions used by fence_after and -atomic_thread_fence: the "isync" instruction normally does -not wait for memory-accessing operations to complete, the -"trick" is to introduce a conditional branch that formally -depends on the memory-accessing instruction -- isync waits -until the branch can be resolved and thus implicitly until -the memory access completes. - -This means that the load(memory_order_relaxed) instruction -includes this branch, even though no barrier would be required -here, but as a consequence atomic_thread_fence(memory_order_acquire) -would have to be implemented using "sync" instead of "isync". -The following simple cost-analysis provides the rationale -for this decision: - -- isync: about ~12 cycles -- sync: about ~50 cycles -- "spurious" branch after load: 1-2 cycles -- making the right decision: priceless - -*/ - -static inline void fence_after(memory_order order) -{ - switch(order) { - case memory_order_acquire: - case memory_order_acq_rel: - case memory_order_seq_cst: - __asm__ __volatile__ ("isync"); - case memory_order_consume: - __asm__ __volatile__ ("" ::: "memory"); - default:; - } -} - -template<> -inline void platform_atomic_thread_fence(memory_order order) -{ - switch(order) { - case memory_order_acquire: - __asm__ __volatile__ ("isync" ::: "memory"); - break; - case memory_order_release: - case memory_order_acq_rel: -#if defined(__powerpc64__) - __asm__ __volatile__ ("lwsync" ::: "memory"); - break; -#endif - case memory_order_seq_cst: - __asm__ __volatile__ ("sync" ::: "memory"); - default:; - } -} - - -/* note: the __asm__ constraint "b" instructs gcc to use any register -except r0; this is required because r0 is not allowed in -some places. Since I am sometimes unsure if it is allowed -or not just play it safe and avoid r0 entirely -- ppc isn't -exactly register-starved, so this really should not matter :) */ - -template -class atomic_ppc_32 { -public: - typedef T integral_type; - explicit atomic_ppc_32(T v) : i(v) {} - atomic_ppc_32() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v=*reinterpret_cast(&i); - __asm__ __volatile__ ( - "cmpw %0, %0\n" - "bne- 1f\n" - "1f:\n" - : "+b"(v)); - fence_after(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - fence_before(order); - *reinterpret_cast(&i)=v; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - fence_before(success_order); - int success; - __asm__ __volatile__( - "lwarx %0,0,%2\n" - "cmpw %0, %3\n" - "bne- 2f\n" - "stwcx. %4,0,%2\n" - "bne- 2f\n" - "addi %1,0,1\n" - "1:" - - ".subsection 2\n" - "2: addi %1,0,0\n" - "b 1b\n" - ".previous\n" - : "=&b" (expected), "=&b" (success) - : "b" (&i), "b" (expected), "b" ((int)desired) - ); - if (success) fence_after(success_order); - else fence_after(failure_order); - return success; - } - - bool is_lock_free(void) const volatile {return true;} -protected: - inline T fetch_add_var(T c, memory_order order) volatile - { - fence_before(order); - T original, tmp; - __asm__ __volatile__( - "1: lwarx %0,0,%2\n" - "add %1,%0,%3\n" - "stwcx. %1,0,%2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp) - : "b" (&i), "b" (c) - : "cc"); - fence_after(order); - return original; - } - inline T fetch_inc(memory_order order) volatile - { - fence_before(order); - T original, tmp; - __asm__ __volatile__( - "1: lwarx %0,0,%2\n" - "addi %1,%0,1\n" - "stwcx. %1,0,%2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp) - : "b" (&i) - : "cc"); - fence_after(order); - return original; - } - inline T fetch_dec(memory_order order) volatile - { - fence_before(order); - T original, tmp; - __asm__ __volatile__( - "1: lwarx %0,0,%2\n" - "addi %1,%0,-1\n" - "stwcx. %1,0,%2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp) - : "b" (&i) - : "cc"); - fence_after(order); - return original; - } -private: - T i; -}; - -#if defined(__powerpc64__) - -#warning Untested code -- please inform me if it works - -template -class atomic_ppc_64 { -public: - typedef T integral_type; - explicit atomic_ppc_64(T v) : i(v) {} - atomic_ppc_64() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v=*reinterpret_cast(&i); - __asm__ __volatile__ ( - "cmpw %0, %0\n" - "bne- 1f\n" - "1f:\n" - : "+b"(v)); - fence_after(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - fence_before(order); - *reinterpret_cast(&i)=v; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - fence_before(success_order); - int success; - __asm__ __volatile__( - "ldarx %0,0,%2\n" - "cmpw %0, %3\n" - "bne- 2f\n" - "stdcx. %4,0,%2\n" - "bne- 2f\n" - "addi %1,0,1\n" - "1:" - - ".subsection 2\n" - "2: addi %1,0,0\n" - "b 1b\n" - ".previous\n" - : "=&b" (expected), "=&b" (success) - : "b" (&i), "b" (expected), "b" ((int)desired) - ); - if (success) fence_after(success_order); - else fence_after(failure_order); - fence_after(order); - return success; - } - - bool is_lock_free(void) const volatile {return true;} -protected: - inline T fetch_add_var(T c, memory_order order) volatile - { - fence_before(order); - T original, tmp; - __asm__ __volatile__( - "1: ldarx %0,0,%2\n" - "add %1,%0,%3\n" - "stdcx. %1,0,%2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp) - : "b" (&i), "b" (c) - : "cc"); - fence_after(order); - return original; - } - inline T fetch_inc(memory_order order) volatile - { - fence_before(order); - T original, tmp; - __asm__ __volatile__( - "1: ldarx %0,0,%2\n" - "addi %1,%0,1\n" - "stdcx. %1,0,%2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp) - : "b" (&i) - : "cc"); - fence_after(order); - return original; - } - inline T fetch_dec(memory_order order) volatile - { - fence_before(order); - T original, tmp; - __asm__ __volatile__( - "1: ldarx %0,0,%2\n" - "addi %1,%0,-1\n" - "stdcx. %1,0,%2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp) - : "b" (&i) - : "cc"); - fence_after(order); - return original; - } -private: - T i; -}; -#endif - -template -class platform_atomic_integral : public build_atomic_from_typical > > { -public: - typedef build_atomic_from_typical > > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral: public build_atomic_from_larger_type, T> { -public: - typedef build_atomic_from_larger_type, T> super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral: public build_atomic_from_larger_type, T> { -public: - typedef build_atomic_from_larger_type, T> super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -#if defined(__powerpc64__) -template -class platform_atomic_integral : public build_atomic_from_typical > > { -public: - typedef build_atomic_from_typical > > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; -#endif - -} -} -} - -#endif diff --git a/vendor/boost_1.51/include/boost/atomic/detail/gcc-x86.hpp b/vendor/boost_1.51/include/boost/atomic/detail/gcc-x86.hpp deleted file mode 100644 index 6f1e83a..0000000 --- a/vendor/boost_1.51/include/boost/atomic/detail/gcc-x86.hpp +++ /dev/null @@ -1,546 +0,0 @@ -#ifndef BOOST_DETAIL_ATOMIC_GCC_X86_HPP -#define BOOST_DETAIL_ATOMIC_GCC_X86_HPP - -// Copyright (c) 2009 Helge Bahmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include - -namespace boost { -namespace detail { -namespace atomic { - -static inline void fence_before(memory_order order) -{ - switch(order) { - case memory_order_consume: - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - __asm__ __volatile__ ("" ::: "memory"); - default:; - } -} - -static inline void fence_after(memory_order order) -{ - switch(order) { - case memory_order_acquire: - case memory_order_acq_rel: - case memory_order_seq_cst: - __asm__ __volatile__ ("" ::: "memory"); - default:; - } -} - -static inline void full_fence(void) -{ -#if (defined(__amd64__) || defined(__x86_64__)) - __asm__ __volatile__("mfence" ::: "memory"); -#else - /* could use mfence iff i686, but it does not appear to matter much */ - __asm__ __volatile__("lock; addl $0, (%%esp)" ::: "memory"); -#endif -} - -static inline void fence_after_load(memory_order order) -{ - switch(order) { - case memory_order_seq_cst: - full_fence(); - case memory_order_acquire: - case memory_order_acq_rel: - __asm__ __volatile__ ("" ::: "memory"); - default:; - } -} - -template<> -inline void platform_atomic_thread_fence(memory_order order) -{ - switch(order) { - case memory_order_seq_cst: - full_fence(); - case memory_order_acquire: - case memory_order_consume: - case memory_order_acq_rel: - case memory_order_release: - __asm__ __volatile__ ("" ::: "memory"); - default:; - } -} - -template -class atomic_x86_8 { -public: - explicit atomic_x86_8(T v) : i(v) {} - atomic_x86_8() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v=*reinterpret_cast(&i); - fence_after_load(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - if (order!=memory_order_seq_cst) { - fence_before(order); - *reinterpret_cast(&i)=v; - } else { - exchange(v); - } - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - fence_before(success_order); - T prev=expected; - __asm__ __volatile__("lock; cmpxchgb %1, %2\n" : "=a" (prev) : "q" (desired), "m" (i), "a" (expected) : "memory"); - bool success=(prev==expected); - if (success) fence_after(success_order); - else fence_after(failure_order); - expected=prev; - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - T exchange(T r, memory_order order=memory_order_seq_cst) volatile - { - __asm__ __volatile__("xchgb %0, %1\n" : "=q" (r) : "m"(i), "0" (r) : "memory"); - return r; - } - T fetch_add(T c, memory_order order=memory_order_seq_cst) volatile - { - __asm__ __volatile__("lock; xaddb %0, %1" : "+q" (c), "+m" (i) :: "memory"); - return c; - } - - bool is_lock_free(void) const volatile {return true;} -protected: - typedef T integral_type; -private: - T i; -}; - -template -class platform_atomic_integral : public build_atomic_from_add > { -public: - typedef build_atomic_from_add > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class atomic_x86_16 { -public: - explicit atomic_x86_16(T v) : i(v) {} - atomic_x86_16() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v=*reinterpret_cast(&i); - fence_after_load(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - if (order!=memory_order_seq_cst) { - fence_before(order); - *reinterpret_cast(&i)=v; - } else { - exchange(v); - } - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - fence_before(success_order); - T prev=expected; - __asm__ __volatile__("lock; cmpxchgw %1, %2\n" : "=a" (prev) : "q" (desired), "m" (i), "a" (expected) : "memory"); - bool success=(prev==expected); - if (success) fence_after(success_order); - else fence_after(failure_order); - expected=prev; - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - T exchange(T r, memory_order order=memory_order_seq_cst) volatile - { - __asm__ __volatile__("xchgw %0, %1\n" : "=r" (r) : "m"(i), "0" (r) : "memory"); - return r; - } - T fetch_add(T c, memory_order order=memory_order_seq_cst) volatile - { - __asm__ __volatile__("lock; xaddw %0, %1" : "+r" (c), "+m" (i) :: "memory"); - return c; - } - - bool is_lock_free(void) const volatile {return true;} -protected: - typedef T integral_type; -private: - T i; -}; - -template -class platform_atomic_integral : public build_atomic_from_add > { -public: - typedef build_atomic_from_add > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class atomic_x86_32 { -public: - explicit atomic_x86_32(T v) : i(v) {} - atomic_x86_32() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v=*reinterpret_cast(&i); - fence_after_load(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - if (order!=memory_order_seq_cst) { - fence_before(order); - *reinterpret_cast(&i)=v; - } else { - exchange(v); - } - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - fence_before(success_order); - T prev=expected; - __asm__ __volatile__("lock; cmpxchgl %1, %2\n" : "=a" (prev) : "q" (desired), "m" (i), "a" (expected) : "memory"); - bool success=(prev==expected); - if (success) fence_after(success_order); - else fence_after(failure_order); - expected=prev; - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - T exchange(T r, memory_order order=memory_order_seq_cst) volatile - { - __asm__ __volatile__("xchgl %0, %1\n" : "=r" (r) : "m"(i), "0" (r) : "memory"); - return r; - } - T fetch_add(T c, memory_order order=memory_order_seq_cst) volatile - { - __asm__ __volatile__("lock; xaddl %0, %1" : "+r" (c), "+m" (i) :: "memory"); - return c; - } - - bool is_lock_free(void) const volatile {return true;} -protected: - typedef T integral_type; -private: - T i; -}; - -template -class platform_atomic_integral : public build_atomic_from_add > { -public: - typedef build_atomic_from_add > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -#if (defined(__amd64__) || defined(__x86_64__)) -template -class atomic_x86_64 { -public: - explicit atomic_x86_64(T v) : i(v) {} - atomic_x86_64() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v=*reinterpret_cast(&i); - fence_after_load(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - if (order!=memory_order_seq_cst) { - fence_before(order); - *reinterpret_cast(&i)=v; - } else { - exchange(v); - } - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - fence_before(success_order); - T prev=expected; - __asm__ __volatile__("lock; cmpxchgq %1, %2\n" : "=a" (prev) : "q" (desired), "m" (i), "a" (expected) : "memory"); - bool success=(prev==expected); - if (success) fence_after(success_order); - else fence_after(failure_order); - expected=prev; - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - T exchange(T r, memory_order order=memory_order_seq_cst) volatile - { - __asm__ __volatile__("xchgq %0, %1\n" : "=r" (r) : "m"(i), "0" (r) : "memory"); - return r; - } - T fetch_add(T c, memory_order order=memory_order_seq_cst) volatile - { - __asm__ __volatile__("lock; xaddq %0, %1" : "+r" (c), "+m" (i) :: "memory"); - return c; - } - - bool is_lock_free(void) const volatile {return true;} -protected: - typedef T integral_type; -private: - T i; -} __attribute__((aligned(8))); - -#elif defined(__i686__) - -template -class atomic_x86_64 { -private: - typedef atomic_x86_64 this_type; -public: - explicit atomic_x86_64(T v) : i(v) {} - atomic_x86_64() {} - - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - long scratch; - fence_before(success_order); - T prev=expected; - /* Make sure ebx is saved and restored properly in case - this object is compiled as "position independent". Since - programmers on x86 tend to forget specifying -DPIC or - similar, always assume PIC. - - To make this work uniformly even in the non-PIC case, - setup register constraints such that ebx can not be - used by accident e.g. as base address for the variable - to be modified. Accessing "scratch" should always be okay, - as it can only be placed on the stack (and therefore - accessed through ebp or esp only). - - In theory, could push/pop ebx onto/off the stack, but movs - to a prepared stack slot turn out to be faster. */ - __asm__ __volatile__( - "movl %%ebx, %1\n" - "movl %2, %%ebx\n" - "lock; cmpxchg8b 0(%4)\n" - "movl %1, %%ebx\n" - : "=A" (prev), "=m" (scratch) - : "D" ((long)desired), "c" ((long)(desired>>32)), "S" (&i), "0" (prev) - : "memory"); - bool success=(prev==expected); - if (success) fence_after(success_order); - else fence_after(failure_order); - expected=prev; - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - T exchange(T r, memory_order order=memory_order_seq_cst) volatile - { - T prev=i; - do {} while(!compare_exchange_strong(prev, r, order, memory_order_relaxed)); - return prev; - } - - T load(memory_order order=memory_order_seq_cst) const volatile - { - /* this is a bit problematic -- there is no other - way to atomically load a 64 bit value, but of course - compare_exchange requires write access to the memory - area */ - T expected=i; - do { } while(!const_cast(this)->compare_exchange_strong(expected, expected, order, memory_order_relaxed)); - return expected; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - exchange(v, order); - } - T fetch_add(T c, memory_order order=memory_order_seq_cst) volatile - { - T expected=i, desired;; - do { - desired=expected+c; - } while(!compare_exchange_strong(expected, desired, order, memory_order_relaxed)); - return expected; - } - - bool is_lock_free(void) const volatile {return true;} -protected: - typedef T integral_type; -private: - T i; -} __attribute__((aligned(8))) ; - -#endif - -#if (defined(__amd64__) || defined(__x86_64__)) || defined(__i686__) -template -class platform_atomic_integral : public build_atomic_from_add >{ -public: - typedef build_atomic_from_add > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; -#endif - -// TODO: only use the sync intrinsics as a fallback, prefer inline asm as it -// allows us to do relaxed memory ordering. -#if (defined(__amd64__) || defined(__x86_64__)) && \ - defined(BOOST_ATOMIC_HAVE_SSE2) && \ - defined(BOOST_ATOMIC_HAVE_GNU_SYNC_16) && \ - defined(BOOST_ATOMIC_HAVE_GNU_ALIGNED_16) -template -class atomic_x86_128 { -public: - explicit atomic_x86_128(T v) : i(v) {} - atomic_x86_128() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v; - __asm__ __volatile__ ( - "movdqa %1, %%xmm0 ;\n" - "movdqa %%xmm0, %0 ;\n" - : "=m" (v) - : "m" (i) - : "xmm0", "memory" - ); - fence_after_load(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - fence_before(order); - // Atomically stores 128bit value by SSE instruction movdqa - __asm__ __volatile__ ( - "movdqa %1, %%xmm0 ;\n" - "movdqa %%xmm0, %0 ;\n" - : "=m" (i) - : "m" (v) - : "xmm0", "memory" - ); - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - T prev = __sync_val_compare_and_swap_16 - (reinterpret_cast(&i), expected, desired); - bool success=(prev==expected); - if (success) fence_after(success_order); - else fence_after(failure_order); - expected=prev; - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - T exchange(T r, memory_order order=memory_order_seq_cst) volatile - { - while (!__sync_bool_compare_and_swap_16 - (reinterpret_cast(&i), i, r)) - {}; - - return r; - } - T fetch_add(T c, memory_order order=memory_order_seq_cst) volatile - { - T expected=i, desired; - do { - desired=expected+c; - } while(!compare_exchange_strong(expected, desired, order, memory_order_relaxed)); - return expected; - } - - bool is_lock_free(void) const volatile {return true;} -protected: - typedef T integral_type; -private: - T i; -} __attribute__((aligned(16))); - -template -class platform_atomic_integral : public build_atomic_from_add >{ -public: - typedef build_atomic_from_add > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -#endif - -} -} -} - -#endif diff --git a/vendor/boost_1.51/include/boost/atomic/detail/generic-cas.hpp b/vendor/boost_1.51/include/boost/atomic/detail/generic-cas.hpp deleted file mode 100644 index dc14a8b..0000000 --- a/vendor/boost_1.51/include/boost/atomic/detail/generic-cas.hpp +++ /dev/null @@ -1,192 +0,0 @@ -#ifndef BOOST_DETAIL_ATOMIC_GENERIC_CAS_HPP -#define BOOST_DETAIL_ATOMIC_GENERIC_CAS_HPP - -// Copyright (c) 2009 Helge Bahmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include - -#include -#include -#include - -/* fallback implementation for various compilation targets; -this is *not* efficient, particularly because all operations -are fully fenced (full memory barriers before and after -each operation) */ - -#if defined(__GNUC__) - namespace boost { namespace detail { namespace atomic { - static inline int32_t - fenced_compare_exchange_strong_32(volatile int32_t *ptr, int32_t expected, int32_t desired) - { - return __sync_val_compare_and_swap_4(ptr, expected, desired); - } - #define BOOST_ATOMIC_HAVE_CAS32 1 - - #if (defined(__amd64__) || defined(__x86_64__)) || defined(__i686__) - static inline int64_t - fenced_compare_exchange_strong_64(int64_t *ptr, int64_t expected, int64_t desired) - { - return __sync_val_compare_and_swap_8(ptr, expected, desired); - } - #define BOOST_ATOMIC_HAVE_CAS64 1 - #endif - }}} - -#elif defined(__ICL) || defined(_MSC_VER) - - #if defined(_MSC_VER) - #include - #include - #endif - - namespace boost { namespace detail { namespace atomic { - static inline int32_t - fenced_compare_exchange_strong(int32_t *ptr, int32_t expected, int32_t desired) - { - return _InterlockedCompareExchange(reinterpret_cast(ptr), desired, expected); - } - #define BOOST_ATOMIC_HAVE_CAS32 1 - #if defined(_WIN64) - static inline int64_t - fenced_compare_exchange_strong(int64_t *ptr, int64_t expected, int64_t desired) - { - return _InterlockedCompareExchange64(ptr, desired, expected); - } - #define BOOST_ATOMIC_HAVE_CAS64 1 - #endif - }}} - -#elif (defined(__ICC) || defined(__ECC)) - namespace boost { namespace detail { namespace atomic { - static inline int32_t - fenced_compare_exchange_strong_32(int32_t *ptr, int32_t expected, int32_t desired) - { - return _InterlockedCompareExchange((void*)ptr, desired, expected); - } - #define BOOST_ATOMIC_HAVE_CAS32 1 - #if defined(__x86_64) - static inline int64_t - fenced_compare_exchange_strong(int64_t *ptr, int64_t expected, int64_t desired) - { - return cas64(ptr, expected, desired); - } - #define BOOST_ATOMIC_HAVE_CAS64 1 - #elif defined(__ECC) //IA-64 version - static inline int64_t - fenced_compare_exchange_strong(int64_t *ptr, int64_t expected, int64_t desired) - { - return _InterlockedCompareExchange64((void*)ptr, desired, expected); - } - #define BOOST_ATOMIC_HAVE_CAS64 1 - #endif - }}} - -#elif (defined(__SUNPRO_CC) && defined(__sparc)) - #include - namespace boost { namespace detail { namespace atomic { - static inline int32_t - fenced_compare_exchange_strong_32(int32_t *ptr, int32_t expected, int32_t desired) - { - return atomic_cas_32((volatile unsigned int*)ptr, expected, desired); - } - #define BOOST_ATOMIC_HAVE_CAS32 1 - - /* FIXME: check for 64 bit mode */ - static inline int64_t - fenced_compare_exchange_strong_64(int64_t *ptr, int64_t expected, int64_t desired) - { - return atomic_cas_64((volatile unsigned long long*)ptr, expected, desired); - } - #define BOOST_ATOMIC_HAVE_CAS64 1 - }}} -#endif - - -namespace boost { namespace detail { namespace atomic { - -#ifdef BOOST_ATOMIC_HAVE_CAS32 -template -class atomic_generic_cas32 { -private: - typedef atomic_generic_cas32 this_type; -public: - explicit atomic_generic_cas32(T v) : i((int32_t)v) {} - atomic_generic_cas32() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T expected=(T)i; - do { } while(!const_cast(this)->compare_exchange_weak(expected, expected, order, memory_order_relaxed)); - return expected; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - exchange(v); - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - T found; - found=(T)fenced_compare_exchange_strong_32(&i, (int32_t)expected, (int32_t)desired); - bool success=(found==expected); - expected=found; - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - T exchange(T r, memory_order order=memory_order_seq_cst) volatile - { - T expected=(T)i; - do { } while(!compare_exchange_weak(expected, r, order, memory_order_relaxed)); - return expected; - } - - bool is_lock_free(void) const volatile {return true;} - typedef T integral_type; -private: - mutable int32_t i; -}; - -template -class platform_atomic_integral : public build_atomic_from_exchange > { -public: - typedef build_atomic_from_exchange > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral: public build_atomic_from_larger_type, T> { -public: - typedef build_atomic_from_larger_type, T> super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral: public build_atomic_from_larger_type, T> { -public: - typedef build_atomic_from_larger_type, T> super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; -#endif - -} } } - -#endif diff --git a/vendor/boost_1.51/include/boost/atomic/detail/integral-casts.hpp b/vendor/boost_1.51/include/boost/atomic/detail/integral-casts.hpp deleted file mode 100644 index 2b045d2..0000000 --- a/vendor/boost_1.51/include/boost/atomic/detail/integral-casts.hpp +++ /dev/null @@ -1,465 +0,0 @@ -#ifndef BOOST_DETAIL_ATOMIC_INTEGRAL_CASTS_HPP -#define BOOST_DETAIL_ATOMIC_INTEGRAL_CASTS_HPP - -// Copyright (c) 2009 Helge Bahmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include - -namespace boost { namespace detail { namespace atomic { - -template -class platform_atomic : private platform_atomic_integral { -public: - typedef platform_atomic_integral super; -#if defined(BOOST_ATOMIC_ENFORCE_PODNESS) - typedef union { T e; boost::uint8_t i;} conv; -#endif - - platform_atomic() {} - explicit platform_atomic(T t) : super(to_integral(t)) - { - } - - void store(T t, memory_order order=memory_order_seq_cst) volatile - { - super::store(to_integral(t), order); - } - T load(memory_order order=memory_order_seq_cst) volatile const - { - return from_integral(super::load(order)); - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - boost::uint8_t _expected, _desired; - _expected=to_integral(expected); - _desired=to_integral(desired); - bool success=super::compare_exchange_strong(_expected, _desired, success_order, failure_order); - expected=from_integral(_expected); - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - boost::uint8_t _expected, _desired; - _expected=to_integral(expected); - _desired=to_integral(desired); - bool success=super::compare_exchange_weak(_expected, _desired, success_order, failure_order); - expected=from_integral(_expected); - return success; - } - - T exchange(T replacement, memory_order order=memory_order_seq_cst) volatile - { - return from_integral(super::exchange(to_integral(replacement), order)); - } - - operator T(void) const volatile {return load();} - T operator=(T v) volatile {store(v); return v;} - - using super::is_lock_free; -protected: - static inline boost::uint8_t to_integral(T &t) - { - boost::uint8_t tmp; - memcpy(&tmp, &t, sizeof(t)); - return tmp; - } - static inline T from_integral(boost::uint8_t t) - { - T tmp; - memcpy(&tmp, &t, sizeof(t)); - return tmp; - } -}; - -template -class platform_atomic : private platform_atomic_integral { -public: - typedef platform_atomic_integral super; -#if defined(BOOST_ATOMIC_ENFORCE_PODNESS) - typedef union { T e; boost::uint16_t i;} conv; -#endif - - platform_atomic() {} - explicit platform_atomic(T t) : super(to_integral(t)) - { - } - - void store(T t, memory_order order=memory_order_seq_cst) volatile - { - super::store(to_integral(t), order); - } - T load(memory_order order=memory_order_seq_cst) volatile const - { - return from_integral(super::load(order)); - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - boost::uint16_t _expected, _desired; - _expected=to_integral(expected); - _desired=to_integral(desired); - bool success=super::compare_exchange_strong(_expected, _desired, success_order, failure_order); - expected=from_integral(_expected); - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - boost::uint16_t _expected, _desired; - _expected=to_integral(expected); - _desired=to_integral(desired); - bool success=super::compare_exchange_weak(_expected, _desired, success_order, failure_order); - expected=from_integral(_expected); - return success; - } - - T exchange(T replacement, memory_order order=memory_order_seq_cst) volatile - { - return from_integral(super::exchange(to_integral(replacement), order)); - } - - operator T(void) const volatile {return load();} - T operator=(T v) volatile {store(v); return v;} - - using super::is_lock_free; -protected: - static inline boost::uint16_t to_integral(T &t) - { - boost::uint16_t tmp; - memcpy(&tmp, &t, sizeof(t)); - return tmp; - } - static inline T from_integral(boost::uint16_t t) - { - T tmp; - memcpy(&tmp, &t, sizeof(t)); - return tmp; - } -}; - -template -class platform_atomic : private platform_atomic_integral { -public: - typedef platform_atomic_integral super; -#if defined(BOOST_ATOMIC_ENFORCE_PODNESS) - typedef union { T e; boost::uint32_t i;} conv; -#endif - - platform_atomic() {} - explicit platform_atomic(T t) : super(to_integral(t)) - { - } - - void store(T t, memory_order order=memory_order_seq_cst) volatile - { - super::store(to_integral(t), order); - } - T load(memory_order order=memory_order_seq_cst) volatile const - { - return from_integral(super::load(order)); - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - boost::uint32_t _expected, _desired; - _expected=to_integral(expected); - _desired=to_integral(desired); - bool success=super::compare_exchange_strong(_expected, _desired, success_order, failure_order); - expected=from_integral(_expected); - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - boost::uint32_t _expected, _desired; - _expected=to_integral(expected); - _desired=to_integral(desired); - bool success=super::compare_exchange_weak(_expected, _desired, success_order, failure_order); - expected=from_integral(_expected); - return success; - } - - T exchange(T replacement, memory_order order=memory_order_seq_cst) volatile - { - return from_integral(super::exchange(to_integral(replacement), order)); - } - - operator T(void) const volatile {return load();} - T operator=(T v) volatile {store(v); return v;} - - using super::is_lock_free; -protected: - static inline boost::uint32_t to_integral(T &t) - { - boost::uint32_t tmp; - memcpy(&tmp, &t, sizeof(t)); - return tmp; - } - static inline T from_integral(boost::uint32_t t) - { - T tmp; - memcpy(&tmp, &t, sizeof(t)); - return tmp; - } -}; - -template -class platform_atomic : private platform_atomic_integral { -public: - typedef platform_atomic_integral super; -#if defined(BOOST_ATOMIC_ENFORCE_PODNESS) - typedef union { T e; boost::uint64_t i;} conv; -#endif - - platform_atomic() {} - explicit platform_atomic(T t) : super(to_integral(t)) - { - } - - void store(T t, memory_order order=memory_order_seq_cst) volatile - { - super::store(to_integral(t), order); - } - T load(memory_order order=memory_order_seq_cst) volatile const - { - return from_integral(super::load(order)); - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - boost::uint64_t _expected, _desired; - _expected=to_integral(expected); - _desired=to_integral(desired); - bool success=super::compare_exchange_strong(_expected, _desired, success_order, failure_order); - expected=from_integral(_expected); - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - boost::uint64_t _expected, _desired; - _expected=to_integral(expected); - _desired=to_integral(desired); - bool success=super::compare_exchange_weak(_expected, _desired, success_order, failure_order); - expected=from_integral(_expected); - return success; - } - - T exchange(T replacement, memory_order order=memory_order_seq_cst) volatile - { - return from_integral(super::exchange(to_integral(replacement), order)); - } - - operator T(void) const volatile {return load();} - T operator=(T v) volatile {store(v); return v;} - - using super::is_lock_free; -protected: - static inline boost::uint64_t to_integral(T &t) - { - boost::uint64_t tmp; - memcpy(&tmp, &t, sizeof(t)); - return tmp; - } - static inline T from_integral(boost::uint64_t t) - { - T tmp; - memcpy(&tmp, &t, sizeof(t)); - return tmp; - } -}; - -#if (defined(__amd64__) || defined(__x86_64__)) && \ - defined(BOOST_ATOMIC_HAVE_SSE2) && \ - defined(BOOST_ATOMIC_HAVE_GNU_SYNC_16) && \ - defined(BOOST_ATOMIC_HAVE_GNU_ALIGNED_16) && \ - defined(BOOST_ATOMIC_HAVE_GNU_128BIT_INTEGERS) - -#define BOOST_ATOMIC_HAVE_128BIT_SUPPORT - -template -class platform_atomic : private platform_atomic_integral<__uint128_t> { -public: - typedef platform_atomic_integral<__uint128_t> super; -#if defined(BOOST_ATOMIC_ENFORCE_PODNESS) - typedef union { T e; __uint128_t i;} conv; -#endif - - platform_atomic() {} - explicit platform_atomic(T t) : super(to_integral(t)) - { - } - - void store(T t, memory_order order=memory_order_seq_cst) volatile - { - super::store(to_integral(t), order); - } - T load(memory_order order=memory_order_seq_cst) volatile const - { - return from_integral(super::load(order)); - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - __uint128_t _expected, _desired; - _expected=to_integral(expected); - _desired=to_integral(desired); - bool success=super::compare_exchange_strong(_expected, _desired, success_order, failure_order); - expected=from_integral(_expected); - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - __uint128_t _expected, _desired; - _expected=to_integral(expected); - _desired=to_integral(desired); - bool success=super::compare_exchange_weak(_expected, _desired, success_order, failure_order); - expected=from_integral(_expected); - return success; - } - - T exchange(T replacement, memory_order order=memory_order_seq_cst) volatile - { - return from_integral(super::exchange(to_integral(replacement), order)); - } - - operator T(void) const volatile {return load();} - T operator=(T v) volatile {store(v); return v;} - - using super::is_lock_free; -protected: - static inline __uint128_t to_integral(T &t) - { - __uint128_t tmp; - memcpy(&tmp, &t, sizeof(t)); - return tmp; - } - static inline T from_integral(__uint128_t t) - { - T tmp; - memcpy(&tmp, &t, sizeof(t)); - return tmp; - } -}; - -#elif BOOST_MSVC >= 1500 && (defined(_M_IA64) || defined(_M_AMD64)) && defined(BOOST_ATOMIC_HAVE_SSE2) - -#define BOOST_ATOMIC_HAVE_128BIT_SUPPORT - -#include - -template -class platform_atomic : private platform_atomic_integral<__m128i> { -public: - typedef platform_atomic_integral<__m128i> super; -#if defined(BOOST_ATOMIC_ENFORCE_PODNESS) - typedef union { T e; __m128i i;} conv; -#endif - - platform_atomic() {} - explicit platform_atomic(T t) : super(to_integral(t)) - { - } - - void store(T t, memory_order order=memory_order_seq_cst) volatile - { - super::store(to_integral(t), order); - } - T load(memory_order order=memory_order_seq_cst) volatile const - { - return from_integral(super::load(order)); - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - __m128i _expected, _desired; - _expected=to_integral(expected); - _desired=to_integral(desired); - bool success=super::compare_exchange_strong(_expected, _desired, success_order, failure_order); - expected=from_integral(_expected); - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - __m128i _expected, _desired; - _expected=to_integral(expected); - _desired=to_integral(desired); - bool success=super::compare_exchange_weak(_expected, _desired, success_order, failure_order); - expected=from_integral(_expected); - return success; - } - - T exchange(T replacement, memory_order order=memory_order_seq_cst) volatile - { - return from_integral(super::exchange(to_integral(replacement), order)); - } - - operator T(void) const volatile {return load();} - T operator=(T v) volatile {store(v); return v;} - - using super::is_lock_free; -protected: - static inline __m128i to_integral(T &t) - { - __m128i tmp; - memcpy(&tmp, &t, sizeof(t)); - return tmp; - } - static inline T from_integral(__m128i t) - { - T tmp; - memcpy(&tmp, &t, sizeof(t)); - return tmp; - } -}; - -#endif - -} } } - -#endif diff --git a/vendor/boost_1.51/include/boost/atomic/detail/interlocked.hpp b/vendor/boost_1.51/include/boost/atomic/detail/interlocked.hpp deleted file mode 100644 index dcb8502..0000000 --- a/vendor/boost_1.51/include/boost/atomic/detail/interlocked.hpp +++ /dev/null @@ -1,365 +0,0 @@ -#ifndef BOOST_DETAIL_ATOMIC_INTERLOCKED_HPP -#define BOOST_DETAIL_ATOMIC_INTERLOCKED_HPP - -// Copyright (c) 2009 Helge Bahmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include - -#include -#include - -namespace boost { -namespace detail { -namespace atomic { - -static inline void full_fence(void) -{ - long tmp; - BOOST_INTERLOCKED_EXCHANGE(&tmp, 0); -} - -template<> -inline void platform_atomic_thread_fence(memory_order order) -{ - switch(order) { - case memory_order_seq_cst: - full_fence(); - default:; - } -} - -static inline void fence_after_load(memory_order order) -{ - switch(order) { - case memory_order_seq_cst: - full_fence(); - case memory_order_acquire: - case memory_order_acq_rel: - default:; - } -} - - -template -class atomic_interlocked_32 { -public: - explicit atomic_interlocked_32(T v) : i(v) {} - atomic_interlocked_32() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v=*reinterpret_cast(&i); - fence_after_load(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - if (order!=memory_order_seq_cst) { - *reinterpret_cast(&i)=v; - } else { - exchange(v); - } - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - T prev=expected; - expected=(T)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long *)(&i), (long)desired, (long)expected); - bool success=(prev==expected); - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - T exchange(T r, memory_order order=memory_order_seq_cst) volatile - { - return (T)BOOST_INTERLOCKED_EXCHANGE((long *)&i, (long)r); - } - T fetch_add(T c, memory_order order=memory_order_seq_cst) volatile - { - return (T)BOOST_INTERLOCKED_EXCHANGE_ADD((long *)&i, c); - } - - bool is_lock_free(void) const volatile {return true;} - - typedef T integral_type; -private: - T i; -}; - -# if defined(_M_IA64) || defined(_M_AMD64) - -#if defined( BOOST_USE_WINDOWS_H ) - -# include - -# define BOOST_INTERLOCKED_EXCHANGE_ADD64 InterlockedExchangeAdd64 -# define BOOST_INTERLOCKED_EXCHANGE64 InterlockedExchange64 -# define BOOST_INTERLOCKED_COMPARE_EXCHANGE64 InterlockedCompareExchange64 - -#else - -extern "C" boost::int64_t __cdecl _InterlockedExchangeAdd64(boost::int64_t volatile *, boost::int64_t); -extern "C" boost::int64_t __cdecl _InterlockedExchange64(boost::int64_t volatile *, boost::int64_t); -extern "C" boost::int64_t __cdecl _InterlockedCompareExchange64(boost::int64_t volatile *, boost::int64_t, boost::int64_t); - -# pragma intrinsic( _InterlockedExchangeAdd64 ) -# pragma intrinsic( _InterlockedExchange64 ) -# pragma intrinsic( _InterlockedCompareExchange64 ) - -# define BOOST_INTERLOCKED_EXCHANGE_ADD64 _InterlockedExchangeAdd64 -# define BOOST_INTERLOCKED_EXCHANGE64 _InterlockedExchange64 -# define BOOST_INTERLOCKED_COMPARE_EXCHANGE64 _InterlockedCompareExchange64 - -#endif - -template -class __declspec(align(64)) atomic_interlocked_64 { -public: - explicit atomic_interlocked_64(T v) : i(v) {} - atomic_interlocked_64() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v=*reinterpret_cast(&i); - fence_after_load(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - if (order!=memory_order_seq_cst) { - *reinterpret_cast(&i)=v; - } else { - exchange(v); - } - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - T prev=expected; - expected=(T)BOOST_INTERLOCKED_COMPARE_EXCHANGE64((boost::int64_t *)(&i), (boost::int64_t)desired, (boost::int64_t)expected); - bool success=(prev==expected); - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - T exchange(T r, memory_order order=memory_order_seq_cst) volatile - { - return (T)BOOST_INTERLOCKED_EXCHANGE64((boost::int64_t *)&i, (boost::int64_t)r); - } - T fetch_add(T c, memory_order order=memory_order_seq_cst) volatile - { - return (T)BOOST_INTERLOCKED_EXCHANGE_ADD64((boost::int64_t *)&i, c); - } - - bool is_lock_free(void) const volatile {return true;} - - typedef T integral_type; -private: - T i; -}; - -// _InterlockedCompareExchange128 is available only starting with VS2008 -#if BOOST_MSVC >= 1500 && defined(BOOST_ATOMIC_HAVE_SSE2) - -#if defined( BOOST_USE_WINDOWS_H ) - -# include -# include - -# define BOOST_INTERLOCKED_COMPARE_EXCHANGE128 InterlockedCompareExchange128 - -# pragma intrinsic( _mm_load_si128 ) -# pragma intrinsic( _mm_store_si128 ) - -#else - -# include - -extern "C" unsigned char __cdecl _InterlockedCompareExchange128( - boost::int64_t volatile *Destination, - boost::int64_t ExchangeHigh, boost::int64_t ExchangeLow, - boost::int64_t *Comparand) -extern "C" __m128i _mm_load_si128(__m128i const*_P); -extern "C" void _mm_store_si128(__m128i *_P, __m128i _B); - -# pragma intrinsic( _InterlockedCompareExchange128 ) -# pragma intrinsic( _mm_load_si128 ) -# pragma intrinsic( _mm_store_si128 ) - -# define BOOST_INTERLOCKED_COMPARE_EXCHANGE128 _InterlockedCompareExchange128 - -#endif - -template -class __declspec(align(128)) atomic_interlocked_128 { -public: - explicit atomic_interlocked_128(T v) : i(v) {} - atomic_interlocked_128() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v; - if (order!=memory_order_seq_cst) { - v = _mm_load_si128(*(__m128i*)(&i)); - } - else { - v = *reinterpret_cast(&i); - } - fence_after_load(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - if (order!=memory_order_seq_cst) { - *reinterpret_cast(&i)=v; - } - else { - _mm_store_si128(*(__m128i*)(&i), v); - } - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - boost::int64_t* desired_raw = &desired; - T prev = i; - bool success = BOOST_INTERLOCKED_COMPARE_EXCHANGE128( - (boost::int64_t volatile *)(&i), - desired_raw[1], desired_raw[0], (boost::int64_t*)&expected); - if (!success) - expected = prev; - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - T exchange(T r, memory_order order=memory_order_seq_cst) volatile - { - boost::int64_t* desired_raw = &r; - T prev = i; - - while (!BOOST_INTERLOCKED_COMPARE_EXCHANGE128( - (boost::int64_t volatile*)&i, desired_raw[1], desired_raw[0], - (boost::int64_t*)&i)) - {} - - return prev; - } - T fetch_add(T c, memory_order order=memory_order_seq_cst) volatile - { - T expected = i; - __m128i desired; - - do { - desired = _mm_add_epi32(*(__m128i*)(&expected), *(__m128i*)(&c)); - } while (!compare_exchange_strong(expected, *(T*)(&desired), order, memory_order_relaxed)); - - return expected; - } - - bool is_lock_free(void) const volatile {return true;} - - typedef T integral_type; -private: - T i; -}; -#endif - -#endif - -template -class platform_atomic_integral : public build_atomic_from_add > { -public: - typedef build_atomic_from_add > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral: public build_atomic_from_larger_type, T> { -public: - typedef build_atomic_from_larger_type, T> super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral: public build_atomic_from_larger_type, T> { -public: - typedef build_atomic_from_larger_type, T> super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -# if defined(_M_IA64) || defined(_M_AMD64) -template -class platform_atomic_integral - : public build_atomic_from_add > -{ -public: - typedef build_atomic_from_add > super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template<> -class platform_atomic_integral - : public build_atomic_from_add > -{ -public: - typedef build_atomic_from_add > super; - - explicit platform_atomic_integral(void* v) : super(v) {} - platform_atomic_integral(void) {} -}; - -#if BOOST_MSVC >= 1500 && defined(BOOST_ATOMIC_HAVE_SSE2) - -template -class platform_atomic_integral - : public build_atomic_from_add > -{ -public: - typedef build_atomic_from_add > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -#endif - -#endif - -} -} -} - -#endif diff --git a/vendor/boost_1.51/include/boost/atomic/detail/linux-arm.hpp b/vendor/boost_1.51/include/boost/atomic/detail/linux-arm.hpp deleted file mode 100644 index 142c20a..0000000 --- a/vendor/boost_1.51/include/boost/atomic/detail/linux-arm.hpp +++ /dev/null @@ -1,171 +0,0 @@ -#ifndef BOOST_DETAIL_ATOMIC_LINUX_ARM_HPP -#define BOOST_DETAIL_ATOMIC_LINUX_ARM_HPP - -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// Copyright (c) 2009 Helge Bahmann -// Copyright (c) 2009 Phil Endecott -// ARM Code by Phil Endecott, based on other architectures. - -#include -#include -#include - -namespace boost { -namespace detail { -namespace atomic { - - -// Different ARM processors have different atomic instructions. In particular, -// architecture versions before v6 (which are still in widespread use, e.g. the -// Intel/Marvell XScale chips like the one in the NSLU2) have only atomic swap. -// On Linux the kernel provides some support that lets us abstract away from -// these differences: it provides emulated CAS and barrier functions at special -// addresses that are garaunteed not to be interrupted by the kernel. Using -// this facility is slightly slower than inline assembler would be, but much -// faster than a system call. -// -// For documentation, see arch/arm/kernel/entry-armv.S in the kernel source -// (search for "User Helpers"). - - -typedef void (kernel_dmb_t)(void); -#define BOOST_ATOMIC_KERNEL_DMB (*(kernel_dmb_t *)0xffff0fa0) - -static inline void fence_before(memory_order order) -{ - switch(order) { - // FIXME I really don't know which of these cases should call - // kernel_dmb() and which shouldn't... - case memory_order_consume: - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - BOOST_ATOMIC_KERNEL_DMB(); - default:; - } -} - -static inline void fence_after(memory_order order) -{ - switch(order) { - // FIXME I really don't know which of these cases should call - // kernel_dmb() and which shouldn't... - case memory_order_acquire: - case memory_order_acq_rel: - case memory_order_seq_cst: - BOOST_ATOMIC_KERNEL_DMB(); - default:; - } -} - -#undef BOOST_ATOMIC_KERNEL_DMB - - -template -class atomic_linux_arm_4 { - -// typedef int (kernel_cmpxchg_t)(T oldval, T newval, T *ptr); - typedef int (kernel_cmpxchg_t)(T oldval, T newval, volatile T *ptr); -# define BOOST_ATOMIC_KERNEL_CMPXCHG (*(kernel_cmpxchg_t *)0xffff0fc0) - // Returns 0 if *ptr was changed. - -public: - explicit atomic_linux_arm_4(T v) : i(v) {} - atomic_linux_arm_4() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v=const_cast(i); - fence_after(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - fence_before(order); - const_cast(i)=v; - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - // Aparently we can consider kernel_cmpxchg to be strong if it is retried - // by the kernel after being interrupted, which I think it is. - // Also it seems that when an ll/sc implementation is used the kernel - // loops until the store succeeds. - bool success = BOOST_ATOMIC_KERNEL_CMPXCHG(expected,desired,&i)==0; - if (!success) expected = load(memory_order_relaxed); - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - T exchange(T replacement, memory_order order=memory_order_seq_cst) volatile - { - // Copied from build_exchange. - T o=load(memory_order_relaxed); - do {} while(!compare_exchange_weak(o, replacement, order, order)); - return o; - // Note that ARM has an atomic swap instruction that we could use here: - // T oldval; - // asm volatile ("swp\t%0, %1, [%2]" : "=&r"(oldval) : "r" (replacement), "r" (&i) : "memory"); - // return oldval; - // This instruction is deprecated in architecture >= 6. I'm unsure how inefficient - // its implementation is on those newer architectures. - // I don't think this would gain - // much since exchange() is not used often. - } - - bool is_lock_free(void) const volatile {return true;} - typedef T integral_type; -protected: -private: - T i; - -# undef BOOST_ATOMIC_KERNEL_CMPXCHG - -}; - -template -class platform_atomic_integral : public build_atomic_from_exchange > { -public: - typedef build_atomic_from_exchange > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - - -template -class platform_atomic_integral : public build_atomic_from_larger_type, T > { -public: - typedef build_atomic_from_larger_type, T> super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - - -template -class platform_atomic_integral : public build_atomic_from_larger_type, T > { -public: - typedef build_atomic_from_larger_type, T> super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - - -typedef atomic_linux_arm_4 platform_atomic_address; - - -} -} -} - -#endif diff --git a/vendor/boost_1.51/include/boost/atomic/detail/valid_integral_types.hpp b/vendor/boost_1.51/include/boost/atomic/detail/valid_integral_types.hpp deleted file mode 100644 index b091c9f..0000000 --- a/vendor/boost_1.51/include/boost/atomic/detail/valid_integral_types.hpp +++ /dev/null @@ -1,45 +0,0 @@ -#ifndef BOOST_DETAIL_ATOMIC_VALID_INTEGRAL_TYPES_HPP -#define BOOST_DETAIL_ATOMIC_VALID_INTEGRAL_TYPES_HPP - -// Copyright (c) 2009 Helge Bahmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include - -namespace boost { -namespace detail { -namespace atomic { - -template struct is_integral_type {typedef void test;}; - -template<> struct is_integral_type {typedef int test;}; - -template<> struct is_integral_type {typedef int test;}; -template<> struct is_integral_type {typedef int test;}; -template<> struct is_integral_type {typedef int test;}; -template<> struct is_integral_type {typedef int test;}; -template<> struct is_integral_type {typedef int test;}; -template<> struct is_integral_type {typedef int test;}; -template<> struct is_integral_type {typedef int test;}; -template<> struct is_integral_type {typedef int test;}; -#ifdef BOOST_HAS_LONG_LONG -template<> struct is_integral_type {typedef int test;}; -template<> struct is_integral_type {typedef int test;}; -#endif -#ifdef BOOST_ATOMIC_HAVE_GNU_128BIT_INTEGERS -template<> struct is_integral_type<__uint128_t> {typedef int test;}; -template<> struct is_integral_type<__int128_t> {typedef int test;}; -#endif -#if BOOST_MSVC >= 1500 && (defined(_M_IA64) || defined(_M_AMD64)) && defined(BOOST_ATOMIC_HAVE_SSE2) -#include -template<> struct is_integral_type<__m128i> {typedef int test;}; -#endif -} -} -} - -#endif diff --git a/vendor/boost_1.51/include/boost/atomic/platform.hpp b/vendor/boost_1.51/include/boost/atomic/platform.hpp deleted file mode 100644 index 0cdfb56..0000000 --- a/vendor/boost_1.51/include/boost/atomic/platform.hpp +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright (c) 2009 Helge Bahmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include - -#if defined(__GNUC__) && (defined(__i386__) || defined(__amd64__) || defined(__x86_64__)) - - #include - -#elif defined(__GNUC__) && defined(__alpha__) - - #include - -#elif defined(__GNUC__) && (defined(__POWERPC__) || defined(__PPC__)) - - #include - -// This list of ARM architecture versions comes from Apple's arm/arch.h header. -// I don't know how complete it is. -#elif defined(__GNUC__) && (defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) \ - || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) \ - || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_7A__)) - - #include - -#elif defined(__linux__) && defined(__arm__) - - #include - -#elif defined(BOOST_USE_WINDOWS_H) || defined(_WIN32_CE) || defined(BOOST_MSVC) || defined(BOOST_INTEL_WIN) || defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) - - #include - -#else - - #warning "Using slow fallback atomic implementation" - #include - -#endif diff --git a/vendor/boost_1.51/include/boost/context/all.hpp b/vendor/boost_1.51/include/boost/context/all.hpp deleted file mode 100644 index f9a4c71..0000000 --- a/vendor/boost_1.51/include/boost/context/all.hpp +++ /dev/null @@ -1,14 +0,0 @@ - -// Copyright Oliver Kowalke 2009. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_CTX_ALL_H -#define BOOST_CTX_ALL_H - -#include -#include -#include - -#endif // BOOST_CTX_ALL_H diff --git a/vendor/boost_1.51/include/boost/context/detail/config.hpp b/vendor/boost_1.51/include/boost/context/detail/config.hpp deleted file mode 100644 index 50ada3c..0000000 --- a/vendor/boost_1.51/include/boost/context/detail/config.hpp +++ /dev/null @@ -1,42 +0,0 @@ - -// Copyright Oliver Kowalke 2009. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_CTX_DETAIL_CONFIG_H -#define BOOST_CTX_DETAIL_CONFIG_H - -#include -#include - -#ifdef BOOST_CONTEXT_DECL -# undef BOOST_CONTEXT_DECL -#endif - -#if defined(BOOST_HAS_DECLSPEC) -# if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_CONTEXT_DYN_LINK) -# if ! defined(BOOST_DYN_LINK) -# define BOOST_DYN_LINK -# endif -# if defined(BOOST_CONTEXT_SOURCE) -# define BOOST_CONTEXT_DECL BOOST_SYMBOL_EXPORT -# else -# define BOOST_CONTEXT_DECL BOOST_SYMBOL_IMPORT -# endif -# endif -#endif - -#if ! defined(BOOST_CONTEXT_DECL) -# define BOOST_CONTEXT_DECL -#endif - -#if ! defined(BOOST_CONTEXT_SOURCE) && ! defined(BOOST_ALL_NO_LIB) && ! defined(BOOST_CONTEXT_NO_LIB) -# define BOOST_LIB_NAME boost_context -# if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_CONTEXT_DYN_LINK) -# define BOOST_DYN_LINK -# endif -# include -#endif - -#endif // BOOST_CTX_DETAIL_CONFIG_H diff --git a/vendor/boost_1.51/include/boost/context/detail/fcontext_arm.hpp b/vendor/boost_1.51/include/boost/context/detail/fcontext_arm.hpp deleted file mode 100644 index b4ed2fa..0000000 --- a/vendor/boost_1.51/include/boost/context/detail/fcontext_arm.hpp +++ /dev/null @@ -1,66 +0,0 @@ - -// Copyright Oliver Kowalke 2009. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_CTX_DETAIL_FCONTEXT_ARM_H -#define BOOST_CTX_DETAIL_FCONTEXT_ARM_H - -#include -#include - -#include - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_PREFIX -#endif - -namespace boost { -namespace ctx { - -extern "C" { - -#define BOOST_CONTEXT_CALLDECL - -struct stack_t -{ - void * base; - void * limit; - - stack_t() : - base( 0), limit( 0) - {} -}; - -struct fp_t -{ - boost::uint32_t fc_freg[16]; - - fp_t() : - fc_freg() - {} -}; - -struct fcontext_t -{ - boost::uint32_t fc_greg[11]; - stack_t fc_stack; - fp_t fc_fp; - - fcontext_t() : - fc_greg(), - fc_stack(), - fc_fp() - {} -}; - -} - -}} - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_SUFFIX -#endif - -#endif // BOOST_CTX_DETAIL_FCONTEXT_ARM_H diff --git a/vendor/boost_1.51/include/boost/context/detail/fcontext_i386.hpp b/vendor/boost_1.51/include/boost/context/detail/fcontext_i386.hpp deleted file mode 100644 index 573a22c..0000000 --- a/vendor/boost_1.51/include/boost/context/detail/fcontext_i386.hpp +++ /dev/null @@ -1,68 +0,0 @@ - -// Copyright Oliver Kowalke 2009. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_CTX_DETAIL_FCONTEXT_I386H -#define BOOST_CTX_DETAIL_FCONTEXT_I386H - -#include - -#include -#include - -#include - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_PREFIX -#endif - -namespace boost { -namespace ctx { - -extern "C" { - -#define BOOST_CONTEXT_CALLDECL __attribute__((cdecl)) - -struct stack_t -{ - void * base; - void * limit; - - stack_t() : - base( 0), limit( 0) - {} -}; - -struct fp_t -{ - boost::uint32_t fc_freg[2]; - - fp_t() : - fc_freg() - {} -}; - -struct fcontext_t -{ - boost::uint32_t fc_greg[6]; - stack_t fc_stack; - fp_t fc_fp; - - fcontext_t() : - fc_greg(), - fc_stack(), - fc_fp() - {} -}; - -} - -}} - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_SUFFIX -#endif - -#endif // BOOST_CTX_DETAIL_FCONTEXT_I386_H diff --git a/vendor/boost_1.51/include/boost/context/detail/fcontext_i386_win.hpp b/vendor/boost_1.51/include/boost/context/detail/fcontext_i386_win.hpp deleted file mode 100644 index e250ec5..0000000 --- a/vendor/boost_1.51/include/boost/context/detail/fcontext_i386_win.hpp +++ /dev/null @@ -1,83 +0,0 @@ - -// Copyright Oliver Kowalke 2009. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_CTX_DETAIL_FCONTEXT_I386H -#define BOOST_CTX_DETAIL_FCONTEXT_I386H - -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once -#endif - -#include -#include - -#include - -#if defined(BOOST_MSVC) -#pragma warning(push) -#pragma warning(disable:4351) -#endif - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_PREFIX -#endif - -namespace boost { -namespace ctx { - -extern "C" { - -#define BOOST_CONTEXT_CALLDECL __cdecl - -struct stack_t -{ - void * base; - void * limit; - - stack_t() : - base( 0), limit( 0) - {} -}; - -struct fp_t -{ - boost::uint32_t fc_freg[2]; - - fp_t() : - fc_freg() - {} -}; - -struct fcontext_t -{ - boost::uint32_t fc_greg[6]; - stack_t fc_stack; - void * fc_excpt_lst; - void * fc_local_storage; - fp_t fc_fp; - - fcontext_t() : - fc_greg(), - fc_stack(), - fc_excpt_lst( 0), - fc_local_storage( 0), - fc_fp() - {} -}; - -} - -}} - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_SUFFIX -#endif - -#if defined(BOOST_MSVC) -#pragma warning(pop) -#endif - -#endif // BOOST_CTX_DETAIL_FCONTEXT_I386_H diff --git a/vendor/boost_1.51/include/boost/context/detail/fcontext_mips.hpp b/vendor/boost_1.51/include/boost/context/detail/fcontext_mips.hpp deleted file mode 100644 index 1645adf..0000000 --- a/vendor/boost_1.51/include/boost/context/detail/fcontext_mips.hpp +++ /dev/null @@ -1,68 +0,0 @@ - -// Copyright Oliver Kowalke 2009. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_CTX_DETAIL_FCONTEXT_MIPS_H -#define BOOST_CTX_DETAIL_FCONTEXT_MIPS_H - -#include -#include - -#include - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_PREFIX -#endif - -namespace boost { -namespace ctx { - -extern "C" { - -#define BOOST_CONTEXT_CALLDECL - -// on MIPS we assume 64bit regsiters - even for 32bit ABIs - -struct stack_t -{ - void * base; - void * limit; - - stack_t() : - base( 0), limit( 0) - {} -}; - -struct fp_t -{ - boost::uint64_t fc_freg[6]; - - fp_t() : - fc_freg() - {} -}; - -struct fcontext_t -{ - boost::uint64_t fc_greg[13]; - stack_t fc_stack; - fp_t fc_fp; - - fcontext_t() : - fc_greg(), - fc_stack(), - fc_fp() - {} -}; - -} - -}} - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_SUFFIX -#endif - -#endif // BOOST_CTX_DETAIL_FCONTEXT_MIPS_H diff --git a/vendor/boost_1.51/include/boost/context/detail/fcontext_ppc.hpp b/vendor/boost_1.51/include/boost/context/detail/fcontext_ppc.hpp deleted file mode 100644 index 5e6c64c..0000000 --- a/vendor/boost_1.51/include/boost/context/detail/fcontext_ppc.hpp +++ /dev/null @@ -1,70 +0,0 @@ - -// Copyright Oliver Kowalke 2009. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_CTX_DETAIL_FCONTEXT_PPC_H -#define BOOST_CTX_DETAIL_FCONTEXT_PPC_H - -#include -#include - -#include - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_PREFIX -#endif - -namespace boost { -namespace ctx { - -extern "C" { - -#define BOOST_CONTEXT_CALLDECL - -struct stack_t -{ - void * base; - void * limit; - - stack_t() : - base( 0), limit( 0) - {} -}; - -struct fp_t -{ - boost::uint64_t fc_freg[19]; - - fp_t() : - fc_freg() - {} -}; - -struct fcontext_t -{ -# if defined(__powerpc64__) - boost::uint64_t fc_greg[23]; -# else - boost::uint32_t fc_greg[23]; -# endif - stack_t fc_stack; - fp_t fc_fp; - - fcontext_t() : - fc_greg(), - fc_stack(), - fc_fp() - {} -}; - -} - -}} - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_SUFFIX -#endif - -#endif // BOOST_CTX_DETAIL_FCONTEXT_PPC_H diff --git a/vendor/boost_1.51/include/boost/context/detail/fcontext_x86_64.hpp b/vendor/boost_1.51/include/boost/context/detail/fcontext_x86_64.hpp deleted file mode 100644 index 106ee74..0000000 --- a/vendor/boost_1.51/include/boost/context/detail/fcontext_x86_64.hpp +++ /dev/null @@ -1,66 +0,0 @@ - -// Copyright Oliver Kowalke 2009. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_CTX_DETAIL_FCONTEXT_X86_64_H -#define BOOST_CTX_DETAIL_FCONTEXT_X86_64_H - -#include -#include - -#include - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_PREFIX -#endif - -namespace boost { -namespace ctx { - -extern "C" { - -#define BOOST_CONTEXT_CALLDECL - -struct stack_t -{ - void * base; - void * limit; - - stack_t() : - base( 0), limit( 0) - {} -}; - -struct fp_t -{ - boost::uint32_t fc_freg[2]; - - fp_t() : - fc_freg() - {} -}; - -struct fcontext_t -{ - boost::uint64_t fc_greg[8]; - stack_t fc_stack; - fp_t fc_fp; - - fcontext_t() : - fc_greg(), - fc_stack(), - fc_fp() - {} -}; - -} - -}} - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_SUFFIX -#endif - -#endif // BOOST_CTX_DETAIL_FCONTEXT_X86_64_H diff --git a/vendor/boost_1.51/include/boost/context/detail/fcontext_x86_64_win.hpp b/vendor/boost_1.51/include/boost/context/detail/fcontext_x86_64_win.hpp deleted file mode 100644 index 96f153b..0000000 --- a/vendor/boost_1.51/include/boost/context/detail/fcontext_x86_64_win.hpp +++ /dev/null @@ -1,90 +0,0 @@ - -// Copyright Oliver Kowalke 2009. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_CTX_DETAIL_FCONTEXT_X86_64_H -#define BOOST_CTX_DETAIL_FCONTEXT_X86_64_H - -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -# pragma once -#endif - -#include -#include -#include - -#include - -#if defined(BOOST_MSVC) -#pragma warning(push) -#pragma warning(disable:4351) -#endif - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_PREFIX -#endif - -namespace boost { -namespace ctx { - -extern "C" { - -#define BOOST_CONTEXT_CALLDECL - -struct stack_t -{ - void * base; - void * limit; - - stack_t() : - base( 0), limit( 0) - {} -}; - -struct fp_t -{ - boost::uint32_t fc_freg[2]; - void * fc_xmm; - char fc_buffer[175]; - - fp_t() : - fc_freg(), - fc_xmm( 0), - fc_buffer() - { - fc_xmm = fc_buffer; - if ( 0 != ( ( ( uintptr_t) fc_xmm) & 15) ) - fc_xmm = ( char *) ( ( ( ( uintptr_t) fc_xmm) + 15) & ~0x0F); - } -}; - -struct fcontext_t -{ - boost::uint64_t fc_greg[10]; - stack_t fc_stack; - void * fc_local_storage; - fp_t fc_fp; - - fcontext_t() : - fc_greg(), - fc_stack(), - fc_local_storage( 0), - fc_fp() - {} -}; - -} - -}} - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_SUFFIX -#endif - -#if defined(BOOST_MSVC) -#pragma warning(pop) -#endif - -#endif // BOOST_CTX_DETAIL_FCONTEXT_X86_64_H diff --git a/vendor/boost_1.51/include/boost/context/fcontext.hpp b/vendor/boost_1.51/include/boost/context/fcontext.hpp deleted file mode 100644 index d2cc030..0000000 --- a/vendor/boost_1.51/include/boost/context/fcontext.hpp +++ /dev/null @@ -1,82 +0,0 @@ - -// Copyright Oliver Kowalke 2009. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_CTX_FCONTEXT_H -#define BOOST_CTX_FCONTEXT_H - -#if defined(__PGI) -#include -#endif - -#include -#include - -#include - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_PREFIX -#endif - -// x86_64 -// test x86_64 before i386 because icc might -// define __i686__ for x86_64 too -#if defined(__x86_64__) || defined(__x86_64) \ - || defined(__amd64__) || defined(__amd64) \ - || defined(_M_X64) || defined(_M_AMD64) -# if defined(BOOST_WINDOWS) -# include -# else -# include -# endif -// i386 -#elif defined(i386) || defined(__i386__) || defined(__i386) \ - || defined(__i486__) || defined(__i586__) || defined(__i686__) \ - || defined(__X86__) || defined(_X86_) || defined(__THW_INTEL__) \ - || defined(__I86__) || defined(__INTEL__) || defined(__IA32__) \ - || defined(_M_IX86) || defined(_I86_) -# if defined(BOOST_WINDOWS) -# include -# else -# include -# endif -// arm -#elif defined(__arm__) || defined(__thumb__) || defined(__TARGET_ARCH_ARM) \ - || defined(__TARGET_ARCH_THUMB) || defined(_ARM) -# include -// mips -#elif (defined(__mips) && __mips == 1) || defined(_MIPS_ISA_MIPS1) \ - || defined(_R3000) -# include -// powerpc -#elif defined(__powerpc) || defined(__powerpc__) || defined(__ppc) \ - || defined(__ppc__) || defined(_ARCH_PPC) || defined(__POWERPC__) \ - || defined(__PPCGECKO__) || defined(__PPCBROADWAY) || defined(_XENON) -# include -#else -# error "platform not supported" -#endif - -namespace boost { -namespace ctx { -namespace detail { - -extern "C" BOOST_CONTEXT_DECL void * BOOST_CONTEXT_CALLDECL align_stack( void * vp); - -} - -extern "C" BOOST_CONTEXT_DECL -intptr_t BOOST_CONTEXT_CALLDECL jump_fcontext( fcontext_t * ofc, fcontext_t const* nfc, intptr_t vp, bool preserve_fpu = true); -extern "C" BOOST_CONTEXT_DECL -void BOOST_CONTEXT_CALLDECL make_fcontext( fcontext_t * fc, void (* fn)( intptr_t) ); - -}} - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_SUFFIX -#endif - -#endif // BOOST_CTX_FCONTEXT_H - diff --git a/vendor/boost_1.51/include/boost/context/stack_allocator.hpp b/vendor/boost_1.51/include/boost/context/stack_allocator.hpp deleted file mode 100644 index 0db5015..0000000 --- a/vendor/boost_1.51/include/boost/context/stack_allocator.hpp +++ /dev/null @@ -1,37 +0,0 @@ - -// Copyright Oliver Kowalke 2009. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_CTX_STACK_ALLOCATOR_H -#define BOOST_CTX_STACK_ALLOCATOR_H - -#include - -#include - -#include - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_PREFIX -#endif - -namespace boost { -namespace ctx { - -class BOOST_CONTEXT_DECL stack_allocator -{ -public: - void * allocate( std::size_t) const; - - void deallocate( void *, std::size_t) const; -}; - -}} - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_SUFFIX -#endif - -#endif // BOOST_CTX_STACK_ALLOCATOR_H diff --git a/vendor/boost_1.51/include/boost/context/stack_utils.hpp b/vendor/boost_1.51/include/boost/context/stack_utils.hpp deleted file mode 100644 index ca3ed21..0000000 --- a/vendor/boost_1.51/include/boost/context/stack_utils.hpp +++ /dev/null @@ -1,41 +0,0 @@ - -// Copyright Oliver Kowalke 2009. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#ifndef BOOST_CTX_STACK_UTILS_H -#define BOOST_CTX_STACK_UTILS_H - -#include - -#include - -#include - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_PREFIX -#endif - -namespace boost { -namespace ctx { - -BOOST_CONTEXT_DECL std::size_t default_stacksize(); - -BOOST_CONTEXT_DECL std::size_t minimum_stacksize(); - -BOOST_CONTEXT_DECL std::size_t maximum_stacksize(); - -BOOST_CONTEXT_DECL std::size_t pagesize(); - -BOOST_CONTEXT_DECL std::size_t page_count( std::size_t stacksize); - -BOOST_CONTEXT_DECL bool is_stack_unbound(); - -}} - -#ifdef BOOST_HAS_ABI_HEADERS -# include BOOST_ABI_SUFFIX -#endif - -#endif // BOOST_CTX_STACK_UTILS_H From 1f03f67d1d864a3b9086ff169a5dd5f41ca60625 Mon Sep 17 00:00:00 2001 From: Daniel Larimer Date: Sat, 10 Aug 2013 02:33:15 -0400 Subject: [PATCH 6/6] added new elliptic curve crypto methods --- include/fc/crypto/elliptic.hpp | 1 + src/crypto/elliptic.cpp | 46 +++++++++++++++++++++++++++++++++- 2 files changed, 46 insertions(+), 1 deletion(-) diff --git a/include/fc/crypto/elliptic.hpp b/include/fc/crypto/elliptic.hpp index 58999ce..128cd4e 100644 --- a/include/fc/crypto/elliptic.hpp +++ b/include/fc/crypto/elliptic.hpp @@ -36,6 +36,7 @@ namespace fc { bool valid()const; public_key mult( const fc::sha256& offset ); + public_key add( const fc::sha256& offset )const; public_key( public_key&& pk ); public_key& operator=( public_key&& pk ); diff --git a/src/crypto/elliptic.cpp b/src/crypto/elliptic.cpp index cedad1d..3eb8f26 100644 --- a/src/crypto/elliptic.cpp +++ b/src/crypto/elliptic.cpp @@ -258,6 +258,50 @@ struct ssl_bignum return rtn; } + public_key public_key::add( const fc::sha256& digest )const + { + try { + ec_group group(EC_GROUP_new_by_curve_name(NID_secp256k1)); + bn_ctx ctx(BN_CTX_new()); + + fc::bigint digest_bi( (char*)&digest, sizeof(digest) ); + + ssl_bignum order; + EC_GROUP_get_order(group, order, ctx); + if( digest_bi > fc::bigint(order) ) + { + FC_THROW_EXCEPTION( exception, "digest > group order" ); + } + + + public_key digest_key = private_key::regenerate(digest).get_public_key(); + const EC_POINT* digest_point = EC_KEY_get0_public_key( digest_key.my->_key ); + + // get point from this public key + const EC_POINT* master_pub = EC_KEY_get0_public_key( my->_key ); + + ssl_bignum z; + BN_bin2bn((unsigned char*)&digest, sizeof(digest), z); + + // multiply by digest + ssl_bignum one; + BN_one(one); + + ec_point result(EC_POINT_new(group)); + EC_POINT_add(group, result, digest_point, master_pub, ctx); + + if (EC_POINT_is_at_infinity(group, result)) + { + FC_THROW_EXCEPTION( exception, "point at infinity" ); + } + + + public_key rtn; + rtn.my->_key = EC_KEY_new_by_curve_name( NID_secp256k1 ); + EC_KEY_set_public_key(rtn.my->_key,result); + return rtn; + } FC_RETHROW_EXCEPTIONS( debug, "digest: ${digest}", ("digest",digest) ); + } private_key::private_key() {} @@ -268,8 +312,8 @@ struct ssl_bignum BN_bin2bn((unsigned char*)&offset, sizeof(offset), z); ec_group group(EC_GROUP_new_by_curve_name(NID_secp256k1)); - ssl_bignum order; bn_ctx ctx(BN_CTX_new()); + ssl_bignum order; EC_GROUP_get_order(group, order, ctx); // secexp = (seed + z) % order