WebSVN – Kolibri OS – Path Comparison – / – /contrib/sdk/sources/libstdc++-v3/ Rev 6324 and /contrib/sdk/sources/libstdc++-v3/ Rev 6325

Regard whitespace Rev 6324 → Rev 6325

 /contrib/sdk/sources/libstdc++-v3/ChangeLog
 ,3 → 1,384
+-06-23  Release Manager
+        * GCC 4.8.5 released.
+-06-17  Matthias Klose  <doko@ubuntu.com>
+        Backported from mainline
+-06-01  Jonathan Wakely  <jwakely@redhat.com>
+        * testsuite/lib/libstdc++.exp (libstdc++_init): Unset LANGUAGE
+        environment variable.
+-06-04  Renlin Li  <renlin.li@arm.com>
+        Backported from mainline
+-06-02  Renlin Li  <renlin.li@arm.com>
+        * testsuite/27_io/fpos/14775.cc: Add _GLIBCXX_HAVE_LIMIT_FSIZE check.
+-03-25  Jonathan Wakely  <jwakely@redhat.com>
+        Backport from mainline
+-03-02  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/65279
+        * include/std/scoped_allocator (__inner_type_impl,
+        scoped_allocator_adaptor): Add defaulted copy assignment and move
+        assignment operators.
+        * testsuite/20_util/scoped_allocator/65279.cc: New.
+-03-25  Paolo Carlini  <paolo.carlini@oracle.com>
+        PR libstdc++/65543
+        * include/std/istream (operator>>(basic_istream<>&&, _Tp&): Revert
+        thinko in r150387.
+        * include/std/ostream (operator<<(basic_ostream<>&&, const _Tp&):
+        Likewise.
+        * testsuite/27_io/rvalue_streams-2.cc: New.
+-01-09  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/60966
+        * include/std/future (packaged_task::operator()): Increment the
+        reference count on the shared state until the function returns.
+-12-19  Release Manager
+        * GCC 4.8.4 released.
+-12-06  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/63840
+        * include/std/functional (function::function(const function&)): Set
+        _M_manager after operations that might throw.
+        * include/tr1/functional (function::function(const function&),
+        function::function(_Functor, _Useless)): Likewise.
+        * testsuite/20_util/function/63840.cc: New.
+        * testsuite/tr1/3_function_objects/function/63840.cc: New.
+        PR libstdc++/61947
+        * include/std/tuple (_Head_base): Use allocator_arg_t parameters to
+        disambiguate unary constructors.
+        (_Tuple_impl): Pass allocator_arg_t arguments.
+        * testsuite/20_util/tuple/61947.cc: New.
+        * testsuite/20_util/uses_allocator/cons_neg.cc: Adjust dg-error line.
+        PR libstdc++/59603
+        * include/bits/stl_algo.h (random_shuffle): Prevent self-swapping.
+        * testsuite/25_algorithms/random_shuffle/59603.cc: New.
+-11-27  Thomas Preud'homme  <thomas.preudhomme@arm.com>
+        Backport from mainline
+-09-10  Tony Wang  <tony.wang@arm.com>
+        PR target/56846
+        * libsupc++/eh_personality.cc (PERSONALITY_FUNCTION):
+        Return with CONTINUE_UNWINDING when the state pattern
+        contains: _US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND
+-11-05  David Edelsohn  <dje.gcc@gmail.com>
+        Backported from mainline.
+-10-30  David Edelsohn  <dje.gcc@gmail.com>
+        * configure.host (aix4.3+, 5+): Do not use -G in link command.
+-10-15  Jason Merrill  <jason@redhat.com>
+        * libsupc++/dyncast.cc (__dynamic_cast): Handle mid-destruction
+        dynamic_cast more gracefully.
+-10-14  Kai Tietz  <ktietz@redhat.com>
+        PR libstdc++/57440
+        * config/os/mingw32/os_defines.h (_GTHREAD_USE_MUTEX_INIT_FUNC):
+        Define to avoid leak.
+        * config/os/mingw32-w64/os_defines.h: Likewise.
+-10-03  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/63449
+        * doc/xml/manual/containers.xml: Remove outdated section. Update
+        std::list notes.
+        * doc/html/*: Regenerate.
+-10-01  Jonathan Wakely  <jwakely@redhat.com>
+        * doc/xml/manual/status_cxx2011.xml: Corrections.
+        * doc/html/manual/status.html: Regenerate.
+-08-28  Samuel Bronson  <naesten@gmail.com>
+        Backport r212453 from trunk
+-07-11  Samuel Bronson  <naesten@gmail.com>
+                    Matthias Klose  <doko@ubuntu.com>
+        PR libstdc++/58962
+        * python/libstdcxx/v6/printers.py: Port to Python 2+3
+        (imap): New compat function.
+        (izip): Likewise.
+        (Iterator): New mixin to allow writing iterators in Python 3 style
+        regardless of which version we're running on.
+        [Python3] (long) New compat alias for "int".
+        * testsuite/lib/gdb-test.exp: Port to Python 2+3 (print syntax)
+        Backport r210625 from trunk
+-05-19  Jonathan Wakely  <jwakely@redhat.com>
+        * python/libstdcxx/v6/printers.py: Use Python3 raise syntax.
+-08-26  John David Anglin  <danglin@gcc.gnu.org>
+        * config/abi/post/hppa-linux-gnu/baseline_symbols.txt: Update.
+-08-26  Jonathan Wakely  <jwakely@redhat.com>
+        * doc/xml/manual/status_cxx2011.xml: Correct status table.
+        * doc/html/manual/*: Regenerate.
+-08-04  Jonathan Wakely  <jwakely@redhat.com>
+        Backported from mainline
+-07-29  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/61946
+        * include/ext/rope (rope::rope(char_producer<_CharT>*, size_t, bool,
+        const allocator_type&)): Pass non-const allocator to
+        _S_new_RopeFunction.
+        * testsuite/ext/rope/61946.cc: New.
+-08-04  Zifei Tong  <zifeitong@gmail.com>
+        * libsupc++/atexit_thread.cc (HAVE___CXA_THREAD_ATEXIT_IMPL): Add
+        _GLIBCXX_ prefix to macro.
+-06-03  Jonathan Wakely  <jwakely@redhat.com>
+        Backport from mainline
+-04-15  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/60734
+        * include/bits/stl_tree.h (_Rb_tree::_M_end): Fix invalid cast.
+        Backport from mainline
+-05-16  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/60966
+        * include/std/future (__future_base::_State_baseV2::_M_set_result):
+        Signal condition variable after call_once returns.
+        (__future_base::_State_baseV2::_M_do_set): Do not signal here.
+        (promise::set_value, promise::set_exception): Increment the reference
+        count on the shared state until the function returns.
+        * testsuite/30_threads/promise/60966.cc: New.
+-05-29  Jonathan Wakely  <jwakely@redhat.com>
+        * include/tr2/bool_set: Use UTF-8 for accented characters.
+        * scripts/run_doxygen: Handle Doxygen 1.8.x change.
+-05-22  Release Manager
+        * GCC 4.8.3 released.
+-05-08  Joshua Gay  <jgay@gnu.org>
+        PR libstdc++/61117
+        * doc/xml/faq.xml (faq.license.what_restrictions): Replace "open
+        source" with "free software".
+        * doc/html/faq.html: Likewise.
+-05-08  Jonathan Wakely  <jwakely@redhat.com>
+        * include/std/iostream: Fix URL in comment.
+        * src/c++98/ios_init.cc: Fix path in comment.
+-05-06  Jonathan Wakely  <jwakely@redhat.com>
+        Backport from mainline
+-04-15  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/60594
+        * include/std/functional (function::_Callable): Exclude own type
+        from the callable checks.
+        * testsuite/20_util/function/60594.cc: New.
+-04-27  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/60497
+        * include/std/tuple (get): Qualify calls to prevent ADL.
+        * testsuite/20_util/tuple/60497.cc: New.
+-04-05  Dominique d'Humieres  <dominiq@lps.ens.fr>
+            Jack Howarth <howarth@bromo.med.uc.edu>
+        PR target/54407
+        * 30_threads/condition_variable/54185.cc: Skip for darwin < 11.
+-04-04  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+        Backport from mainline
+-11-15  Ulrich Weigand  <Ulrich.Weigand@de.ibm.com>
+        * configure: Regenerate.
+-04-04  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+        Backport from mainline r204808:
+-11-14  Ulrich Weigand  <Ulrich.Weigand@de.ibm.com>
+        * scripts/extract_symvers.in: Ignore <localentry: > fields
+        in readelf --symbols output.
+-03-26  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/59548
+        * include/debug/safe_unordered_base.h (_Safe_unordered_container_base):
+        Define copy and move constructors that handle iterators correctly.
+        * testsuite/23_containers/unordered_map/59548.cc: New.
+-03-25  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/60658
+        * include/bits/atomic_base.h (__atomic_base<_PTp*>::is_lock_free()):
+        Use sizeof pointer type not the element type.
+        * testsuite/29_atomics/atomic/60658.cc: New.
+-03-18  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/60564
+        * include/std/future (__future_base::_Task_state<>): Change
+        constructors to template functions using perfect forwarding.
+        (__create_task_state): Use decayed type as stored task.
+        (packaged_task::packaged_task(_Fn&&)): Forward instead of moving.
+        * testsuite/30_threads/packaged_task/60564.cc: New.
+-03-12  Roland McGrath  <mcgrathr@google.com>
+            Mark Seaborn  <mseaborn@google.com>
+        PR libstdc++/59392
+        * libsupc++/eh_call.cc (__cxa_call_unexpected): Call __do_catch with
+        the address of a null pointer, not with a null pointer to pointer.
+        Copy comment for this case from eh_personality.cc:__cxa_call_unexpected.
+        * testsuite/18_support/bad_exception/59392.cc: New file.
+-03-11  Jonathan Wakely  <jwakely@redhat.com>
+        Backport from mainline.
+-01-09  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/59680
+        * src/c++11/thread.cc (__sleep_for): Fix call to ::sleep.
+-03-11  Jonathan Wakely  <jwakely@redhat.com>
+        Backport from mainline.
+-01-27  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/59215
+        * include/bits/shared_ptr_base.h
+        (_Sp_counted_base<_S_atomic>::_M_add_ref_lock()): Use relaxed atomic
+        load.
+-03-11  Jonathan Wakely  <jwakely@redhat.com>
+        Backport from mainline.
+-01-09  Jonathan Wakely  <jwakely@redhat.com>
+        PR libstdc++/59738
+        * include/bits/stl_vector.h (vector<>::_M_move_assign): Restore
+        support for non-Movable types.
+-01-08  François Dumont  <fdumont@gcc.gnu.org>
+        * include/bits/stl_vector.h (std::vector<>::_M_move_assign): Pass
+        *this allocator instance when building temporary vector instance
+        so that *this allocator does not get moved.
+        * testsuite/23_containers/vector/allocator/move.cc (test01): Add
+        check on a vector iterator.
+        * testsuite/23_containers/vector/allocator/move_assign.cc
+        (test02): Likewise.
+        (test03): New, test with a non-propagating allocator.
+-11-15  Jonathan Wakely  <jwakely.gcc@gmail.com>
+        * testsuite/23_containers/vector/allocator/move.cc: New
+-01-27  Jason Merrill  <jason@redhat.com>
+        Core DR 475
+        PR c++/41174
+        PR c++/59224
+        * libsupc++/eh_throw.cc (__cxa_throw): Set uncaughtExceptions.
+        * libsupc++/eh_alloc.cc (__cxa_allocate_dependent_exception)
+        (__cxa_allocate_exception): Don't set it here.
+-12-15  H.J. Lu  <hongjiu.lu@intel.com>
+        * config/abi/post/x86_64-linux-gnu/x32/baseline_symbols.txt: Update.
+-11-22  Jonathan Wakely  <jwakely.gcc@gmail.com>
+        * acinclude.m4 (libtool_VERSION): Bump.
+        * configure: Regenerate.
+        * doc/xml/manual/abi.xml: Update version information.
+-11-05  Jonathan Wakely  <jwakely.gcc@gmail.com>
+        * doc/xml/manual/status_cxx2011.xml: Document aligned_union as
+        missing.
+        * doc/xml/manual/spine.xml: Update copyright years.
+        * doc/html/*: Regenerate.
+-11-01  Paolo Carlini  <paolo.carlini@oracle.com>
+        PR libstdc++/58952
+        * include/c_global/cstdio: Undef getchar.
+-10-31  Jonathan Wakely  <jwakely.gcc@gmail.com>
+        * testsuite/20_util/shared_ptr/cons/58839.cc: Do not use
+        default_delete<void>.
+-10-30  Chris Studholme  <cvs@cs.utoronto.ca>
+        PR libstdc++/58912
+        * include/bits/shared_ptr_base.h (_Sp_counted_ptr_inplace): Remove
+        unnecessary initialization of storage buffer.
+-10-29  Jonathan Wakely  <jwakely.gcc@gmail.com>
+        PR libstdc++/58839
+        * include/bits/shared_ptr_base.h
+        (__shared_ptr<T>::__shared_ptr(unique_ptr<U,D>&&)): Do not dereference
+        pointer.
+        * testsuite/20_util/shared_ptr/cons/58839.cc: New.
+-10-20  Chris Jefferson  <chris@bubblescope.net>
+            Paolo Carlini  <paolo.carlini@oracle.com>
+        PR libstdc++/58800
+        * include/bits/stl_algo.h (__unguarded_partition_pivot): Change
+        __last - 2 to __last - 1.
+        * testsuite/25_algorithms/nth_element/58800.cc: New
+-10-16  François Dumont  <fdumont@gcc.gnu.org>
+        PR libstdc++/58191
+        * include/debug/macros.h (__glibcxx_check_partitioned_lower): Add
+        __gnu_debug::__base calls on iterators passed to internal debug
+        check.
+        (__glibcxx_check_partitioned_lower_pred): Likewise.
+        (__glibcxx_check_partitioned_upper): Likewise.
+        (__glibcxx_check_partitioned_upper_pred): Likewise.
+        * include/debug/functions.h (__check_partitioned_lower):
+        Remove code to detect safe iterators.
+        (__check_partitioned_upper): Likewise.
 -10-16  Release Manager
         * GCC 4.8.2 released.

/contrib/sdk/sources/libstdc++-v3/Makefile
7,6 → 7,7
STRIP = kos32-strip

CFLAGS = -U_Win32 -U_WIN32 -U__MINGW32__ -c -O2 -fno-ident -fomit-frame-pointer -ffunction-sections -fdata-sections
CFLAGS+= -fno-rtti -fno-exceptions

ARFLAGS= crs

 /contrib/sdk/sources/libstdc++-v3/config.h
 ,7 → 444,7
 /* #undef HAVE_TGMATH_H */
 /* Define to 1 if the target supports thread-local storage. */
-/* #undef HAVE_TLS */
+#define HAVE_TLS 1
 /* Define to 1 if you have the <unistd.h> header file. */
 #define HAVE_UNISTD_H 1

/contrib/sdk/sources/libstdc++-v3/include/stamp-debug
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-decimal
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-profile
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-visibility
File deleted

/contrib/sdk/sources/libstdc++-v3/include/Makefile
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-tr1
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-tr2
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-profile-impl
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-parallel
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-bits
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-std
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-pb
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-host
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-bits-sup
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-namespace-version
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-ext
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-c_base
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-mingw32
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-c_compatibility
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-extern-template
File deleted

/contrib/sdk/sources/libstdc++-v3/include/stamp-backward
File deleted

 /contrib/sdk/sources/libstdc++-v3/include/bits/atomic_base.h
 ,11 → 764,11
       bool
       is_lock_free() const noexcept
-      { return __atomic_is_lock_free(_M_type_size(1), nullptr); }
+      { return __atomic_is_lock_free(sizeof(__pointer_type), nullptr); }
       bool
       is_lock_free() const volatile noexcept
-      { return __atomic_is_lock_free(_M_type_size(1), nullptr); }
+      { return __atomic_is_lock_free(sizeof(__pointer_type), nullptr); }
       void
       store(__pointer_type __p,

 /contrib/sdk/sources/libstdc++-v3/include/bits/shared_ptr_base.h
 ,7 → 233,7
     _M_add_ref_lock()
     {
       // Perform lock-free add-if-not-zero operation.
-      _Atomic_word __count = _M_use_count;
+      _Atomic_word __count = _M_get_use_count();
       do
         {
           if (__count == 0)
 ,7 → 391,7
     public:
       template<typename... _Args>
         _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
-        : _M_impl(__a), _M_storage()
+        : _M_impl(__a)
         {
           _M_impl._M_ptr = static_cast<_Tp*>(static_cast<void*>(&_M_storage));
           // _GLIBCXX_RESOLVE_LIB_DEFECTS
 ,7 → 819,7
         : _M_ptr(__r.get()), _M_refcount()
         {
           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
-          auto __tmp = std::__addressof(*__r.get());
+          auto __tmp = __r.get();
           _M_refcount = __shared_count<_Lp>(std::move(__r));
           __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
         }

 /contrib/sdk/sources/libstdc++-v3/include/bits/stl_algo.h
 ,7 → 2279,7
                                 _RandomAccessIterator __last)
     {
       _RandomAccessIterator __mid = __first + (__last - __first) / 2;
-      std::__move_median_to_first(__first, __first + 1, __mid, (__last - 2));
+      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1);
       return std::__unguarded_partition(__first + 1, __last, *__first);
     }
 ,7 → 2291,7
                                 _RandomAccessIterator __last, _Compare __comp)
     {
       _RandomAccessIterator __mid = __first + (__last - __first) / 2;
-      std::__move_median_to_first(__first, __first + 1, __mid, (__last - 2),
+      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
                                   __comp);
       return std::__unguarded_partition(__first + 1, __last, *__first, __comp);
     }
 ,8 → 5193,13
       if (__first != __last)
         for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
-          std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));
+          {
+            _RandomAccessIterator __j = __first
+                                        + std::rand() % ((__i - __first) + 1);
+            if (__i != __j)
+              std::iter_swap(__i, __j);
     }
+    }
   /**
    *  @brief Shuffle the elements of a sequence using a random number
 ,8 → 5232,12
       if (__first == __last)
         return;
       for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
-        std::iter_swap(__i, __first + __rand((__i - __first) + 1));
+        {
+          _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
+          if (__i != __j)
+            std::iter_swap(__i, __j);
     }
+    }
   /**

 /contrib/sdk/sources/libstdc++-v3/include/bits/stl_tree.h
 ,11 → 510,11
       _Link_type
       _M_end()
-      { return static_cast<_Link_type>(&this->_M_impl._M_header); }
+      { return reinterpret_cast<_Link_type>(&this->_M_impl._M_header); }
       _Const_Link_type
       _M_end() const
-      { return static_cast<_Const_Link_type>(&this->_M_impl._M_header); }
+      { return reinterpret_cast<_Const_Link_type>(&this->_M_impl._M_header); }
       static const_reference
       _S_value(_Const_Link_type __x)

 /contrib/sdk/sources/libstdc++-v3/include/bits/stl_vector.h
 ,7 → 1361,8
       void
       _M_move_assign(vector&& __x, std::true_type) noexcept
       {
-        const vector __tmp(std::move(*this));
+        vector __tmp(get_allocator());
+        this->_M_impl._M_swap_data(__tmp._M_impl);
         this->_M_impl._M_swap_data(__x._M_impl);
         if (_Alloc_traits::_S_propagate_on_move_assign())
           std::__alloc_on_move(_M_get_Tp_allocator(),

/contrib/sdk/sources/libstdc++-v3/include/cstdio
69,6 → 69,7
#undef ftell
#undef fwrite
#undef getc
#undef getchar
#undef gets
#undef perror
#undef printf

 /contrib/sdk/sources/libstdc++-v3/include/cxxabi.h
 ,0 → 1,700
+// ABI Support -*- C++ -*-
+// Copyright (C) 2000-2013 Free Software Foundation, Inc.
+//
+// This file is part of GCC.
+//
+// GCC is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// GCC is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+// Written by Nathan Sidwell, Codesourcery LLC, <nathan@codesourcery.com>
+/* This file declares the new abi entry points into the runtime. It is not
+   normally necessary for user programs to include this header, or use the
+   entry points directly. However, this header is available should that be
+   needed.
+   Some of the entry points are intended for both C and C++, thus this header
+   is includable from both C and C++. Though the C++ specific parts are not
+   available in C, naturally enough.  */
+/** @file cxxabi.h
+ *  The header provides an interface to the C++ ABI.
+ */
+#ifndef _CXXABI_H
+#define _CXXABI_H 1
+#pragma GCC system_header
+#pragma GCC visibility push(default)
+#include <stddef.h>
+#include <bits/c++config.h>
+#include <bits/cxxabi_tweaks.h>
+#include <bits/cxxabi_forced.h>
+#ifndef _GLIBCXX_CDTOR_CALLABI
+#define _GLIBCXX_CDTOR_CALLABI
+#endif
+#ifdef __cplusplus
+namespace __cxxabiv1
+{
+  extern "C"
+  {
+#endif
+  typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *);
+  // Allocate array.
+  void*
+  __cxa_vec_new(size_t __element_count, size_t __element_size,
+                size_t __padding_size, __cxa_cdtor_type __constructor,
+                __cxa_cdtor_type __destructor);
+  void*
+  __cxa_vec_new2(size_t __element_count, size_t __element_size,
+                 size_t __padding_size, __cxa_cdtor_type __constructor,
+                 __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
+                 void (*__dealloc) (void*));
+  void*
+  __cxa_vec_new3(size_t __element_count, size_t __element_size,
+                 size_t __padding_size, __cxa_cdtor_type __constructor,
+                 __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
+                 void (*__dealloc) (void*, size_t));
+  // Construct array.
+  __cxa_vec_ctor_return_type
+  __cxa_vec_ctor(void* __array_address, size_t __element_count,
+                 size_t __element_size, __cxa_cdtor_type __constructor,
+                 __cxa_cdtor_type __destructor);
+  __cxa_vec_ctor_return_type
+  __cxa_vec_cctor(void* __dest_array, void* __src_array,
+                  size_t __element_count, size_t __element_size,
+                  __cxa_cdtor_return_type (*__constructor) (void*, void*),
+                  __cxa_cdtor_type __destructor);
+  // Destruct array.
+  void
+  __cxa_vec_dtor(void* __array_address, size_t __element_count,
+                 size_t __element_size, __cxa_cdtor_type __destructor);
+  void
+  __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s,
+                    __cxa_cdtor_type __destructor) _GLIBCXX_NOTHROW;
+  // Destruct and release array.
+  void
+  __cxa_vec_delete(void* __array_address, size_t __element_size,
+                   size_t __padding_size, __cxa_cdtor_type __destructor);
+  void
+  __cxa_vec_delete2(void* __array_address, size_t __element_size,
+                    size_t __padding_size, __cxa_cdtor_type __destructor,
+                    void (*__dealloc) (void*));
+  void
+  __cxa_vec_delete3(void* __array_address, size_t __element_size,
+                    size_t __padding_size, __cxa_cdtor_type __destructor,
+                    void (*__dealloc) (void*, size_t));
+  int
+  __cxa_guard_acquire(__guard*);
+  void
+  __cxa_guard_release(__guard*) _GLIBCXX_NOTHROW;
+  void
+  __cxa_guard_abort(__guard*) _GLIBCXX_NOTHROW;
+  // DSO destruction.
+  int
+  __cxa_atexit(void (*)(void*), void*, void*) _GLIBCXX_NOTHROW;
+  int
+  __cxa_finalize(void*);
+  // TLS destruction.
+  int
+  __cxa_thread_atexit(void (*)(void*), void*, void *) _GLIBCXX_NOTHROW;
+  // Pure virtual functions.
+  void
+  __cxa_pure_virtual(void) __attribute__ ((__noreturn__));
+  void
+  __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
+  // Exception handling auxillary.
+  void
+  __cxa_bad_cast() __attribute__((__noreturn__));
+  void
+  __cxa_bad_typeid() __attribute__((__noreturn__));
+  /**
+   *  @brief Demangling routine.
+   *  ABI-mandated entry point in the C++ runtime library for demangling.
+   *
+   *  @param __mangled_name A NUL-terminated character string
+   *  containing the name to be demangled.
+   *
+   *  @param __output_buffer A region of memory, allocated with
+   *  malloc, of @a *__length bytes, into which the demangled name is
+   *  stored.  If @a __output_buffer is not long enough, it is
+   *  expanded using realloc.  @a __output_buffer may instead be NULL;
+   *  in that case, the demangled name is placed in a region of memory
+   *  allocated with malloc.
+   *
+   *  @param __length If @a __length is non-NULL, the length of the
+   *  buffer containing the demangled name is placed in @a *__length.
+   *
+   *  @param __status @a *__status is set to one of the following values:
+   *   0: The demangling operation succeeded.
+   *  -1: A memory allocation failure occurred.
+   *  -2: @a mangled_name is not a valid name under the C++ ABI mangling rules.
+   *  -3: One of the arguments is invalid.
+   *
+   *  @return A pointer to the start of the NUL-terminated demangled
+   *  name, or NULL if the demangling fails.  The caller is
+   *  responsible for deallocating this memory using @c free.
+   *
+   *  The demangling is performed using the C++ ABI mangling rules,
+   *  with GNU extensions. For example, this function is used in
+   *  __gnu_cxx::__verbose_terminate_handler.
+   *
+   *  See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch39.html
+   *  for other examples of use.
+   *
+   *  @note The same demangling functionality is available via
+   *  libiberty (@c <libiberty/demangle.h> and @c libiberty.a) in GCC
+   *  3.1 and later, but that requires explicit installation (@c
+   *  --enable-install-libiberty) and uses a different API, although
+   *  the ABI is unchanged.
+   */
+  char*
+  __cxa_demangle(const char* __mangled_name, char* __output_buffer,
+                 size_t* __length, int* __status);
+#ifdef __cplusplus
+  }
+} // namespace __cxxabiv1
+#endif
+#ifdef __cplusplus
+#include <typeinfo>
+namespace __cxxabiv1
+{
+  // Type information for int, float etc.
+  class __fundamental_type_info : public std::type_info
+  {
+  public:
+    explicit
+    __fundamental_type_info(const char* __n) : std::type_info(__n) { }
+    virtual
+    ~__fundamental_type_info();
+  };
+  // Type information for array objects.
+  class __array_type_info : public std::type_info
+  {
+  public:
+    explicit
+    __array_type_info(const char* __n) : std::type_info(__n) { }
+    virtual
+    ~__array_type_info();
+  };
+  // Type information for functions (both member and non-member).
+  class __function_type_info : public std::type_info
+  {
+  public:
+    explicit
+    __function_type_info(const char* __n) : std::type_info(__n) { }
+    virtual
+    ~__function_type_info();
+  protected:
+    // Implementation defined member function.
+    virtual bool
+    __is_function_p() const;
+  };
+  // Type information for enumerations.
+  class __enum_type_info : public std::type_info
+  {
+  public:
+    explicit
+    __enum_type_info(const char* __n) : std::type_info(__n) { }
+    virtual
+    ~__enum_type_info();
+  };
+  // Common type information for simple pointers and pointers to member.
+  class __pbase_type_info : public std::type_info
+  {
+  public:
+    unsigned int                __flags; // Qualification of the target object.
+    const std::type_info*       __pointee; // Type of pointed to object.
+    explicit
+    __pbase_type_info(const char* __n, int __quals,
+                      const std::type_info* __type)
+    : std::type_info(__n), __flags(__quals), __pointee(__type)
+    { }
+    virtual
+    ~__pbase_type_info();
+    // Implementation defined type.
+    enum __masks
+      {
+        __const_mask = 0x1,
+        __volatile_mask = 0x2,
+        __restrict_mask = 0x4,
+        __incomplete_mask = 0x8,
+        __incomplete_class_mask = 0x10
+      };
+  protected:
+    __pbase_type_info(const __pbase_type_info&);
+    __pbase_type_info&
+    operator=(const __pbase_type_info&);
+    // Implementation defined member functions.
+    virtual bool
+    __do_catch(const std::type_info* __thr_type, void** __thr_obj,
+               unsigned int __outer) const;
+    inline virtual bool
+    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
+                    unsigned __outer) const;
+  };
+  // Type information for simple pointers.
+  class __pointer_type_info : public __pbase_type_info
+  {
+  public:
+    explicit
+    __pointer_type_info(const char* __n, int __quals,
+                        const std::type_info* __type)
+    : __pbase_type_info (__n, __quals, __type) { }
+    virtual
+    ~__pointer_type_info();
+  protected:
+    // Implementation defined member functions.
+    virtual bool
+    __is_pointer_p() const;
+    virtual bool
+    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
+                    unsigned __outer) const;
+  };
+  class __class_type_info;
+  // Type information for a pointer to member variable.
+  class __pointer_to_member_type_info : public __pbase_type_info
+  {
+  public:
+    __class_type_info* __context;   // Class of the member.
+    explicit
+    __pointer_to_member_type_info(const char* __n, int __quals,
+                                  const std::type_info* __type,
+                                  __class_type_info* __klass)
+    : __pbase_type_info(__n, __quals, __type), __context(__klass) { }
+    virtual
+    ~__pointer_to_member_type_info();
+  protected:
+    __pointer_to_member_type_info(const __pointer_to_member_type_info&);
+    __pointer_to_member_type_info&
+    operator=(const __pointer_to_member_type_info&);
+    // Implementation defined member function.
+    virtual bool
+    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
+                    unsigned __outer) const;
+  };
+  // Helper class for __vmi_class_type.
+  class __base_class_type_info
+  {
+  public:
+    const __class_type_info*    __base_type;  // Base class type.
+#ifdef _GLIBCXX_LLP64
+    long long                   __offset_flags;  // Offset and info.
+#else
+    long                        __offset_flags;  // Offset and info.
+#endif
+    enum __offset_flags_masks
+      {
+        __virtual_mask = 0x1,
+        __public_mask = 0x2,
+        __hwm_bit = 2,
+        __offset_shift = 8          // Bits to shift offset.
+      };
+    // Implementation defined member functions.
+    bool
+    __is_virtual_p() const
+    { return __offset_flags & __virtual_mask; }
+    bool
+    __is_public_p() const
+    { return __offset_flags & __public_mask; }
+    ptrdiff_t
+    __offset() const
+    {
+      // This shift, being of a signed type, is implementation
+      // defined. GCC implements such shifts as arithmetic, which is
+      // what we want.
+      return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
+    }
+  };
+  // Type information for a class.
+  class __class_type_info : public std::type_info
+  {
+  public:
+    explicit
+    __class_type_info (const char *__n) : type_info(__n) { }
+    virtual
+    ~__class_type_info ();
+    // Implementation defined types.
+    // The type sub_kind tells us about how a base object is contained
+    // within a derived object. We often do this lazily, hence the
+    // UNKNOWN value. At other times we may use NOT_CONTAINED to mean
+    // not publicly contained.
+    enum __sub_kind
+      {
+        // We have no idea.
+        __unknown = 0,
+        // Not contained within us (in some circumstances this might
+        // mean not contained publicly)
+        __not_contained,
+        // Contained ambiguously.
+        __contained_ambig,
+        // Via a virtual path.
+        __contained_virtual_mask = __base_class_type_info::__virtual_mask,
+        // Via a public path.
+        __contained_public_mask = __base_class_type_info::__public_mask,
+        // Contained within us.
+        __contained_mask = 1 << __base_class_type_info::__hwm_bit,
+        __contained_private = __contained_mask,
+        __contained_public = __contained_mask | __contained_public_mask
+      };
+    struct __upcast_result;
+    struct __dyncast_result;
+  protected:
+    // Implementation defined member functions.
+    virtual bool
+    __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
+    virtual bool
+    __do_catch(const type_info* __thr_type, void** __thr_obj,
+               unsigned __outer) const;
+  public:
+    // Helper for upcast. See if DST is us, or one of our bases.
+    // Return false if not found, true if found.
+    virtual bool
+    __do_upcast(const __class_type_info* __dst, const void* __obj,
+                __upcast_result& __restrict __result) const;
+    // Indicate whether SRC_PTR of type SRC_TYPE is contained publicly
+    // within OBJ_PTR. OBJ_PTR points to a base object of our type,
+    // which is the destination type. SRC2DST indicates how SRC
+    // objects might be contained within this type.  If SRC_PTR is one
+    // of our SRC_TYPE bases, indicate the virtuality. Returns
+    // not_contained for non containment or private containment.
+    inline __sub_kind
+    __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
+                      const __class_type_info* __src_type,
+                      const void* __src_ptr) const;
+    // Helper for dynamic cast. ACCESS_PATH gives the access from the
+    // most derived object to this base. DST_TYPE indicates the
+    // desired type we want. OBJ_PTR points to a base of our type
+    // within the complete object. SRC_TYPE indicates the static type
+    // started from and SRC_PTR points to that base within the most
+    // derived object. Fill in RESULT with what we find. Return true
+    // if we have located an ambiguous match.
+    virtual bool
+    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
+                 const __class_type_info* __dst_type, const void* __obj_ptr,
+                 const __class_type_info* __src_type, const void* __src_ptr,
+                 __dyncast_result& __result) const;
+    // Helper for find_public_subobj. SRC2DST indicates how SRC_TYPE
+    // bases are inherited by the type started from -- which is not
+    // necessarily the current type. The current type will be a base
+    // of the destination type.  OBJ_PTR points to the current base.
+    virtual __sub_kind
+    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
+                         const __class_type_info* __src_type,
+                         const void* __src_ptr) const;
+  };
+  // Type information for a class with a single non-virtual base.
+  class __si_class_type_info : public __class_type_info
+  {
+  public:
+    const __class_type_info* __base_type;
+    explicit
+    __si_class_type_info(const char *__n, const __class_type_info *__base)
+    : __class_type_info(__n), __base_type(__base) { }
+    virtual
+    ~__si_class_type_info();
+  protected:
+    __si_class_type_info(const __si_class_type_info&);
+    __si_class_type_info&
+    operator=(const __si_class_type_info&);
+    // Implementation defined member functions.
+    virtual bool
+    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
+                 const __class_type_info* __dst_type, const void* __obj_ptr,
+                 const __class_type_info* __src_type, const void* __src_ptr,
+                 __dyncast_result& __result) const;
+    virtual __sub_kind
+    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
+                         const __class_type_info* __src_type,
+                         const void* __sub_ptr) const;
+    virtual bool
+    __do_upcast(const __class_type_info*__dst, const void*__obj,
+                __upcast_result& __restrict __result) const;
+  };
+  // Type information for a class with multiple and/or virtual bases.
+  class __vmi_class_type_info : public __class_type_info
+  {
+  public:
+    unsigned int                __flags;  // Details about the class hierarchy.
+    unsigned int                __base_count;  // Number of direct bases.
+    // The array of bases uses the trailing array struct hack so this
+    // class is not constructable with a normal constructor. It is
+    // internally generated by the compiler.
+    __base_class_type_info      __base_info[1];  // Array of bases.
+    explicit
+    __vmi_class_type_info(const char* __n, int ___flags)
+    : __class_type_info(__n), __flags(___flags), __base_count(0) { }
+    virtual
+    ~__vmi_class_type_info();
+    // Implementation defined types.
+    enum __flags_masks
+      {
+        __non_diamond_repeat_mask = 0x1, // Distinct instance of repeated base.
+        __diamond_shaped_mask = 0x2, // Diamond shaped multiple inheritance.
+        __flags_unknown_mask = 0x10
+      };
+  protected:
+    // Implementation defined member functions.
+    virtual bool
+    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
+                 const __class_type_info* __dst_type, const void* __obj_ptr,
+                 const __class_type_info* __src_type, const void* __src_ptr,
+                 __dyncast_result& __result) const;
+    virtual __sub_kind
+    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
+                         const __class_type_info* __src_type,
+                         const void* __src_ptr) const;
+    virtual bool
+    __do_upcast(const __class_type_info* __dst, const void* __obj,
+                __upcast_result& __restrict __result) const;
+  };
+  // Exception handling forward declarations.
+  struct __cxa_exception;
+  struct __cxa_refcounted_exception;
+  struct __cxa_dependent_exception;
+  struct __cxa_eh_globals;
+  extern "C"
+  {
+  // Dynamic cast runtime.
+  // src2dst has the following possible values
+  //  >-1: src_type is a unique public non-virtual base of dst_type
+  //       dst_ptr + src2dst == src_ptr
+  //   -1: unspecified relationship
+  //   -2: src_type is not a public base of dst_type
+  //   -3: src_type is a multiple public non-virtual base of dst_type
+  void*
+  __dynamic_cast(const void* __src_ptr, // Starting object.
+                 const __class_type_info* __src_type, // Static type of object.
+                 const __class_type_info* __dst_type, // Desired target type.
+                 ptrdiff_t __src2dst); // How src and dst are related.
+  // Exception handling runtime.
+  // The __cxa_eh_globals for the current thread can be obtained by using
+  // either of the following functions.  The "fast" version assumes at least
+  // one prior call of __cxa_get_globals has been made from the current
+  // thread, so no initialization is necessary.
+  __cxa_eh_globals*
+  __cxa_get_globals() _GLIBCXX_NOTHROW __attribute__ ((__const__));
+  __cxa_eh_globals*
+  __cxa_get_globals_fast() _GLIBCXX_NOTHROW __attribute__ ((__const__));
+  // Allocate memory for the primary exception plus the thrown object.
+  void*
+  __cxa_allocate_exception(size_t) _GLIBCXX_NOTHROW;
+  // Free the space allocated for the primary exception.
+  void
+  __cxa_free_exception(void*) _GLIBCXX_NOTHROW;
+  // Throw the exception.
+  void
+  __cxa_throw(void*, std::type_info*, void (_GLIBCXX_CDTOR_CALLABI *) (void *))
+  __attribute__((__noreturn__));
+  // Used to implement exception handlers.
+  void*
+  __cxa_get_exception_ptr(void*) _GLIBCXX_NOTHROW __attribute__ ((__pure__));
+  void*
+  __cxa_begin_catch(void*) _GLIBCXX_NOTHROW;
+  void
+  __cxa_end_catch();
+  void
+  __cxa_rethrow() __attribute__((__noreturn__));
+  // Returns the type_info for the currently handled exception [15.3/8], or
+  // null if there is none.
+  std::type_info*
+  __cxa_current_exception_type() _GLIBCXX_NOTHROW __attribute__ ((__pure__));
+  // GNU Extensions.
+  // Allocate memory for a dependent exception.
+  __cxa_dependent_exception*
+  __cxa_allocate_dependent_exception() _GLIBCXX_NOTHROW;
+  // Free the space allocated for the dependent exception.
+  void
+  __cxa_free_dependent_exception(__cxa_dependent_exception*) _GLIBCXX_NOTHROW;
+  } // extern "C"
+  // A magic placeholder class that can be caught by reference
+  // to recognize foreign exceptions.
+  class __foreign_exception
+  {
+    virtual ~__foreign_exception() throw();
+    virtual void __pure_dummy() = 0; // prevent catch by value
+  };
+} // namespace __cxxabiv1
+/** @namespace abi
+ *  @brief The cross-vendor C++ Application Binary Interface. A
+ *  namespace alias to __cxxabiv1, but user programs should use the
+ *  alias 'abi'.
+ *
+ *  A brief overview of an ABI is given in the libstdc++ FAQ, question
+ *  5.8 (you may have a copy of the FAQ locally, or you can view the online
+ *  version at http://gcc.gnu.org/onlinedocs/libstdc++/faq.html#5_8 ).
+ *
+ *  GCC subscribes to a cross-vendor ABI for C++, sometimes
+ *  called the IA64 ABI because it happens to be the native ABI for that
+ *  platform.  It is summarized at http://www.codesourcery.com/cxx-abi/
+ *  along with the current specification.
+ *
+ *  For users of GCC greater than or equal to 3.x, entry points are
+ *  available in <cxxabi.h>, which notes, <em>'It is not normally
+ *  necessary for user programs to include this header, or use the
+ *  entry points directly.  However, this header is available should
+ *  that be needed.'</em>
+*/
+namespace abi = __cxxabiv1;
+namespace __gnu_cxx
+{
+  /**
+   *  @brief Exception thrown by __cxa_guard_acquire.
+   *  @ingroup exceptions
+   *
+   *  6.7[stmt.dcl]/4: If control re-enters the declaration (recursively)
+   *  while the object is being initialized, the behavior is undefined.
+   *
+   *  Since we already have a library function to handle locking, we might
+   *  as well check for this situation and throw an exception.
+   *  We use the second byte of the guard variable to remember that we're
+   *  in the middle of an initialization.
+   */
+  class recursive_init_error: public std::exception
+  {
+  public:
+    recursive_init_error() throw() { }
+    virtual ~recursive_init_error() throw ();
+  };
+}
+#endif // __cplusplus
+#pragma GCC visibility pop
+#endif // __CXXABI_H

 /contrib/sdk/sources/libstdc++-v3/include/debug/functions.h
 ,11 → 345,13
       return __check_sorted_set_aux(__first, __last, __pred, _SameType());
    }
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 270. Binary search requirements overly strict
+  // Determine if a sequence is partitioned w.r.t. this element.
   template<typename _ForwardIterator, typename _Tp>
     inline bool
-  __check_partitioned_lower_aux(_ForwardIterator __first,
-                                _ForwardIterator __last, const _Tp& __value,
-                                std::forward_iterator_tag)
+    __check_partitioned_lower(_ForwardIterator __first,
+                              _ForwardIterator __last, const _Tp& __value)
     {
       while (__first != __last && *__first < __value)
         ++__first;
 ,38 → 364,11
       return __first == __last;
     }
-  // For performance reason, as the iterator range has been validated, check on
-  // random access safe iterators is done using the base iterator.
-  template<typename _Iterator, typename _Sequence, typename _Tp>
-    inline bool
-    __check_partitioned_lower_aux(
-                        const _Safe_iterator<_Iterator, _Sequence>& __first,
-                        const _Safe_iterator<_Iterator, _Sequence>& __last,
-                        const _Tp& __value,
-                        std::random_access_iterator_tag __tag)
-    {
-      return __check_partitioned_lower_aux(__first.base(), __last.base(),
-                                           __value, __tag);
-    }
-  // _GLIBCXX_RESOLVE_LIB_DEFECTS
-  // 270. Binary search requirements overly strict
-  // Determine if a sequence is partitioned w.r.t. this element.
   template<typename _ForwardIterator, typename _Tp>
     inline bool
-    __check_partitioned_lower(_ForwardIterator __first,
+    __check_partitioned_upper(_ForwardIterator __first,
                               _ForwardIterator __last, const _Tp& __value)
     {
-      return __check_partitioned_lower_aux(__first, __last, __value,
-                                           std::__iterator_category(__first));
-    }
-  template<typename _ForwardIterator, typename _Tp>
-    inline bool
-    __check_partitioned_upper_aux(_ForwardIterator __first,
-                                  _ForwardIterator __last, const _Tp& __value,
-                                  std::forward_iterator_tag)
-    {
       while (__first != __last && !(__value < *__first))
         ++__first;
       if (__first != __last)
 ,35 → 380,12
       return __first == __last;
     }
-  // For performance reason, as the iterator range has been validated, check on
-  // random access safe iterators is done using the base iterator.
-  template<typename _Iterator, typename _Sequence, typename _Tp>
-    inline bool
-    __check_partitioned_upper_aux(
-                        const _Safe_iterator<_Iterator, _Sequence>& __first,
-                        const _Safe_iterator<_Iterator, _Sequence>& __last,
-                        const _Tp& __value,
-                        std::random_access_iterator_tag __tag)
-    {
-      return __check_partitioned_upper_aux(__first.base(), __last.base(),
-                                           __value, __tag);
-    }
-  template<typename _ForwardIterator, typename _Tp>
-    inline bool
-    __check_partitioned_upper(_ForwardIterator __first,
-                              _ForwardIterator __last, const _Tp& __value)
-    {
-      return __check_partitioned_upper_aux(__first, __last, __value,
-                                           std::__iterator_category(__first));
-    }
+  // Determine if a sequence is partitioned w.r.t. this element.
   template<typename _ForwardIterator, typename _Tp, typename _Pred>
     inline bool
-    __check_partitioned_lower_aux(_ForwardIterator __first,
+    __check_partitioned_lower(_ForwardIterator __first,
                                   _ForwardIterator __last, const _Tp& __value,
-                                  _Pred __pred,
-                                  std::forward_iterator_tag)
+                              _Pred __pred)
     {
       while (__first != __last && bool(__pred(*__first, __value)))
         ++__first;
 ,39 → 398,12
       return __first == __last;
     }
-  // For performance reason, as the iterator range has been validated, check on
-  // random access safe iterators is done using the base iterator.
-  template<typename _Iterator, typename _Sequence,
-           typename _Tp, typename _Pred>
-    inline bool
-    __check_partitioned_lower_aux(
-                        const _Safe_iterator<_Iterator, _Sequence>& __first,
-                        const _Safe_iterator<_Iterator, _Sequence>& __last,
-                        const _Tp& __value, _Pred __pred,
-                        std::random_access_iterator_tag __tag)
-    {
-      return __check_partitioned_lower_aux(__first.base(), __last.base(),
-                                           __value, __pred, __tag);
-    }
-  // Determine if a sequence is partitioned w.r.t. this element.
   template<typename _ForwardIterator, typename _Tp, typename _Pred>
     inline bool
-    __check_partitioned_lower(_ForwardIterator __first,
+    __check_partitioned_upper(_ForwardIterator __first,
                               _ForwardIterator __last, const _Tp& __value,
                               _Pred __pred)
     {
-      return __check_partitioned_lower_aux(__first, __last, __value, __pred,
-                                           std::__iterator_category(__first));
-    }
-  template<typename _ForwardIterator, typename _Tp, typename _Pred>
-    inline bool
-    __check_partitioned_upper_aux(_ForwardIterator __first,
-                                  _ForwardIterator __last, const _Tp& __value,
-                                  _Pred __pred,
-                                  std::forward_iterator_tag)
-    {
       while (__first != __last && !bool(__pred(__value, *__first)))
         ++__first;
       if (__first != __last)
 ,31 → 415,6
       return __first == __last;
     }
-  // For performance reason, as the iterator range has been validated, check on
-  // random access safe iterators is done using the base iterator.
-  template<typename _Iterator, typename _Sequence,
-           typename _Tp, typename _Pred>
-    inline bool
-    __check_partitioned_upper_aux(
-                        const _Safe_iterator<_Iterator, _Sequence>& __first,
-                        const _Safe_iterator<_Iterator, _Sequence>& __last,
-                        const _Tp& __value, _Pred __pred,
-                        std::random_access_iterator_tag __tag)
-    {
-      return __check_partitioned_upper_aux(__first.base(), __last.base(),
-                                           __value, __pred, __tag);
-    }
-  template<typename _ForwardIterator, typename _Tp, typename _Pred>
-    inline bool
-    __check_partitioned_upper(_ForwardIterator __first,
-                              _ForwardIterator __last, const _Tp& __value,
-                              _Pred __pred)
-    {
-      return __check_partitioned_upper_aux(__first, __last, __value, __pred,
-                                           std::__iterator_category(__first));
-    }
   // Helper struct to detect random access safe iterators.
   template<typename _Iterator>
     struct __is_safe_random_iterator

 /contrib/sdk/sources/libstdc++-v3/include/debug/macros.h
 ,8 → 261,9
     w.r.t. the value _Value. */
 #define __glibcxx_check_partitioned_lower(_First,_Last,_Value)          \
 __glibcxx_check_valid_range(_First,_Last);                              \
-_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower(_First, _Last, \
-                                                            _Value),    \
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower(           \
+                        __gnu_debug::__base(_First),                    \
+                        __gnu_debug::__base(_Last), _Value),            \
                       _M_message(__gnu_debug::__msg_unpartitioned)      \
                       ._M_iterator(_First, #_First)                     \
                       ._M_iterator(_Last, #_Last)                       \
 ,8 → 271,9
 #define __glibcxx_check_partitioned_upper(_First,_Last,_Value)          \
 __glibcxx_check_valid_range(_First,_Last);                              \
-_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper(_First, _Last, \
-                                                            _Value),    \
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper(           \
+                        __gnu_debug::__base(_First),                    \
+                        __gnu_debug::__base(_Last), _Value),            \
                       _M_message(__gnu_debug::__msg_unpartitioned)      \
                       ._M_iterator(_First, #_First)                     \
                       ._M_iterator(_Last, #_Last)                       \
 ,8 → 283,9
     w.r.t. the value _Value and predicate _Pred. */
 #define __glibcxx_check_partitioned_lower_pred(_First,_Last,_Value,_Pred) \
 __glibcxx_check_valid_range(_First,_Last);                              \
-_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower(_First, _Last, \
-                                                         _Value, _Pred), \
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower(           \
+                        __gnu_debug::__base(_First),                    \
+                        __gnu_debug::__base(_Last), _Value, _Pred),     \
                       _M_message(__gnu_debug::__msg_unpartitioned_pred) \
                       ._M_iterator(_First, #_First)                     \
                       ._M_iterator(_Last, #_Last)                       \
 ,8 → 296,9
     w.r.t. the value _Value and predicate _Pred. */
 #define __glibcxx_check_partitioned_upper_pred(_First,_Last,_Value,_Pred) \
 __glibcxx_check_valid_range(_First,_Last);                              \
-_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper(_First, _Last, \
-                                                         _Value, _Pred), \
+_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper(           \
+                        __gnu_debug::__base(_First),                    \
+                        __gnu_debug::__base(_Last), _Value, _Pred),     \
                       _M_message(__gnu_debug::__msg_unpartitioned_pred) \
                       ._M_iterator(_First, #_First)                     \
                       ._M_iterator(_Last, #_Last)                       \

 /contrib/sdk/sources/libstdc++-v3/include/debug/safe_unordered_base.h
 ,9 → 133,19
   protected:
     // Initialize with a version number of 1 and no iterators
     _Safe_unordered_container_base()
-    : _M_local_iterators(0), _M_const_local_iterators(0)
+    : _M_local_iterators(nullptr), _M_const_local_iterators(nullptr)
     { }
+    // Initialize with a version number of 1 and no iterators
+    _Safe_unordered_container_base(const _Safe_unordered_container_base&)
+    noexcept
+    : _Safe_unordered_container_base() { }
+    _Safe_unordered_container_base(_Safe_unordered_container_base&& __x)
+    noexcept
+    : _Safe_unordered_container_base()
+    { this->_M_swap(__x); }
     /** Notify all iterators that reference this container that the
         container is being destroyed. */
     ~_Safe_unordered_container_base()

 /contrib/sdk/sources/libstdc++-v3/include/exception
 ,0 → 1,156
+// Exception Handling support header for -*- C++ -*-
+// Copyright (C) 1995-2013 Free Software Foundation, Inc.
+//
+// This file is part of GCC.
+//
+// GCC is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// GCC is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+/** @file exception
+ *  This is a Standard C++ Library header.
+ */
+#ifndef __EXCEPTION__
+#define __EXCEPTION__
+#pragma GCC system_header
+#pragma GCC visibility push(default)
+#include <bits/c++config.h>
+#include <bits/atomic_lockfree_defines.h>
+extern "C++" {
+namespace std
+{
+  /**
+   * @defgroup exceptions Exceptions
+   * @ingroup diagnostics
+   *
+   * Classes and functions for reporting errors via exception classes.
+   * @{
+   */
+  /**
+   *  @brief Base class for all library exceptions.
+   *
+   *  This is the base class for all exceptions thrown by the standard
+   *  library, and by certain language expressions.  You are free to derive
+   *  your own %exception classes, or use a different hierarchy, or to
+   *  throw non-class data (e.g., fundamental types).
+   */
+  class exception
+  {
+  public:
+    exception() _GLIBCXX_USE_NOEXCEPT { }
+    virtual ~exception() _GLIBCXX_USE_NOEXCEPT;
+    /** Returns a C-style character string describing the general cause
+     *  of the current error.  */
+    virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
+  };
+  /** If an %exception is thrown which is not listed in a function's
+   *  %exception specification, one of these may be thrown.  */
+  class bad_exception : public exception
+  {
+  public:
+    bad_exception() _GLIBCXX_USE_NOEXCEPT { }
+    // This declaration is not useless:
+    // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
+    virtual ~bad_exception() _GLIBCXX_USE_NOEXCEPT;
+    // See comment in eh_exception.cc.
+    virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
+  };
+  /// If you write a replacement %terminate handler, it must be of this type.
+  typedef void (*terminate_handler) ();
+  /// If you write a replacement %unexpected handler, it must be of this type.
+  typedef void (*unexpected_handler) ();
+  /// Takes a new handler function as an argument, returns the old function.
+  terminate_handler set_terminate(terminate_handler) _GLIBCXX_USE_NOEXCEPT;
+  /** The runtime will call this function if %exception handling must be
+   *  abandoned for any reason.  It can also be called by the user.  */
+  void terminate() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__noreturn__));
+  /// Takes a new handler function as an argument, returns the old function.
+  unexpected_handler set_unexpected(unexpected_handler) _GLIBCXX_USE_NOEXCEPT;
+  /** The runtime will call this function if an %exception is thrown which
+   *  violates the function's %exception specification.  */
+  void unexpected() __attribute__ ((__noreturn__));
+  /** [18.6.4]/1:  'Returns true after completing evaluation of a
+   *  throw-expression until either completing initialization of the
+   *  exception-declaration in the matching handler or entering @c unexpected()
+   *  due to the throw; or after entering @c terminate() for any reason
+   *  other than an explicit call to @c terminate().  [Note: This includes
+   *  stack unwinding [15.2].  end note]'
+   *
+   *  2: 'When @c uncaught_exception() is true, throwing an
+   *  %exception can result in a call of @c terminate()
+   *  (15.5.1).'
+   */
+  bool uncaught_exception() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__pure__));
+  // @} group exceptions
+} // namespace std
+namespace __gnu_cxx
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+  /**
+   *  @brief A replacement for the standard terminate_handler which
+   *  prints more information about the terminating exception (if any)
+   *  on stderr.
+   *
+   *  @ingroup exceptions
+   *
+   *  Call
+   *   @code
+   *     std::set_terminate(__gnu_cxx::__verbose_terminate_handler)
+   *   @endcode
+   *  to use.  For more info, see
+   *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt02ch06s02.html
+   *
+   *  In 3.4 and later, this is on by default.
+   */
+  void __verbose_terminate_handler();
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+} // extern "C++"
+#pragma GCC visibility pop
+#if (__cplusplus >= 201103L) && (ATOMIC_INT_LOCK_FREE > 1)
+#include <bits/exception_ptr.h>
+#include <bits/nested_exception.h>
+#endif
+#endif

 /contrib/sdk/sources/libstdc++-v3/include/ext/rope
 ,8 → 1876,9
            const allocator_type& __a = allocator_type())
       : _Base(__a)
       {
-        this->_M_tree_ptr = (0 == __len) ?
-: _S_new_RopeFunction(__fn, __len, __delete_fn, __a);
+        this->_M_tree_ptr = (0 == __len)
+          ? 0
+          : _S_new_RopeFunction(__fn, __len, __delete_fn, _M_get_allocator());
       }
       rope(const rope& __x, const allocator_type& __a = allocator_type())

 /contrib/sdk/sources/libstdc++-v3/include/functional
 ,8 → 2181,15
         using _Invoke = decltype(__callable_functor(std::declval<_Functor&>())
                                  (std::declval<_ArgTypes>()...) );
+      // Used so the return type convertibility checks aren't done when
+      // performing overload resolution for copy construction/assignment.
+      template<typename _Tp>
+        using _NotSelf = __not_<is_same<_Tp, function>>;
       template<typename _Functor>
-        using _Callable = __check_func_return_type<_Invoke<_Functor>, _Res>;
+        using _Callable
+          = __and_<_NotSelf<_Functor>,
+                   __check_func_return_type<_Invoke<_Functor>, _Res>>;
       template<typename _Cond, typename _Tp>
         using _Requires = typename enable_if<_Cond::value, _Tp>::type;
 ,7 → 2330,7
        *  reference_wrapper<F>, this function will not throw.
        */
       template<typename _Functor>
-        _Requires<_Callable<_Functor>, function&>
+        _Requires<_Callable<typename decay<_Functor>::type>, function&>
         operator=(_Functor&& __f)
         {
           function(std::forward<_Functor>(__f)).swap(*this);
 ,9 → 2439,9
     {
       if (static_cast<bool>(__x))
         {
+          __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
           _M_invoker = __x._M_invoker;
           _M_manager = __x._M_manager;
-          __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
         }
     }

 /contrib/sdk/sources/libstdc++-v3/include/future
 ,12 → 351,14
       void
       _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false)
       {
-        bool __set = __ignore_failure;
+        bool __set = false;
         // all calls to this function are serialized,
         // side-effects of invoking __res only happen once
         call_once(_M_once, &_State_base::_M_do_set, this, ref(__res),
             ref(__set));
-        if (!__set)
+        if (__set)
+          _M_cond.notify_all();
+        else if (!__ignore_failure)
           __throw_future_error(int(future_errc::promise_already_satisfied));
       }
 ,7 → 473,6
           lock_guard<mutex> __lock(_M_mutex);
           _M_result.swap(__res);
         }
-        _M_cond.notify_all();
         __set = true;
       }
 ,22 → 984,25
       void
       set_value(const _Res& __r)
       {
+        auto __future = _M_future;
         auto __setter = _State::__setter(this, __r);
-        _M_future->_M_set_result(std::move(__setter));
+        __future->_M_set_result(std::move(__setter));
       }
       void
       set_value(_Res&& __r)
       {
+        auto __future = _M_future;
         auto __setter = _State::__setter(this, std::move(__r));
-        _M_future->_M_set_result(std::move(__setter));
+        __future->_M_set_result(std::move(__setter));
       }
       void
       set_exception(exception_ptr __p)
       {
+        auto __future = _M_future;
         auto __setter = _State::__setter(__p, this);
-        _M_future->_M_set_result(std::move(__setter));
+        __future->_M_set_result(std::move(__setter));
       }
     };
 ,15 → 1085,17
       void
       set_value(_Res& __r)
       {
+        auto __future = _M_future;
         auto __setter = _State::__setter(this, __r);
-        _M_future->_M_set_result(std::move(__setter));
+        __future->_M_set_result(std::move(__setter));
       }
       void
       set_exception(exception_ptr __p)
       {
+        auto __future = _M_future;
         auto __setter = _State::__setter(__p, this);
-        _M_future->_M_set_result(std::move(__setter));
+        __future->_M_set_result(std::move(__setter));
       }
     };
 ,8 → 1172,9
       void
       set_exception(exception_ptr __p)
       {
+        auto __future = _M_future;
         auto __setter = _State::__setter(__p, this);
-        _M_future->_M_set_result(std::move(__setter));
+        __future->_M_set_result(std::move(__setter));
       }
     };
 ,8 → 1200,9
   inline void
   promise<void>::set_value()
   {
+    auto __future = _M_future;
     auto __setter = _State::__setter(this);
-    _M_future->_M_set_result(std::move(__setter));
+    __future->_M_set_result(std::move(__setter));
   }
 ,8 → 1269,10
     struct __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)> final
     : __future_base::_Task_state_base<_Res(_Args...)>
     {
-      _Task_state(_Fn&& __fn, const _Alloc& __a)
-      : _Task_state_base<_Res(_Args...)>(__a), _M_impl(std::move(__fn), __a)
+      template<typename _Fn2>
+        _Task_state(_Fn2&& __fn, const _Alloc& __a)
+        : _Task_state_base<_Res(_Args...)>(__a),
+          _M_impl(std::forward<_Fn2>(__fn), __a)
       { }
     private:
 ,8 → 1302,9
       struct _Impl : _Alloc
       {
-        _Impl(_Fn&& __fn, const _Alloc& __a)
-          : _Alloc(__a), _M_fn(std::move(__fn)) { }
+        template<typename _Fn2>
+          _Impl(_Fn2&& __fn, const _Alloc& __a)
+          : _Alloc(__a), _M_fn(std::forward<_Fn2>(__fn)) { }
         _Fn _M_fn;
       } _M_impl;
     };
 ,8 → 1313,9
       static shared_ptr<__future_base::_Task_state_base<_Signature>>
       __create_task_state(_Fn&& __fn, const _Alloc& __a)
       {
-        typedef __future_base::_Task_state<_Fn, _Alloc, _Signature> _State;
-        return std::allocate_shared<_State>(__a, std::move(__fn), __a);
+      typedef typename decay<_Fn>::type _Fn2;
+      typedef __future_base::_Task_state<_Fn2, _Alloc, _Signature> _State;
+      return std::allocate_shared<_State>(__a, std::forward<_Fn>(__fn), __a);
       }
   template<typename _Fn, typename _Alloc, typename _Res, typename... _Args>
 ,7 → 1356,8
                __constrain_pkgdtask<packaged_task, _Fn>::__type>
         explicit
         packaged_task(_Fn&& __fn)
-        : packaged_task(allocator_arg, std::allocator<int>(), std::move(__fn))
+        : packaged_task(allocator_arg, std::allocator<int>(),
+                        std::forward<_Fn>(__fn))
         { }
       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 ,7 → 1417,8
       operator()(_ArgTypes... __args)
       {
         __future_base::_State_base::_S_check(_M_state);
-        _M_state->_M_run(std::forward<_ArgTypes>(__args)...);
+        auto __state = _M_state;
+        __state->_M_run(std::forward<_ArgTypes>(__args)...);
       }
       void

/contrib/sdk/sources/libstdc++-v3/include/gstdint.h
1,4 → 1,4
/* generated for xgcc.exe (GCC) 4.8.2 */
/* generated for xgcc.exe (GCC) 4.8.5 */

#ifndef GCC_GENERATED_STDINT_H
#define GCC_GENERATED_STDINT_H 1

 /contrib/sdk/sources/libstdc++-v3/include/initializer_list
 ,0 → 1,107
+// std::initializer_list support -*- C++ -*-
+// Copyright (C) 2008-2013 Free Software Foundation, Inc.
+//
+// This file is part of GCC.
+//
+// GCC is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// GCC is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+/** @file initializer_list
+ *  This is a Standard C++ Library header.
+ */
+#ifndef _INITIALIZER_LIST
+#define _INITIALIZER_LIST
+#pragma GCC system_header
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else // C++0x
+#pragma GCC visibility push(default)
+#include <bits/c++config.h>
+namespace std
+{
+  /// initializer_list
+  template<class _E>
+    class initializer_list
+    {
+    public:
+      typedef _E                value_type;
+      typedef const _E&         reference;
+      typedef const _E&         const_reference;
+      typedef size_t            size_type;
+      typedef const _E*         iterator;
+      typedef const _E*         const_iterator;
+    private:
+      iterator                  _M_array;
+      size_type                 _M_len;
+      // The compiler can call a private constructor.
+      constexpr initializer_list(const_iterator __a, size_type __l)
+      : _M_array(__a), _M_len(__l) { }
+    public:
+      constexpr initializer_list() noexcept
+      : _M_array(0), _M_len(0) { }
+      // Number of elements.
+      constexpr size_type
+      size() const noexcept { return _M_len; }
+      // First element.
+      constexpr const_iterator
+      begin() const noexcept { return _M_array; }
+      // One past the last element.
+      constexpr const_iterator
+      end() const noexcept { return begin() + size(); }
+    };
+  /**
+   *  @brief  Return an iterator pointing to the first element of
+   *          the initilizer_list.
+   *  @param  __ils  Initializer list.
+   */
+  template<class _Tp>
+    constexpr const _Tp*
+    begin(initializer_list<_Tp> __ils) noexcept
+    { return __ils.begin(); }
+  /**
+   *  @brief  Return an iterator pointing to one past the last element
+   *          of the initilizer_list.
+   *  @param  __ils  Initializer list.
+   */
+  template<class _Tp>
+    constexpr const _Tp*
+    end(initializer_list<_Tp> __ils) noexcept
+    { return __ils.end(); }
+}
+#pragma GCC visibility pop
+#endif // C++11
+#endif // _INITIALIZER_LIST

 /contrib/sdk/sources/libstdc++-v3/include/iostream
 ,13 → 48,13
    *
    *  The &lt;iostream&gt; header declares the eight <em>standard stream
    *  objects</em>.  For other declarations, see
-   *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch24.html
+   *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/io.html
    *  and the @link iosfwd I/O forward declarations @endlink
    *
    *  They are required by default to cooperate with the global C
    *  library's @c FILE streams, and to be available during program
-   *  startup and termination. For more information, see the HOWTO
-   *  linked to above.
+   *  startup and termination. For more information, see the section of the
+   *  manual linked to above.
   */
   //@{
   extern istream cin;           /// Linked to standard input

 /contrib/sdk/sources/libstdc++-v3/include/istream
 ,7 → 870,10
   template<typename _CharT, typename _Traits, typename _Tp>
     inline basic_istream<_CharT, _Traits>&
     operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
-    { return (__is >> __x); }
+    {
+      __is >> __x;
+      return __is;
+    }
 #endif // C++11
 _GLIBCXX_END_NAMESPACE_VERSION

/contrib/sdk/sources/libstdc++-v3/include/mingw32/bits/c++locale_internal.h
File deleted

/contrib/sdk/sources/libstdc++-v3/include/mingw32/bits/compatibility.h
File deleted

 /contrib/sdk/sources/libstdc++-v3/include/mingw32/bits/c++config.h
 ,7 → 31,7
 #define _GLIBCXX_CXX_CONFIG_H 1
 // The current version of the C++ library in compressed ISO date format.
-#define __GLIBCXX__ 20131016
+#define __GLIBCXX__ 20150623
 // Macros for various attributes.
 //   _GLIBCXX_PURE
 ,7 → 599,7
 #define _GLIBCXX_HAVE_FABSL 1
 /* Define to 1 if you have the <fenv.h> header file. */
-#define _GLIBCXX_HAVE_FENV_H 1
+/* #undef _GLIBCXX_HAVE_FENV_H */
 /* Define to 1 if you have the `finite' function. */
 #define _GLIBCXX_HAVE_FINITE 1
 ,7 → 653,7
 #define _GLIBCXX_HAVE_HYPOTL 1
 /* Define if you have the iconv() function. */
-/* #undef _GLIBCXX_HAVE_ICONV */
+#define _GLIBCXX_HAVE_ICONV 1
 /* Define to 1 if you have the <ieeefp.h> header file. */
 /* #undef _GLIBCXX_HAVE_IEEEFP_H */
 ,10 → 737,10
 #define _GLIBCXX_HAVE_LOGL 1
 /* Define to 1 if you have the <machine/endian.h> header file. */
-#define _GLIBCXX_HAVE_MACHINE_ENDIAN_H 1
+/* #undef _GLIBCXX_HAVE_MACHINE_ENDIAN_H */
 /* Define to 1 if you have the <machine/param.h> header file. */
-#define _GLIBCXX_HAVE_MACHINE_PARAM_H 1
+/* #undef _GLIBCXX_HAVE_MACHINE_PARAM_H */
 /* Define if mbstate_t exists in wchar.h. */
 #define _GLIBCXX_HAVE_MBSTATE_T 1
 ,7 → 824,7
 /* #undef _GLIBCXX_HAVE_STRERROR_L */
 /* Define if strerror_r is available in <string.h>. */
-/* #undef _GLIBCXX_HAVE_STRERROR_R */
+#define _GLIBCXX_HAVE_STRERROR_R 1
 /* Define to 1 if you have the <strings.h> header file. */
 #define _GLIBCXX_HAVE_STRINGS_H 1
 ,7 → 836,7
 #define _GLIBCXX_HAVE_STRTOF 1
 /* Define to 1 if you have the `strtold' function. */
-//#define _GLIBCXX_HAVE_STRTOLD 1
+#define _GLIBCXX_HAVE_STRTOLD 1
 /* Define if strxfrm_l is available in <string.h>. */
 /* #undef _GLIBCXX_HAVE_STRXFRM_L */
 ,7 → 909,7
 /* #undef _GLIBCXX_HAVE_TGMATH_H */
 /* Define to 1 if the target supports thread-local storage. */
-/* #undef _GLIBCXX_HAVE_TLS */
+#define _GLIBCXX_HAVE_TLS 1
 /* Define to 1 if you have the <unistd.h> header file. */
 #define _GLIBCXX_HAVE_UNISTD_H 1
 ,7 → 1131,7
 /* #undef _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL */
 /* Define as const if the declaration of iconv() needs const. */
-/* #undef _GLIBCXX_ICONV_CONST */
+#define _GLIBCXX_ICONV_CONST
 /* Define to the sub-directory in which libtool stores uninstalled libraries.
    */
 ,7 → 1292,7
 #define _GLIBCXX_USE_FLOAT128 1
 /* Defined if gettimeofday is available. */
-#define _GLIBCXX_USE_GETTIMEOFDAY 1
+/* #undef _GLIBCXX_USE_GETTIMEOFDAY */
 /* Define if get_nprocs is available in <sys/sysinfo.h>. */
 /* #undef _GLIBCXX_USE_GET_NPROCS */
 ,7 → 1332,7
 /* #undef _GLIBCXX_USE_SYSCTL_HW_NCPU */
 /* Define if code specialized for wchar_t should be used. */
-//#define _GLIBCXX_USE_WCHAR_T 1
+#define _GLIBCXX_USE_WCHAR_T 1
 /* Define to 1 if a verbose library is built, or 0 otherwise. */
 #define _GLIBCXX_VERBOSE 1

 /contrib/sdk/sources/libstdc++-v3/include/mingw32/bits/opt_random.h
 ,4 → 1,4
-// Optimizations for random number handling, generic version -*- C++ -*-
+// Optimizations for random number functions, x86 version -*- C++ -*-
 // Copyright (C) 2012-2013 Free Software Foundation, Inc.
 //
 ,9 → 30,190
 #ifndef _BITS_OPT_RANDOM_H
 #define _BITS_OPT_RANDOM_H 1
+#include <x86intrin.h>
 #pragma GCC system_header
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+#ifdef __SSE3__
+  template<>
+    template<typename _UniformRandomNumberGenerator>
+      void
+      normal_distribution<double>::
+      __generate(typename normal_distribution<double>::result_type* __f,
+                 typename normal_distribution<double>::result_type* __t,
+                 _UniformRandomNumberGenerator& __urng,
+                 const param_type& __param)
+      {
+        typedef uint64_t __uctype;
+        if (__f == __t)
+          return;
+        if (_M_saved_available)
+          {
+            _M_saved_available = false;
+            *__f++ = _M_saved * __param.stddev() + __param.mean();
+            if (__f == __t)
+              return;
+          }
+        constexpr uint64_t __maskval = 0xfffffffffffffull;
+        static const __m128i __mask = _mm_set1_epi64x(__maskval);
+        static const __m128i __two = _mm_set1_epi64x(0x4000000000000000ull);
+        static const __m128d __three = _mm_set1_pd(3.0);
+        const __m128d __av = _mm_set1_pd(__param.mean());
+        const __uctype __urngmin = __urng.min();
+        const __uctype __urngmax = __urng.max();
+        const __uctype __urngrange = __urngmax - __urngmin;
+        const __uctype __uerngrange = __urngrange + 1;
+        while (__f + 1 < __t)
+          {
+            double __le;
+            __m128d __x;
+            do
+              {
+                union
+                {
+                  __m128i __i;
+                  __m128d __d;
+                } __v;
+                if (__urngrange > __maskval)
+                  {
+                    if (__detail::_Power_of_2(__uerngrange))
+                      __v.__i = _mm_and_si128(_mm_set_epi64x(__urng(),
+                                                             __urng()),
+                                              __mask);
+                    else
+                      {
+                        const __uctype __uerange = __maskval + 1;
+                        const __uctype __scaling = __urngrange / __uerange;
+                        const __uctype __past = __uerange * __scaling;
+                        uint64_t __v1;
+                        do
+                          __v1 = __uctype(__urng()) - __urngmin;
+                        while (__v1 >= __past);
+                        __v1 /= __scaling;
+                        uint64_t __v2;
+                        do
+                          __v2 = __uctype(__urng()) - __urngmin;
+                        while (__v2 >= __past);
+                        __v2 /= __scaling;
+                        __v.__i = _mm_set_epi64x(__v1, __v2);
+                      }
+                  }
+                else if (__urngrange == __maskval)
+                  __v.__i = _mm_set_epi64x(__urng(), __urng());
+                else if ((__urngrange + 2) * __urngrange >= __maskval
+                         && __detail::_Power_of_2(__uerngrange))
+                  {
+                    uint64_t __v1 = __urng() * __uerngrange + __urng();
+                    uint64_t __v2 = __urng() * __uerngrange + __urng();
+                    __v.__i = _mm_and_si128(_mm_set_epi64x(__v1, __v2),
+                                            __mask);
+                  }
+                else
+                  {
+                    size_t __nrng = 2;
+                    __uctype __high = __maskval / __uerngrange / __uerngrange;
+                    while (__high > __uerngrange)
+                      {
+                        ++__nrng;
+                        __high /= __uerngrange;
+                      }
+                    const __uctype __highrange = __high + 1;
+                    const __uctype __scaling = __urngrange / __highrange;
+                    const __uctype __past = __highrange * __scaling;
+                    __uctype __tmp;
+                    uint64_t __v1;
+                    do
+                      {
+                        do
+                          __tmp = __uctype(__urng()) - __urngmin;
+                        while (__tmp >= __past);
+                        __v1 = __tmp / __scaling;
+                        for (size_t __cnt = 0; __cnt < __nrng; ++__cnt)
+                          {
+                            __tmp = __v1;
+                            __v1 *= __uerngrange;
+                            __v1 += __uctype(__urng()) - __urngmin;
+                          }
+                      }
+                    while (__v1 > __maskval || __v1 < __tmp);
+                    uint64_t __v2;
+                    do
+                      {
+                        do
+                          __tmp = __uctype(__urng()) - __urngmin;
+                        while (__tmp >= __past);
+                        __v2 = __tmp / __scaling;
+                        for (size_t __cnt = 0; __cnt < __nrng; ++__cnt)
+                          {
+                            __tmp = __v2;
+                            __v2 *= __uerngrange;
+                            __v2 += __uctype(__urng()) - __urngmin;
+                          }
+                      }
+                    while (__v2 > __maskval || __v2 < __tmp);
+                    __v.__i = _mm_set_epi64x(__v1, __v2);
+                  }
+                __v.__i = _mm_or_si128(__v.__i, __two);
+                __x = _mm_sub_pd(__v.__d, __three);
+                __m128d __m = _mm_mul_pd(__x, __x);
+                __le = _mm_cvtsd_f64(_mm_hadd_pd (__m, __m));
+              }
+            while (__le == 0.0 || __le >= 1.0);
+            double __mult = (std::sqrt(-2.0 * std::log(__le) / __le)
+                             * __param.stddev());
+            __x = _mm_add_pd(_mm_mul_pd(__x, _mm_set1_pd(__mult)), __av);
+            _mm_storeu_pd(__f, __x);
+            __f += 2;
+          }
+        if (__f != __t)
+          {
+            result_type __x, __y, __r2;
+            __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+              __aurng(__urng);
+            do
+              {
+                __x = result_type(2.0) * __aurng() - 1.0;
+                __y = result_type(2.0) * __aurng() - 1.0;
+                __r2 = __x * __x + __y * __y;
+              }
+            while (__r2 > 1.0 || __r2 == 0.0);
+            const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
+            _M_saved = __x * __mult;
+            _M_saved_available = true;
+            *__f = __y * __mult * __param.stddev() + __param.mean();
+          }
+      }
+#endif
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
 #endif // _BITS_OPT_RANDOM_H

/contrib/sdk/sources/libstdc++-v3/include/mingw32/bits/os_defines.h
75,4 → 75,7
#define _GLIBCXX_LLP64 1
#endif

// See libstdc++/59807
#define _GTHREAD_USE_MUTEX_INIT_FUNC 1

#endif

 /contrib/sdk/sources/libstdc++-v3/include/mingw32/ext/opt_random.h
 ,4 → 1,4
-// Optimizations for random number extensions, generic version -*- C++ -*-
+// Optimizations for random number extensions, x86 version -*- C++ -*-
 // Copyright (C) 2012-2013 Free Software Foundation, Inc.
 //
 ,7 → 22,7
 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 // <http://www.gnu.org/licenses/>.
-/** @file ext/opt_random.h
+/** @file ext/random.tcc
  *  This is an internal header file, included by other library headers.
  *  Do not attempt to use it directly. @headername{ext/random}
  */
 ,7 → 32,109
 #pragma GCC system_header
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#ifdef __SSE2__
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+  namespace {
+    template<size_t __sl1, size_t __sl2, size_t __sr1, size_t __sr2,
+             uint32_t __msk1, uint32_t __msk2, uint32_t __msk3, uint32_t __msk4>
+      inline __m128i __sse2_recursion(__m128i __a, __m128i __b,
+                                      __m128i __c, __m128i __d)
+      {
+        __m128i __y = _mm_srli_epi32(__b, __sr1);
+        __m128i __z = _mm_srli_si128(__c, __sr2);
+        __m128i __v = _mm_slli_epi32(__d, __sl1);
+        __z = _mm_xor_si128(__z, __a);
+        __z = _mm_xor_si128(__z, __v);
+        __m128i __x = _mm_slli_si128(__a, __sl2);
+        __y = _mm_and_si128(__y, _mm_set_epi32(__msk4, __msk3, __msk2, __msk1));
+        __z = _mm_xor_si128(__z, __x);
+        return _mm_xor_si128(__z, __y);
+      }
+  }
+#define _GLIBCXX_OPT_HAVE_RANDOM_SFMT_GEN_READ  1
+  template<typename _UIntType, size_t __m,
+           size_t __pos1, size_t __sl1, size_t __sl2,
+           size_t __sr1, size_t __sr2,
+           uint32_t __msk1, uint32_t __msk2,
+           uint32_t __msk3, uint32_t __msk4,
+           uint32_t __parity1, uint32_t __parity2,
+           uint32_t __parity3, uint32_t __parity4>
+    void simd_fast_mersenne_twister_engine<_UIntType, __m,
+                                           __pos1, __sl1, __sl2, __sr1, __sr2,
+                                           __msk1, __msk2, __msk3, __msk4,
+                                           __parity1, __parity2, __parity3,
+                                           __parity4>::
+    _M_gen_rand(void)
+    {
+      __m128i __r1 = _mm_load_si128(&_M_state[_M_nstate - 2]);
+      __m128i __r2 = _mm_load_si128(&_M_state[_M_nstate - 1]);
+      size_t __i;
+      for (__i = 0; __i < _M_nstate - __pos1; ++__i)
+        {
+          __m128i __r = __sse2_recursion<__sl1, __sl2, __sr1, __sr2,
+                                         __msk1, __msk2, __msk3, __msk4>
+            (_M_state[__i], _M_state[__i + __pos1], __r1, __r2);
+          _mm_store_si128(&_M_state[__i], __r);
+          __r1 = __r2;
+          __r2 = __r;
+        }
+      for (; __i < _M_nstate; ++__i)
+        {
+          __m128i __r = __sse2_recursion<__sl1, __sl2, __sr1, __sr2,
+                                         __msk1, __msk2, __msk3, __msk4>
+            (_M_state[__i], _M_state[__i + __pos1 - _M_nstate], __r1, __r2);
+          _mm_store_si128(&_M_state[__i], __r);
+          __r1 = __r2;
+          __r2 = __r;
+        }
+      _M_pos = 0;
+    }
+#define _GLIBCXX_OPT_HAVE_RANDOM_SFMT_OPERATOREQUAL     1
+  template<typename _UIntType, size_t __m,
+           size_t __pos1, size_t __sl1, size_t __sl2,
+           size_t __sr1, size_t __sr2,
+           uint32_t __msk1, uint32_t __msk2,
+           uint32_t __msk3, uint32_t __msk4,
+           uint32_t __parity1, uint32_t __parity2,
+           uint32_t __parity3, uint32_t __parity4>
+    bool
+    operator==(const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
+               __m, __pos1, __sl1, __sl2, __sr1, __sr2,
+               __msk1, __msk2, __msk3, __msk4,
+               __parity1, __parity2, __parity3, __parity4>& __lhs,
+               const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
+               __m, __pos1, __sl1, __sl2, __sr1, __sr2,
+               __msk1, __msk2, __msk3, __msk4,
+               __parity1, __parity2, __parity3, __parity4>& __rhs)
+    {
+      __m128i __res = _mm_cmpeq_epi8(__lhs._M_state[0], __rhs._M_state[0]);
+      for (size_t __i = 1; __i < __lhs._M_nstate; ++__i)
+        __res = _mm_and_si128(__res, _mm_cmpeq_epi8(__lhs._M_state[__i],
+                                                    __rhs._M_state[__i]));
+      return (_mm_movemask_epi8(__res) == 0xffff
+              && __lhs._M_pos == __rhs._M_pos);
+    }
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+#endif // __SSE2__
+#endif // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 #endif // _EXT_OPT_RANDOM_H

 /contrib/sdk/sources/libstdc++-v3/include/new
 ,0 → 1,122
+// The -*- C++ -*- dynamic memory management header.
+// Copyright (C) 1994-2013 Free Software Foundation, Inc.
+// This file is part of GCC.
+//
+// GCC is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// GCC is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+/** @file new
+ *  This is a Standard C++ Library header.
+ *
+ *  The header @c new defines several functions to manage dynamic memory and
+ *  handling memory allocation errors; see
+ *  http://gcc.gnu.org/onlinedocs/libstdc++/18_support/howto.html#4 for more.
+ */
+#ifndef _NEW
+#define _NEW
+#pragma GCC system_header
+#include <bits/c++config.h>
+#include <exception>
+#pragma GCC visibility push(default)
+extern "C++" {
+namespace std
+{
+  /**
+   *  @brief  Exception possibly thrown by @c new.
+   *  @ingroup exceptions
+   *
+   *  @c bad_alloc (or classes derived from it) is used to report allocation
+   *  errors from the throwing forms of @c new.  */
+  class bad_alloc : public exception
+  {
+  public:
+    bad_alloc() throw() { }
+    // This declaration is not useless:
+    // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
+    virtual ~bad_alloc() throw();
+    // See comment in eh_exception.cc.
+    virtual const char* what() const throw();
+  };
+  struct nothrow_t { };
+  extern const nothrow_t nothrow;
+  /** If you write your own error handler to be called by @c new, it must
+   *  be of this type.  */
+  typedef void (*new_handler)();
+  /// Takes a replacement handler as the argument, returns the
+  /// previous handler.
+  new_handler set_new_handler(new_handler) throw();
+} // namespace std
+//@{
+/** These are replaceable signatures:
+ *  - normal single new and delete (no arguments, throw @c bad_alloc on error)
+ *  - normal array new and delete (same)
+ *  - @c nothrow single new and delete (take a @c nothrow argument, return
+ *    @c NULL on error)
+ *  - @c nothrow array new and delete (same)
+ *
+ *  Placement new and delete signatures (take a memory address argument,
+ *  does nothing) may not be replaced by a user's program.
+*/
+void* operator new(std::size_t) _GLIBCXX_THROW (std::bad_alloc)
+  __attribute__((__externally_visible__));
+void* operator new[](std::size_t) _GLIBCXX_THROW (std::bad_alloc)
+  __attribute__((__externally_visible__));
+void operator delete(void*) _GLIBCXX_USE_NOEXCEPT
+  __attribute__((__externally_visible__));
+void operator delete[](void*) _GLIBCXX_USE_NOEXCEPT
+  __attribute__((__externally_visible__));
+void* operator new(std::size_t, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT
+  __attribute__((__externally_visible__));
+void* operator new[](std::size_t, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT
+  __attribute__((__externally_visible__));
+void operator delete(void*, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT
+  __attribute__((__externally_visible__));
+void operator delete[](void*, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT
+  __attribute__((__externally_visible__));
+// Default placement versions of operator new.
+inline void* operator new(std::size_t, void* __p) _GLIBCXX_USE_NOEXCEPT
+{ return __p; }
+inline void* operator new[](std::size_t, void* __p) _GLIBCXX_USE_NOEXCEPT
+{ return __p; }
+// Default placement versions of operator delete.
+inline void operator delete  (void*, void*) _GLIBCXX_USE_NOEXCEPT { }
+inline void operator delete[](void*, void*) _GLIBCXX_USE_NOEXCEPT { }
+//@}
+} // extern "C++"
+#pragma GCC visibility pop
+#endif

 /contrib/sdk/sources/libstdc++-v3/include/ostream
 ,7 → 600,10
   template<typename _CharT, typename _Traits, typename _Tp>
     inline basic_ostream<_CharT, _Traits>&
     operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
-    { return (__os << __x); }
+    {
+      __os << __x;
+      return __os;
+    }
 #endif // C++11
 _GLIBCXX_END_NAMESPACE_VERSION

 /contrib/sdk/sources/libstdc++-v3/include/scoped_allocator
 ,6 → 105,8
       __inner_type_impl() = default;
       __inner_type_impl(const __inner_type_impl&) = default;
       __inner_type_impl(__inner_type_impl&&) = default;
+      __inner_type_impl& operator=(const __inner_type_impl&) = default;
+      __inner_type_impl& operator=(__inner_type_impl&&) = default;
       template<typename _Alloc>
       __inner_type_impl(const __inner_type_impl<_Alloc>& __other)
 ,6 → 138,8
       __inner_type_impl() = default;
       __inner_type_impl(const __inner_type_impl&) = default;
       __inner_type_impl(__inner_type_impl&&) = default;
+      __inner_type_impl& operator=(const __inner_type_impl&) = default;
+      __inner_type_impl& operator=(__inner_type_impl&&) = default;
       template<typename... _Allocs>
       __inner_type_impl(const __inner_type_impl<_Allocs...>& __other)
 ,6 → 314,12
           _M_inner(std::move(__other._M_inner))
         { }
+      scoped_allocator_adaptor&
+      operator=(const scoped_allocator_adaptor&) = default;
+      scoped_allocator_adaptor&
+      operator=(scoped_allocator_adaptor&&) = default;
       inner_allocator_type& inner_allocator() noexcept
       { return _M_inner._M_get(this); }

 /contrib/sdk/sources/libstdc++-v3/include/tr1/cmath
 ,143 → 158,143
   // functions
   using ::acosh;
   using ::acoshf;
-  using ::acoshl;
+//  using ::acoshl;
   using ::asinh;
   using ::asinhf;
-  using ::asinhl;
+//  using ::asinhl;
   using ::atanh;
   using ::atanhf;
-  using ::atanhl;
+//  using ::atanhl;
   using ::cbrt;
   using ::cbrtf;
-  using ::cbrtl;
+//  using ::cbrtl;
   using ::copysign;
   using ::copysignf;
-  using ::copysignl;
+//  using ::copysignl;
   using ::erf;
   using ::erff;
-  using ::erfl;
+//  using ::erfl;
   using ::erfc;
   using ::erfcf;
-  using ::erfcl;
+//  using ::erfcl;
   using ::exp2;
   using ::exp2f;
-  using ::exp2l;
+//  using ::exp2l;
   using ::expm1;
   using ::expm1f;
-  using ::expm1l;
+//  using ::expm1l;
   using ::fdim;
   using ::fdimf;
-  using ::fdiml;
+//  using ::fdiml;
   using ::fma;
   using ::fmaf;
-  using ::fmal;
+//  using ::fmal;
   using ::fmax;
   using ::fmaxf;
-  using ::fmaxl;
+//  using ::fmaxl;
   using ::fmin;
   using ::fminf;
-  using ::fminl;
+//  using ::fminl;
   using ::hypot;
   using ::hypotf;
-  using ::hypotl;
+//  using ::hypotl;
   using ::ilogb;
   using ::ilogbf;
-  using ::ilogbl;
+//  using ::ilogbl;
   using ::lgamma;
   using ::lgammaf;
-  using ::lgammal;
+//  using ::lgammal;
   using ::llrint;
   using ::llrintf;
-  using ::llrintl;
+//  using ::llrintl;
   using ::llround;
   using ::llroundf;
-  using ::llroundl;
+//  using ::llroundl;
   using ::log1p;
   using ::log1pf;
-  using ::log1pl;
+//  using ::log1pl;
   using ::log2;
   using ::log2f;
-  using ::log2l;
+//  using ::log2l;
   using ::logb;
   using ::logbf;
-  using ::logbl;
+//  using ::logbl;
   using ::lrint;
   using ::lrintf;
-  using ::lrintl;
+//  using ::lrintl;
   using ::lround;
   using ::lroundf;
-  using ::lroundl;
+//  using ::lroundl;
   using ::nan;
   using ::nanf;
-  using ::nanl;
+//  using ::nanl;
   using ::nearbyint;
   using ::nearbyintf;
-  using ::nearbyintl;
+//  using ::nearbyintl;
   using ::nextafter;
   using ::nextafterf;
-  using ::nextafterl;
+//  using ::nextafterl;
-  using ::nexttoward;
-  using ::nexttowardf;
-  using ::nexttowardl;
+//  using ::nexttoward;
+//  using ::nexttowardf;
+//  using ::nexttowardl;
   using ::remainder;
   using ::remainderf;
-  using ::remainderl;
+//  using ::remainderl;
   using ::remquo;
   using ::remquof;
-  using ::remquol;
+//  using ::remquol;
   using ::rint;
   using ::rintf;
-  using ::rintl;
+//  using ::rintl;
   using ::round;
   using ::roundf;
-  using ::roundl;
+//  using ::roundl;
   using ::scalbln;
   using ::scalblnf;
-  using ::scalblnl;
+//  using ::scalblnl;
   using ::scalbn;
   using ::scalbnf;
-  using ::scalbnl;
+//  using ::scalbnl;
   using ::tgamma;
   using ::tgammaf;
-  using ::tgammal;
+//  using ::tgammal;
   using ::trunc;
   using ::truncf;
-  using ::truncl;
+//  using ::truncl;
 #endif

 /contrib/sdk/sources/libstdc++-v3/include/tr1/functional
 ,9 → 2112,9
     {
       if (static_cast<bool>(__x))
         {
+          __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
           _M_invoker = __x._M_invoker;
           _M_manager = __x._M_manager;
-          __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
         }
     }
 ,9 → 2130,9
         if (_My_handler::_M_not_empty_function(__f))
           {
+            _My_handler::_M_init_functor(_M_functor, __f);
             _M_invoker = &_My_handler::_M_invoke;
             _M_manager = &_My_handler::_M_manager;
-            _My_handler::_M_init_functor(_M_functor, __f);
           }
       }

 /contrib/sdk/sources/libstdc++-v3/include/tuple
 ,21 → 88,22
       constexpr _Head_base(const _Head& __h)
       : _Head(__h) { }
-      template<typename _UHead, typename = typename
-               enable_if<!is_convertible<_UHead,
-                                         __uses_alloc_base>::value>::type>
+      constexpr _Head_base(const _Head_base&) = default;
+      constexpr _Head_base(_Head_base&&) = default;
+      template<typename _UHead>
         constexpr _Head_base(_UHead&& __h)
         : _Head(std::forward<_UHead>(__h)) { }
-      _Head_base(__uses_alloc0)
+      _Head_base(allocator_arg_t, __uses_alloc0)
       : _Head() { }
       template<typename _Alloc>
-        _Head_base(__uses_alloc1<_Alloc> __a)
+        _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
         : _Head(allocator_arg, *__a._M_a) { }
       template<typename _Alloc>
-        _Head_base(__uses_alloc2<_Alloc> __a)
+        _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
         : _Head(*__a._M_a) { }
       template<typename _UHead>
 ,21 → 134,22
       constexpr _Head_base(const _Head& __h)
       : _M_head_impl(__h) { }
-      template<typename _UHead, typename = typename
-               enable_if<!is_convertible<_UHead,
-                                         __uses_alloc_base>::value>::type>
+      constexpr _Head_base(const _Head_base&) = default;
+      constexpr _Head_base(_Head_base&&) = default;
+      template<typename _UHead>
         constexpr _Head_base(_UHead&& __h)
         : _M_head_impl(std::forward<_UHead>(__h)) { }
-      _Head_base(__uses_alloc0)
+      _Head_base(allocator_arg_t, __uses_alloc0)
       : _M_head_impl() { }
       template<typename _Alloc>
-        _Head_base(__uses_alloc1<_Alloc> __a)
+        _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
         : _M_head_impl(allocator_arg, *__a._M_a) { }
       template<typename _Alloc>
-        _Head_base(__uses_alloc2<_Alloc> __a)
+        _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
         : _M_head_impl(*__a._M_a) { }
       template<typename _UHead>
 ,7 → 287,7
       template<typename _Alloc>
         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
         : _Inherited(__tag, __a),
-          _Base(__use_alloc<_Head>(__a)) { }
+          _Base(__tag, __use_alloc<_Head>(__a)) { }
       template<typename _Alloc>
         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 ,7 → 757,7
                       typename tuple_element<__i, tuple<_Elements...>>::type
                     >::type
     get(tuple<_Elements...>& __t) noexcept
-    { return __get_helper<__i>(__t); }
+    { return std::__get_helper<__i>(__t); }
   template<std::size_t __i, typename... _Elements>
     constexpr typename __add_c_ref<
 ,7 → 764,7
                       typename tuple_element<__i, tuple<_Elements...>>::type
                     >::type
     get(const tuple<_Elements...>& __t) noexcept
-    { return __get_helper<__i>(__t); }
+    { return std::__get_helper<__i>(__t); }
   template<std::size_t __i, typename... _Elements>
     constexpr typename __add_r_ref<

 /contrib/sdk/sources/libstdc++-v3/include/typeinfo
 ,0 → 1,222
+// RTTI support for -*- C++ -*-
+// Copyright (C) 1994-2013 Free Software Foundation, Inc.
+//
+// This file is part of GCC.
+//
+// GCC is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// GCC is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+/** @file typeinfo
+ *  This is a Standard C++ Library header.
+ */
+#ifndef _TYPEINFO
+#define _TYPEINFO
+#pragma GCC system_header
+#include <exception>
+#if __cplusplus >= 201103L
+#include <bits/hash_bytes.h>
+#endif
+#pragma GCC visibility push(default)
+extern "C++" {
+namespace __cxxabiv1
+{
+  class __class_type_info;
+} // namespace __cxxabiv1
+// Determine whether typeinfo names for the same type are merged (in which
+// case comparison can just compare pointers) or not (in which case strings
+// must be compared), and whether comparison is to be implemented inline or
+// not.  We used to do inline pointer comparison by default if weak symbols
+// are available, but even with weak symbols sometimes names are not merged
+// when objects are loaded with RTLD_LOCAL, so now we always use strcmp by
+// default.  For ABI compatibility, we do the strcmp inline if weak symbols
+// are available, and out-of-line if not.  Out-of-line pointer comparison
+// is used where the object files are to be portable to multiple systems,
+// some of which may not be able to use pointer comparison, but the
+// particular system for which libstdc++ is being built can use pointer
+// comparison; in particular for most ARM EABI systems, where the ABI
+// specifies out-of-line comparison.  The compiler's target configuration
+// can override the defaults by defining __GXX_TYPEINFO_EQUALITY_INLINE to
+// 1 or 0 to indicate whether or not comparison is inline, and
+// __GXX_MERGED_TYPEINFO_NAMES to 1 or 0 to indicate whether or not pointer
+// comparison can be used.
+#ifndef __GXX_MERGED_TYPEINFO_NAMES
+// By default, typeinfo names are not merged.
+#define __GXX_MERGED_TYPEINFO_NAMES 0
+#endif
+// By default follow the old inline rules to avoid ABI changes.
+#ifndef __GXX_TYPEINFO_EQUALITY_INLINE
+  #if !__GXX_WEAK__
+    #define __GXX_TYPEINFO_EQUALITY_INLINE 0
+  #else
+    #define __GXX_TYPEINFO_EQUALITY_INLINE 1
+  #endif
+#endif
+namespace std
+{
+  /**
+   *  @brief  Part of RTTI.
+   *
+   *  The @c type_info class describes type information generated by
+   *  an implementation.
+  */
+  class type_info
+  {
+  public:
+    /** Destructor first. Being the first non-inline virtual function, this
+     *  controls in which translation unit the vtable is emitted. The
+     *  compiler makes use of that information to know where to emit
+     *  the runtime-mandated type_info structures in the new-abi.  */
+    virtual ~type_info();
+    /** Returns an @e implementation-defined byte string; this is not
+     *  portable between compilers!  */
+    const char* name() const _GLIBCXX_NOEXCEPT
+    { return __name[0] == '*' ? __name + 1 : __name; }
+#if !__GXX_TYPEINFO_EQUALITY_INLINE
+    // In old abi, or when weak symbols are not supported, there can
+    // be multiple instances of a type_info object for one
+    // type. Uniqueness must use the _name value, not object address.
+    bool before(const type_info& __arg) const _GLIBCXX_NOEXCEPT;
+    bool operator==(const type_info& __arg) const _GLIBCXX_NOEXCEPT;
+#else
+  #if !__GXX_MERGED_TYPEINFO_NAMES
+    /** Returns true if @c *this precedes @c __arg in the implementation's
+     *  collation order.  */
+    // Even with the new abi, on systems that support dlopen
+    // we can run into cases where type_info names aren't merged,
+    // so we still need to do string comparison.
+    bool before(const type_info& __arg) const _GLIBCXX_NOEXCEPT
+    { return (__name[0] == '*' && __arg.__name[0] == '*')
+        ? __name < __arg.__name
+        : __builtin_strcmp (__name, __arg.__name) < 0; }
+    bool operator==(const type_info& __arg) const _GLIBCXX_NOEXCEPT
+    {
+      return ((__name == __arg.__name)
+              || (__name[0] != '*' &&
+                  __builtin_strcmp (__name, __arg.__name) == 0));
+    }
+  #else
+    // On some targets we can rely on type_info's NTBS being unique,
+    // and therefore address comparisons are sufficient.
+    bool before(const type_info& __arg) const _GLIBCXX_NOEXCEPT
+    { return __name < __arg.__name; }
+    bool operator==(const type_info& __arg) const _GLIBCXX_NOEXCEPT
+    { return __name == __arg.__name; }
+  #endif
+#endif
+    bool operator!=(const type_info& __arg) const _GLIBCXX_NOEXCEPT
+    { return !operator==(__arg); }
+#if __cplusplus >= 201103L
+    size_t hash_code() const noexcept
+    {
+#  if !__GXX_MERGED_TYPEINFO_NAMES
+      return _Hash_bytes(name(), __builtin_strlen(name()),
+                         static_cast<size_t>(0xc70f6907UL));
+#  else
+      return reinterpret_cast<size_t>(__name);
+#  endif
+    }
+#endif // C++11
+    // Return true if this is a pointer type of some kind
+    virtual bool __is_pointer_p() const;
+    // Return true if this is a function type
+    virtual bool __is_function_p() const;
+    // Try and catch a thrown type. Store an adjusted pointer to the
+    // caught type in THR_OBJ. If THR_TYPE is not a pointer type, then
+    // THR_OBJ points to the thrown object. If THR_TYPE is a pointer
+    // type, then THR_OBJ is the pointer itself. OUTER indicates the
+    // number of outer pointers, and whether they were const
+    // qualified.
+    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
+                            unsigned __outer) const;
+    // Internally used during catch matching
+    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
+                             void **__obj_ptr) const;
+  protected:
+    const char *__name;
+    explicit type_info(const char *__n): __name(__n) { }
+  private:
+    /// Assigning type_info is not supported.
+    type_info& operator=(const type_info&);
+    type_info(const type_info&);
+  };
+  /**
+   *  @brief  Thrown during incorrect typecasting.
+   *  @ingroup exceptions
+   *
+   *  If you attempt an invalid @c dynamic_cast expression, an instance of
+   *  this class (or something derived from this class) is thrown.  */
+  class bad_cast : public exception
+  {
+  public:
+    bad_cast() _GLIBCXX_USE_NOEXCEPT { }
+    // This declaration is not useless:
+    // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
+    virtual ~bad_cast() _GLIBCXX_USE_NOEXCEPT;
+    // See comment in eh_exception.cc.
+    virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
+  };
+  /**
+   *  @brief Thrown when a NULL pointer in a @c typeid expression is used.
+   *  @ingroup exceptions
+   */
+  class bad_typeid : public exception
+  {
+  public:
+    bad_typeid () _GLIBCXX_USE_NOEXCEPT { }
+    // This declaration is not useless:
+    // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
+    virtual ~bad_typeid() _GLIBCXX_USE_NOEXCEPT;
+    // See comment in eh_exception.cc.
+    virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
+  };
+} // namespace std
+} // extern "C++"
+#pragma GCC visibility pop
+#endif

 /contrib/sdk/sources/libstdc++-v3/libsupc++/atexit_thread.cc
 ,7 → 26,7
 #include <new>
 #include "bits/gthr.h"
-#if HAVE___CXA_THREAD_ATEXIT_IMPL
+#if _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL
 extern "C" int __cxa_thread_atexit_impl (void (*func) (void *),
                                          void *arg, void *d);
 ,7 → 38,7
   return __cxa_thread_atexit_impl (dtor, obj, dso_handle);
 }
-#else /* HAVE___CXA_THREAD_ATEXIT_IMPL */
+#else /* _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL */
 namespace {
   // One element in a singly-linked stack of cleanups.
 ,4 → 142,4
   return 0;
 }
-#endif /* HAVE___CXA_THREAD_ATEXIT_IMPL */
+#endif /* _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL */

 /contrib/sdk/sources/libstdc++-v3/libsupc++/config.h
 ,418 → 1,346
-/* config.h.  Generated from config.h.in by configure.  */
-/* config.h.in.  Generated from configure.ac by autoheader.  */
+/* config.h.  Generated from config.in by configure.  */
+/* config.in.  Generated from configure.ac by autoheader.  */
-/* Define to 1 if you have the `acosf' function. */
-#define HAVE_ACOSF 1
+/* Define if building universal (internal helper macro) */
+/* #undef AC_APPLE_UNIVERSAL_BUILD */
-/* Define to 1 if you have the `acosl' function. */
-#define HAVE_ACOSL 1
+/* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems.
+   This function is required for alloca.c support on those systems. */
+/* #undef CRAY_STACKSEG_END */
-/* Define to 1 if you have the `asinf' function. */
-#define HAVE_ASINF 1
+/* Define to 1 if you have the <alloca.h> header file. */
+#define HAVE_ALLOCA_H 1
-/* Define to 1 if you have the `asinl' function. */
-#define HAVE_ASINL 1
+/* Define to 1 if you have the `asprintf' function. */
+#define HAVE_ASPRINTF 1
-/* Define to 1 if the target assembler supports .symver directive. */
-/* #undef HAVE_AS_SYMVER_DIRECTIVE */
+/* Define to 1 if you have the `atexit' function. */
+#define HAVE_ATEXIT 1
-/* Define to 1 if you have the `atan2f' function. */
-#define HAVE_ATAN2F 1
+/* Define to 1 if you have the `basename' function. */
+#define HAVE_BASENAME 1
-/* Define to 1 if you have the `atan2l' function. */
-#define HAVE_ATAN2L 1
+/* Define to 1 if you have the `bcmp' function. */
+/* #undef HAVE_BCMP */
-/* Define to 1 if you have the `atanf' function. */
-#define HAVE_ATANF 1
+/* Define to 1 if you have the `bcopy' function. */
+/* #undef HAVE_BCOPY */
-/* Define to 1 if you have the `atanl' function. */
-#define HAVE_ATANL 1
+/* Define to 1 if you have the `bsearch' function. */
+#define HAVE_BSEARCH 1
-/* Define to 1 if you have the `at_quick_exit' function. */
-/* #undef HAVE_AT_QUICK_EXIT */
+/* Define to 1 if you have the `bzero' function. */
+/* #undef HAVE_BZERO */
-/* Define to 1 if the target assembler supports thread-local storage. */
-/* #undef HAVE_CC_TLS */
+/* Define to 1 if you have the `calloc' function. */
+#define HAVE_CALLOC 1
-/* Define to 1 if you have the `ceilf' function. */
-#define HAVE_CEILF 1
+/* Define to 1 if you have the `canonicalize_file_name' function. */
+/* #undef HAVE_CANONICALIZE_FILE_NAME */
-/* Define to 1 if you have the `ceill' function. */
-#define HAVE_CEILL 1
+/* Define to 1 if you have the `clock' function. */
+#define HAVE_CLOCK 1
-/* Define to 1 if you have the <complex.h> header file. */
-#define HAVE_COMPLEX_H 1
+/* Define to 1 if you have the declaration of `asprintf', and to 0 if you
+   don't. */
+#define HAVE_DECL_ASPRINTF 0
-/* Define to 1 if you have the `cosf' function. */
-#define HAVE_COSF 1
+/* Define to 1 if you have the declaration of `basename(char *)', and to 0 if
+   you don't. */
+#define HAVE_DECL_BASENAME 0
-/* Define to 1 if you have the `coshf' function. */
-#define HAVE_COSHF 1
+/* Define to 1 if you have the declaration of `calloc', and to 0 if you don't.
+   */
+#define HAVE_DECL_CALLOC 1
-/* Define to 1 if you have the `coshl' function. */
-#define HAVE_COSHL 1
+/* Define to 1 if you have the declaration of `ffs', and to 0 if you don't. */
+#define HAVE_DECL_FFS 0
-/* Define to 1 if you have the `cosl' function. */
-#define HAVE_COSL 1
+/* Define to 1 if you have the declaration of `getenv', and to 0 if you don't.
+   */
+#define HAVE_DECL_GETENV 1
-/* Define to 1 if you have the <dlfcn.h> header file. */
-/* #undef HAVE_DLFCN_H */
+/* Define to 1 if you have the declaration of `getopt', and to 0 if you don't.
+   */
+#define HAVE_DECL_GETOPT 1
-/* Define if EBADMSG exists. */
-/* #undef HAVE_EBADMSG */
+/* Define to 1 if you have the declaration of `malloc', and to 0 if you don't.
+   */
+#define HAVE_DECL_MALLOC 1
-/* Define if ECANCELED exists. */
-/* #undef HAVE_ECANCELED */
+/* Define to 1 if you have the declaration of `realloc', and to 0 if you
+   don't. */
+#define HAVE_DECL_REALLOC 1
-/* Define if ECHILD exists. */
-#define HAVE_ECHILD 1
+/* Define to 1 if you have the declaration of `sbrk', and to 0 if you don't.
+   */
+#define HAVE_DECL_SBRK 0
-/* Define if EIDRM exists. */
-/* #undef HAVE_EIDRM */
+/* Define to 1 if you have the declaration of `snprintf', and to 0 if you
+   don't. */
+#define HAVE_DECL_SNPRINTF 1
-/* Define to 1 if you have the <endian.h> header file. */
-/* #undef HAVE_ENDIAN_H */
+/* Define to 1 if you have the declaration of `strverscmp', and to 0 if you
+   don't. */
+#define HAVE_DECL_STRVERSCMP 0
-/* Define if ENODATA exists. */
-/* #undef HAVE_ENODATA */
+/* Define to 1 if you have the declaration of `vasprintf', and to 0 if you
+   don't. */
+#define HAVE_DECL_VASPRINTF 0
-/* Define if ENOLINK exists. */
-/* #undef HAVE_ENOLINK */
+/* Define to 1 if you have the declaration of `vsnprintf', and to 0 if you
+   don't. */
+#define HAVE_DECL_VSNPRINTF 1
-/* Define if ENOSPC exists. */
-#define HAVE_ENOSPC 1
+/* Define to 1 if you have the `dup3' function. */
+/* #undef HAVE_DUP3 */
-/* Define if ENOSR exists. */
-/* #undef HAVE_ENOSR */
+/* Define to 1 if you have the <fcntl.h> header file. */
+#define HAVE_FCNTL_H 1
-/* Define if ENOSTR exists. */
-/* #undef HAVE_ENOSTR */
+/* Define to 1 if you have the `ffs' function. */
+/* #undef HAVE_FFS */
-/* Define if ENOTRECOVERABLE exists. */
-/* #undef HAVE_ENOTRECOVERABLE */
+/* Define to 1 if you have the `fork' function. */
+/* #undef HAVE_FORK */
-/* Define if ENOTSUP exists. */
-/* #undef HAVE_ENOTSUP */
+/* Define to 1 if you have the `getcwd' function. */
+#define HAVE_GETCWD 1
-/* Define if EOVERFLOW exists. */
-/* #undef HAVE_EOVERFLOW */
+/* Define to 1 if you have the `getpagesize' function. */
+#define HAVE_GETPAGESIZE 1
-/* Define if EOWNERDEAD exists. */
-/* #undef HAVE_EOWNERDEAD */
+/* Define to 1 if you have the `getrlimit' function. */
+/* #undef HAVE_GETRLIMIT */
-/* Define if EPERM exists. */
-#define HAVE_EPERM 1
+/* Define to 1 if you have the `getrusage' function. */
+/* #undef HAVE_GETRUSAGE */
-/* Define if EPROTO exists. */
-/* #undef HAVE_EPROTO */
+/* Define to 1 if you have the `getsysinfo' function. */
+/* #undef HAVE_GETSYSINFO */
-/* Define if ETIME exists. */
-/* #undef HAVE_ETIME */
+/* Define to 1 if you have the `gettimeofday' function. */
+#define HAVE_GETTIMEOFDAY 1
-/* Define if ETIMEDOUT exists. */
-/* #undef HAVE_ETIMEDOUT */
+/* Define to 1 if you have the `index' function. */
+/* #undef HAVE_INDEX */
-/* Define if ETXTBSY exists. */
-/* #undef HAVE_ETXTBSY */
+/* Define to 1 if you have the `insque' function. */
+/* #undef HAVE_INSQUE */
-/* Define if EWOULDBLOCK exists. */
-/* #undef HAVE_EWOULDBLOCK */
+/* Define to 1 if the system has the type `intptr_t'. */
+#define HAVE_INTPTR_T 1
-/* Define to 1 if you have the <execinfo.h> header file. */
-/* #undef HAVE_EXECINFO_H */
-/* Define to 1 if you have the `expf' function. */
-#define HAVE_EXPF 1
-/* Define to 1 if you have the `expl' function. */
-#define HAVE_EXPL 1
-/* Define to 1 if you have the `fabsf' function. */
-#define HAVE_FABSF 1
-/* Define to 1 if you have the `fabsl' function. */
-#define HAVE_FABSL 1
-/* Define to 1 if you have the <fenv.h> header file. */
-#define HAVE_FENV_H 1
-/* Define to 1 if you have the `finite' function. */
-#define HAVE_FINITE 1
-/* Define to 1 if you have the `finitef' function. */
-/* #undef HAVE_FINITEF */
-/* Define to 1 if you have the `finitel' function. */
-/* #undef HAVE_FINITEL */
-/* Define to 1 if you have the <float.h> header file. */
-#define HAVE_FLOAT_H 1
-/* Define to 1 if you have the `floorf' function. */
-#define HAVE_FLOORF 1
-/* Define to 1 if you have the `floorl' function. */
-#define HAVE_FLOORL 1
-/* Define to 1 if you have the `fmodf' function. */
-#define HAVE_FMODF 1
-/* Define to 1 if you have the `fmodl' function. */
-#define HAVE_FMODL 1
-/* Define to 1 if you have the `fpclass' function. */
-#define HAVE_FPCLASS 1
-/* Define to 1 if you have the <fp.h> header file. */
-/* #undef HAVE_FP_H */
-/* Define to 1 if you have the `frexpf' function. */
-#define HAVE_FREXPF 1
-/* Define to 1 if you have the `frexpl' function. */
-#define HAVE_FREXPL 1
-/* Define if _Unwind_GetIPInfo is available. */
-#define HAVE_GETIPINFO 1
-/* Define if gets is available in <stdio.h>. */
-#define HAVE_GETS 1
-/* Define to 1 if you have the `hypot' function. */
-#define HAVE_HYPOT 1
-/* Define to 1 if you have the `hypotf' function. */
-#define HAVE_HYPOTF 1
-/* Define to 1 if you have the `hypotl' function. */
-#define HAVE_HYPOTL 1
-/* Define if you have the iconv() function. */
-/* #undef HAVE_ICONV */
-/* Define to 1 if you have the <ieeefp.h> header file. */
-/* #undef HAVE_IEEEFP_H */
-/* Define if int64_t is available in <stdint.h>. */
-#define HAVE_INT64_T 1
-/* Define if int64_t is a long. */
-/* #undef HAVE_INT64_T_LONG */
-/* Define if int64_t is a long long. */
-#define HAVE_INT64_T_LONG_LONG 1
 /* Define to 1 if you have the <inttypes.h> header file. */
 #define HAVE_INTTYPES_H 1
-/* Define to 1 if you have the `isinf' function. */
-/* #undef HAVE_ISINF */
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
-/* Define to 1 if you have the `isinff' function. */
-/* #undef HAVE_ISINFF */
+/* Define to 1 if you have the <machine/hal_sysinfo.h> header file. */
+/* #undef HAVE_MACHINE_HAL_SYSINFO_H */
-/* Define to 1 if you have the `isinfl' function. */
-/* #undef HAVE_ISINFL */
+/* Define to 1 if you have the <malloc.h> header file. */
+#define HAVE_MALLOC_H 1
-/* Define to 1 if you have the `isnan' function. */
-#define HAVE_ISNAN 1
+/* Define to 1 if you have the `memchr' function. */
+#define HAVE_MEMCHR 1
-/* Define to 1 if you have the `isnanf' function. */
-/* #undef HAVE_ISNANF */
+/* Define to 1 if you have the `memcmp' function. */
+#define HAVE_MEMCMP 1
-/* Define to 1 if you have the `isnanl' function. */
-/* #undef HAVE_ISNANL */
+/* Define to 1 if you have the `memcpy' function. */
+#define HAVE_MEMCPY 1
-/* Defined if iswblank exists. */
-#define HAVE_ISWBLANK 1
+/* Define to 1 if you have the `memmem' function. */
+/* #undef HAVE_MEMMEM */
-/* Define if LC_MESSAGES is available in <locale.h>. */
-/* #undef HAVE_LC_MESSAGES */
+/* Define to 1 if you have the `memmove' function. */
+#define HAVE_MEMMOVE 1
-/* Define to 1 if you have the `ldexpf' function. */
-#define HAVE_LDEXPF 1
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
-/* Define to 1 if you have the `ldexpl' function. */
-#define HAVE_LDEXPL 1
+/* Define to 1 if you have the `memset' function. */
+#define HAVE_MEMSET 1
-/* Define to 1 if you have the <libintl.h> header file. */
-/* #undef HAVE_LIBINTL_H */
+/* Define to 1 if you have the `mkstemps' function. */
+/* #undef HAVE_MKSTEMPS */
-/* Only used in build directory testsuite_hooks.h. */
-/* #undef HAVE_LIMIT_AS */
+/* Define to 1 if you have a working `mmap' system call. */
+/* #undef HAVE_MMAP */
-/* Only used in build directory testsuite_hooks.h. */
-/* #undef HAVE_LIMIT_DATA */
+/* Define to 1 if you have the `on_exit' function. */
+/* #undef HAVE_ON_EXIT */
-/* Only used in build directory testsuite_hooks.h. */
-/* #undef HAVE_LIMIT_FSIZE */
+/* Define to 1 if you have the <process.h> header file. */
+#define HAVE_PROCESS_H 1
-/* Only used in build directory testsuite_hooks.h. */
-/* #undef HAVE_LIMIT_RSS */
+/* Define to 1 if you have the `psignal' function. */
+/* #undef HAVE_PSIGNAL */
-/* Only used in build directory testsuite_hooks.h. */
-/* #undef HAVE_LIMIT_VMEM */
+/* Define to 1 if you have the `pstat_getdynamic' function. */
+/* #undef HAVE_PSTAT_GETDYNAMIC */
-/* Define if futex syscall is available. */
-/* #undef HAVE_LINUX_FUTEX */
+/* Define to 1 if you have the `pstat_getstatic' function. */
+/* #undef HAVE_PSTAT_GETSTATIC */
-/* Define to 1 if you have the <locale.h> header file. */
-#define HAVE_LOCALE_H 1
+/* Define to 1 if you have the `putenv' function. */
+#define HAVE_PUTENV 1
-/* Define to 1 if you have the `log10f' function. */
-#define HAVE_LOG10F 1
+/* Define to 1 if you have the `random' function. */
+/* #undef HAVE_RANDOM */
-/* Define to 1 if you have the `log10l' function. */
-#define HAVE_LOG10L 1
+/* Define to 1 if you have the `realpath' function. */
+/* #undef HAVE_REALPATH */
-/* Define to 1 if you have the `logf' function. */
-#define HAVE_LOGF 1
+/* Define to 1 if you have the `rename' function. */
+#define HAVE_RENAME 1
-/* Define to 1 if you have the `logl' function. */
-#define HAVE_LOGL 1
+/* Define to 1 if you have the `rindex' function. */
+/* #undef HAVE_RINDEX */
-/* Define to 1 if you have the <machine/endian.h> header file. */
-#define HAVE_MACHINE_ENDIAN_H 1
+/* Define to 1 if you have the `sbrk' function. */
+/* #undef HAVE_SBRK */
-/* Define to 1 if you have the <machine/param.h> header file. */
-#define HAVE_MACHINE_PARAM_H 1
+/* Define to 1 if you have the `setenv' function. */
+/* #undef HAVE_SETENV */
-/* Define if mbstate_t exists in wchar.h. */
-#define HAVE_MBSTATE_T 1
+/* Define to 1 if you have the `setproctitle' function. */
+/* #undef HAVE_SETPROCTITLE */
-/* Define to 1 if you have the <memory.h> header file. */
-#define HAVE_MEMORY_H 1
+/* Define to 1 if you have the `setrlimit' function. */
+/* #undef HAVE_SETRLIMIT */
-/* Define to 1 if you have the `modf' function. */
-#define HAVE_MODF 1
+/* Define to 1 if you have the `sigsetmask' function. */
+/* #undef HAVE_SIGSETMASK */
-/* Define to 1 if you have the `modff' function. */
-#define HAVE_MODFF 1
+/* Define to 1 if you have the `snprintf' function. */
+#define HAVE_SNPRINTF 1
-/* Define to 1 if you have the `modfl' function. */
-#define HAVE_MODFL 1
+/* Define to 1 if you have the `spawnve' function. */
+#define HAVE_SPAWNVE 1
-/* Define to 1 if you have the <nan.h> header file. */
-/* #undef HAVE_NAN_H */
+/* Define to 1 if you have the `spawnvpe' function. */
+#define HAVE_SPAWNVPE 1
-/* Define if poll is available in <poll.h>. */
-/* #undef HAVE_POLL */
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
-/* Define to 1 if you have the `powf' function. */
-#define HAVE_POWF 1
+/* Define to 1 if you have the <stdio_ext.h> header file. */
+/* #undef HAVE_STDIO_EXT_H */
-/* Define to 1 if you have the `powl' function. */
-#define HAVE_POWL 1
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
-/* Define to 1 if you have the `qfpclass' function. */
-/* #undef HAVE_QFPCLASS */
+/* Define to 1 if you have the `stpcpy' function. */
+/* #undef HAVE_STPCPY */
-/* Define to 1 if you have the `quick_exit' function. */
-/* #undef HAVE_QUICK_EXIT */
+/* Define to 1 if you have the `stpncpy' function. */
+/* #undef HAVE_STPNCPY */
-/* Define to 1 if you have the `setenv' function. */
-/* #undef HAVE_SETENV */
+/* Define to 1 if you have the `strcasecmp' function. */
+/* #undef HAVE_STRCASECMP */
-/* Define to 1 if you have the `sincos' function. */
-/* #undef HAVE_SINCOS */
+/* Define to 1 if you have the `strchr' function. */
+#define HAVE_STRCHR 1
-/* Define to 1 if you have the `sincosf' function. */
-/* #undef HAVE_SINCOSF */
+/* Define to 1 if you have the `strdup' function. */
+#define HAVE_STRDUP 1
-/* Define to 1 if you have the `sincosl' function. */
-/* #undef HAVE_SINCOSL */
+/* Define to 1 if you have the `strerror' function. */
+#define HAVE_STRERROR 1
-/* Define to 1 if you have the `sinf' function. */
-#define HAVE_SINF 1
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
-/* Define to 1 if you have the `sinhf' function. */
-#define HAVE_SINHF 1
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
-/* Define to 1 if you have the `sinhl' function. */
-#define HAVE_SINHL 1
+/* Define to 1 if you have the `strncasecmp' function. */
+/* #undef HAVE_STRNCASECMP */
-/* Define to 1 if you have the `sinl' function. */
-#define HAVE_SINL 1
+/* Define to 1 if you have the `strndup' function. */
+/* #undef HAVE_STRNDUP */
-/* Defined if sleep exists. */
-/* #undef HAVE_SLEEP */
+/* Define to 1 if you have the `strnlen' function. */
+/* #undef HAVE_STRNLEN */
-/* Define to 1 if you have the `sqrtf' function. */
-#define HAVE_SQRTF 1
+/* Define to 1 if you have the `strrchr' function. */
+#define HAVE_STRRCHR 1
-/* Define to 1 if you have the `sqrtl' function. */
-#define HAVE_SQRTL 1
+/* Define to 1 if you have the `strsignal' function. */
+/* #undef HAVE_STRSIGNAL */
-/* Define to 1 if you have the <stdalign.h> header file. */
-/* #undef HAVE_STDALIGN_H */
+/* Define to 1 if you have the `strstr' function. */
+#define HAVE_STRSTR 1
-/* Define to 1 if you have the <stdbool.h> header file. */
-/* #undef HAVE_STDBOOL_H */
+/* Define to 1 if you have the `strtod' function. */
+#define HAVE_STRTOD 1
-/* Define to 1 if you have the <stdint.h> header file. */
-#define HAVE_STDINT_H 1
+/* Define to 1 if you have the `strtol' function. */
+#define HAVE_STRTOL 1
-/* Define to 1 if you have the <stdlib.h> header file. */
-#define HAVE_STDLIB_H 1
+/* Define to 1 if you have the `strtoul' function. */
+#define HAVE_STRTOUL 1
-/* Define if strerror_l is available in <string.h>. */
-/* #undef HAVE_STRERROR_L */
+/* Define to 1 if you have the `strverscmp' function. */
+/* #undef HAVE_STRVERSCMP */
-/* Define if strerror_r is available in <string.h>. */
-/* #undef HAVE_STRERROR_R */
+/* Define to 1 if you have the `sysconf' function. */
+/* #undef HAVE_SYSCONF */
-/* Define to 1 if you have the <strings.h> header file. */
-#define HAVE_STRINGS_H 1
+/* Define to 1 if you have the `sysctl' function. */
+/* #undef HAVE_SYSCTL */
-/* Define to 1 if you have the <string.h> header file. */
-#define HAVE_STRING_H 1
+/* Define to 1 if you have the `sysmp' function. */
+/* #undef HAVE_SYSMP */
-/* Define to 1 if you have the `strtof' function. */
-#define HAVE_STRTOF 1
+/* Define if you have the sys_errlist variable. */
+#define HAVE_SYS_ERRLIST 1
-/* Define to 1 if you have the `strtold' function. */
-#define HAVE_STRTOLD 1
+/* Define to 1 if you have the <sys/file.h> header file. */
+#define HAVE_SYS_FILE_H 1
-/* Define if strxfrm_l is available in <string.h>. */
-/* #undef HAVE_STRXFRM_L */
+/* Define to 1 if you have the <sys/mman.h> header file. */
+/* #undef HAVE_SYS_MMAN_H */
-/* Define to 1 if the target runtime linker supports binding the same symbol
-   to different versions. */
-/* #undef HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT */
+/* Define if you have the sys_nerr variable. */
+#define HAVE_SYS_NERR 1
-/* Define to 1 if you have the <sys/filio.h> header file. */
-/* #undef HAVE_SYS_FILIO_H */
+/* Define to 1 if you have the <sys/param.h> header file. */
+#define HAVE_SYS_PARAM_H 1
-/* Define to 1 if you have the <sys/ioctl.h> header file. */
-/* #undef HAVE_SYS_IOCTL_H */
+/* Define to 1 if you have the <sys/prctl.h> header file. */
+/* #undef HAVE_SYS_PRCTL_H */
-/* Define to 1 if you have the <sys/ipc.h> header file. */
-/* #undef HAVE_SYS_IPC_H */
+/* Define to 1 if you have the <sys/pstat.h> header file. */
+/* #undef HAVE_SYS_PSTAT_H */
-/* Define to 1 if you have the <sys/isa_defs.h> header file. */
-/* #undef HAVE_SYS_ISA_DEFS_H */
-/* Define to 1 if you have the <sys/machine.h> header file. */
-/* #undef HAVE_SYS_MACHINE_H */
-/* Define to 1 if you have the <sys/param.h> header file. */
-#define HAVE_SYS_PARAM_H 1
 /* Define to 1 if you have the <sys/resource.h> header file. */
-#define HAVE_SYS_RESOURCE_H 1
+/* #undef HAVE_SYS_RESOURCE_H */
-/* Define to 1 if you have a suitable <sys/sdt.h> header file */
-/* #undef HAVE_SYS_SDT_H */
+/* Define if you have the sys_siglist variable. */
+/* #undef HAVE_SYS_SIGLIST */
-/* Define to 1 if you have the <sys/sem.h> header file. */
-/* #undef HAVE_SYS_SEM_H */
 /* Define to 1 if you have the <sys/stat.h> header file. */
 #define HAVE_SYS_STAT_H 1
+/* Define to 1 if you have the <sys/sysctl.h> header file. */
+/* #undef HAVE_SYS_SYSCTL_H */
 /* Define to 1 if you have the <sys/sysinfo.h> header file. */
 /* #undef HAVE_SYS_SYSINFO_H */
+/* Define to 1 if you have the <sys/sysmp.h> header file. */
+/* #undef HAVE_SYS_SYSMP_H */
+/* Define to 1 if you have the <sys/systemcfg.h> header file. */
+/* #undef HAVE_SYS_SYSTEMCFG_H */
+/* Define to 1 if you have the <sys/table.h> header file. */
+/* #undef HAVE_SYS_TABLE_H */
 /* Define to 1 if you have the <sys/time.h> header file. */
 #define HAVE_SYS_TIME_H 1
 ,782 → 347,154
 /* Define to 1 if you have the <sys/types.h> header file. */
 #define HAVE_SYS_TYPES_H 1
-/* Define to 1 if you have the <sys/uio.h> header file. */
-/* #undef HAVE_SYS_UIO_H */
+/* Define to 1 if you have <sys/wait.h> that is POSIX.1 compatible. */
+/* #undef HAVE_SYS_WAIT_H */
-/* Define if S_IFREG is available in <sys/stat.h>. */
-/* #undef HAVE_S_IFREG */
+/* Define to 1 if you have the `table' function. */
+/* #undef HAVE_TABLE */
-/* Define if S_IFREG is available in <sys/stat.h>. */
-#define HAVE_S_ISREG 1
+/* Define to 1 if you have the `times' function. */
+/* #undef HAVE_TIMES */
-/* Define to 1 if you have the `tanf' function. */
-#define HAVE_TANF 1
+/* Define to 1 if you have the <time.h> header file. */
+#define HAVE_TIME_H 1
-/* Define to 1 if you have the `tanhf' function. */
-#define HAVE_TANHF 1
+/* Define to 1 if you have the `tmpnam' function. */
+#define HAVE_TMPNAM 1
-/* Define to 1 if you have the `tanhl' function. */
-#define HAVE_TANHL 1
+/* Define if you have the \`uintptr_t' type. */
+#define HAVE_UINTPTR_T 1
-/* Define to 1 if you have the `tanl' function. */
-#define HAVE_TANL 1
-/* Define to 1 if you have the <tgmath.h> header file. */
-/* #undef HAVE_TGMATH_H */
-/* Define to 1 if the target supports thread-local storage. */
-/* #undef HAVE_TLS */
 /* Define to 1 if you have the <unistd.h> header file. */
 #define HAVE_UNISTD_H 1
-/* Defined if usleep exists. */
-/* #undef HAVE_USLEEP */
+/* Define to 1 if you have the `vasprintf' function. */
+/* #undef HAVE_VASPRINTF */
-/* Defined if vfwscanf exists. */
-#define HAVE_VFWSCANF 1
+/* Define to 1 if you have the `vfork' function. */
+/* #undef HAVE_VFORK */
-/* Defined if vswscanf exists. */
-#define HAVE_VSWSCANF 1
+/* Define to 1 if you have the <vfork.h> header file. */
+/* #undef HAVE_VFORK_H */
-/* Defined if vwscanf exists. */
-#define HAVE_VWSCANF 1
+/* Define to 1 if you have the `vfprintf' function. */
+#define HAVE_VFPRINTF 1
-/* Define to 1 if you have the <wchar.h> header file. */
-#define HAVE_WCHAR_H 1
+/* Define to 1 if you have the `vprintf' function. */
+#define HAVE_VPRINTF 1
-/* Defined if wcstof exists. */
-#define HAVE_WCSTOF 1
+/* Define to 1 if you have the `vsprintf' function. */
+#define HAVE_VSPRINTF 1
-/* Define to 1 if you have the <wctype.h> header file. */
-#define HAVE_WCTYPE_H 1
+/* Define to 1 if you have the `wait3' function. */
+/* #undef HAVE_WAIT3 */
-/* Defined if Sleep exists. */
-/* #undef HAVE_WIN32_SLEEP */
+/* Define to 1 if you have the `wait4' function. */
+/* #undef HAVE_WAIT4 */
-/* Define if writev is available in <sys/uio.h>. */
-/* #undef HAVE_WRITEV */
+/* Define to 1 if you have the `waitpid' function. */
+/* #undef HAVE_WAITPID */
-/* Define to 1 if you have the `_acosf' function. */
-/* #undef HAVE__ACOSF */
+/* Define to 1 if `fork' works. */
+/* #undef HAVE_WORKING_FORK */
-/* Define to 1 if you have the `_acosl' function. */
-/* #undef HAVE__ACOSL */
+/* Define to 1 if `vfork' works. */
+/* #undef HAVE_WORKING_VFORK */
-/* Define to 1 if you have the `_asinf' function. */
-/* #undef HAVE__ASINF */
+/* Define to 1 if you have the `_doprnt' function. */
+/* #undef HAVE__DOPRNT */
-/* Define to 1 if you have the `_asinl' function. */
-/* #undef HAVE__ASINL */
+/* Define if you have the _system_configuration variable. */
+/* #undef HAVE__SYSTEM_CONFIGURATION */
-/* Define to 1 if you have the `_atan2f' function. */
-/* #undef HAVE__ATAN2F */
+/* Define to 1 if you have the `__fsetlocking' function. */
+/* #undef HAVE___FSETLOCKING */
-/* Define to 1 if you have the `_atan2l' function. */
-/* #undef HAVE__ATAN2L */
+/* Define if canonicalize_file_name is not declared in system header files. */
+#define NEED_DECLARATION_CANONICALIZE_FILE_NAME 1
-/* Define to 1 if you have the `_atanf' function. */
-/* #undef HAVE__ATANF */
+/* Define if errno must be declared even when <errno.h> is included. */
+/* #undef NEED_DECLARATION_ERRNO */
-/* Define to 1 if you have the `_atanl' function. */
-/* #undef HAVE__ATANL */
+/* Define to 1 if your C compiler doesn't accept -c and -o together. */
+/* #undef NO_MINUS_C_MINUS_O */
-/* Define to 1 if you have the `_ceilf' function. */
-/* #undef HAVE__CEILF */
-/* Define to 1 if you have the `_ceill' function. */
-/* #undef HAVE__CEILL */
-/* Define to 1 if you have the `_cosf' function. */
-/* #undef HAVE__COSF */
-/* Define to 1 if you have the `_coshf' function. */
-/* #undef HAVE__COSHF */
-/* Define to 1 if you have the `_coshl' function. */
-/* #undef HAVE__COSHL */
-/* Define to 1 if you have the `_cosl' function. */
-/* #undef HAVE__COSL */
-/* Define to 1 if you have the `_expf' function. */
-/* #undef HAVE__EXPF */
-/* Define to 1 if you have the `_expl' function. */
-/* #undef HAVE__EXPL */
-/* Define to 1 if you have the `_fabsf' function. */
-/* #undef HAVE__FABSF */
-/* Define to 1 if you have the `_fabsl' function. */
-/* #undef HAVE__FABSL */
-/* Define to 1 if you have the `_finite' function. */
-/* #undef HAVE__FINITE */
-/* Define to 1 if you have the `_finitef' function. */
-/* #undef HAVE__FINITEF */
-/* Define to 1 if you have the `_finitel' function. */
-/* #undef HAVE__FINITEL */
-/* Define to 1 if you have the `_floorf' function. */
-/* #undef HAVE__FLOORF */
-/* Define to 1 if you have the `_floorl' function. */
-/* #undef HAVE__FLOORL */
-/* Define to 1 if you have the `_fmodf' function. */
-/* #undef HAVE__FMODF */
-/* Define to 1 if you have the `_fmodl' function. */
-/* #undef HAVE__FMODL */
-/* Define to 1 if you have the `_fpclass' function. */
-/* #undef HAVE__FPCLASS */
-/* Define to 1 if you have the `_frexpf' function. */
-/* #undef HAVE__FREXPF */
-/* Define to 1 if you have the `_frexpl' function. */
-/* #undef HAVE__FREXPL */
-/* Define to 1 if you have the `_hypot' function. */
-/* #undef HAVE__HYPOT */
-/* Define to 1 if you have the `_hypotf' function. */
-/* #undef HAVE__HYPOTF */
-/* Define to 1 if you have the `_hypotl' function. */
-/* #undef HAVE__HYPOTL */
-/* Define to 1 if you have the `_isinf' function. */
-/* #undef HAVE__ISINF */
-/* Define to 1 if you have the `_isinff' function. */
-/* #undef HAVE__ISINFF */
-/* Define to 1 if you have the `_isinfl' function. */
-/* #undef HAVE__ISINFL */
-/* Define to 1 if you have the `_isnan' function. */
-/* #undef HAVE__ISNAN */
-/* Define to 1 if you have the `_isnanf' function. */
-/* #undef HAVE__ISNANF */
-/* Define to 1 if you have the `_isnanl' function. */
-/* #undef HAVE__ISNANL */
-/* Define to 1 if you have the `_ldexpf' function. */
-/* #undef HAVE__LDEXPF */
-/* Define to 1 if you have the `_ldexpl' function. */
-/* #undef HAVE__LDEXPL */
-/* Define to 1 if you have the `_log10f' function. */
-/* #undef HAVE__LOG10F */
-/* Define to 1 if you have the `_log10l' function. */
-/* #undef HAVE__LOG10L */
-/* Define to 1 if you have the `_logf' function. */
-/* #undef HAVE__LOGF */
-/* Define to 1 if you have the `_logl' function. */
-/* #undef HAVE__LOGL */
-/* Define to 1 if you have the `_modf' function. */
-/* #undef HAVE__MODF */
-/* Define to 1 if you have the `_modff' function. */
-/* #undef HAVE__MODFF */
-/* Define to 1 if you have the `_modfl' function. */
-/* #undef HAVE__MODFL */
-/* Define to 1 if you have the `_powf' function. */
-/* #undef HAVE__POWF */
-/* Define to 1 if you have the `_powl' function. */
-/* #undef HAVE__POWL */
-/* Define to 1 if you have the `_qfpclass' function. */
-/* #undef HAVE__QFPCLASS */
-/* Define to 1 if you have the `_sincos' function. */
-/* #undef HAVE__SINCOS */
-/* Define to 1 if you have the `_sincosf' function. */
-/* #undef HAVE__SINCOSF */
-/* Define to 1 if you have the `_sincosl' function. */
-/* #undef HAVE__SINCOSL */
-/* Define to 1 if you have the `_sinf' function. */
-/* #undef HAVE__SINF */
-/* Define to 1 if you have the `_sinhf' function. */
-/* #undef HAVE__SINHF */
-/* Define to 1 if you have the `_sinhl' function. */
-/* #undef HAVE__SINHL */
-/* Define to 1 if you have the `_sinl' function. */
-/* #undef HAVE__SINL */
-/* Define to 1 if you have the `_sqrtf' function. */
-/* #undef HAVE__SQRTF */
-/* Define to 1 if you have the `_sqrtl' function. */
-/* #undef HAVE__SQRTL */
-/* Define to 1 if you have the `_tanf' function. */
-/* #undef HAVE__TANF */
-/* Define to 1 if you have the `_tanhf' function. */
-/* #undef HAVE__TANHF */
-/* Define to 1 if you have the `_tanhl' function. */
-/* #undef HAVE__TANHL */
-/* Define to 1 if you have the `_tanl' function. */
-/* #undef HAVE__TANL */
-/* Define to 1 if you have the `__cxa_thread_atexit_impl' function. */
-/* #undef HAVE___CXA_THREAD_ATEXIT_IMPL */
-/* Define as const if the declaration of iconv() needs const. */
-/* #undef ICONV_CONST */
-/* Define to the sub-directory in which libtool stores uninstalled libraries.
-   */
-#define LT_OBJDIR ".libs/"
-/* Name of package */
-/* #undef PACKAGE */
 /* Define to the address where bug reports for this package should be sent. */
 #define PACKAGE_BUGREPORT ""
 /* Define to the full name of this package. */
-#define PACKAGE_NAME "package-unused"
+#define PACKAGE_NAME ""
 /* Define to the full name and version of this package. */
-#define PACKAGE_STRING "package-unused version-unused"
+#define PACKAGE_STRING ""
 /* Define to the one symbol short name of this package. */
-#define PACKAGE_TARNAME "libstdc++"
+#define PACKAGE_TARNAME ""
 /* Define to the home page for this package. */
 #define PACKAGE_URL ""
 /* Define to the version of this package. */
-#define PACKAGE_VERSION "version-unused"
+#define PACKAGE_VERSION ""
-/* The size of `char', as computed by sizeof. */
-/* #undef SIZEOF_CHAR */
 /* The size of `int', as computed by sizeof. */
-/* #undef SIZEOF_INT */
+#define SIZEOF_INT 4
-/* The size of `long', as computed by sizeof. */
-/* #undef SIZEOF_LONG */
+/* Define if you know the direction of stack growth for your system; otherwise
+   it will be automatically deduced at run-time. STACK_DIRECTION > 0 => grows
+   toward higher addresses STACK_DIRECTION < 0 => grows toward lower addresses
+   STACK_DIRECTION = 0 => direction of growth unknown */
+#define STACK_DIRECTION -1
-/* The size of `short', as computed by sizeof. */
-/* #undef SIZEOF_SHORT */
-/* The size of `void *', as computed by sizeof. */
-/* #undef SIZEOF_VOID_P */
 /* Define to 1 if you have the ANSI C header files. */
 #define STDC_HEADERS 1
-/* Version number of package */
-/* #undef VERSION */
+/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
+#define TIME_WITH_SYS_TIME 1
-/* Define if the compiler supports C++11 atomics. */
-#define _GLIBCXX_ATOMIC_BUILTINS 1
+/* Define to an unsigned 64-bit type available in the compiler. */
+#define UNSIGNED_64BIT_TYPE uint64_t
-/* Define to use concept checking code from the boost libraries. */
-/* #undef _GLIBCXX_CONCEPT_CHECKS */
-/* Define to 1 if a fully dynamic basic_string is wanted, 0 to disable,
-   undefined for platform defaults */
-#define _GLIBCXX_FULLY_DYNAMIC_STRING 0
-/* Define if gthreads library is available. */
-/* #undef _GLIBCXX_HAS_GTHREADS */
-/* Define to 1 if a full hosted library is built, or 0 if freestanding. */
-#define _GLIBCXX_HOSTED 1
-/* Define if compatibility should be provided for -mlong-double-64. */
-/* #undef _GLIBCXX_LONG_DOUBLE_COMPAT */
-/* Define if ptrdiff_t is int. */
-#define _GLIBCXX_PTRDIFF_T_IS_INT 1
-/* Define if using setrlimit to set resource limits during "make check" */
-/* #undef _GLIBCXX_RES_LIMITS */
-/* Define if size_t is unsigned int. */
-#define _GLIBCXX_SIZE_T_IS_UINT 1
-/* Define if the compiler is configured for setjmp/longjmp exceptions. */
-/* #undef _GLIBCXX_SJLJ_EXCEPTIONS */
-/* Define to the value of the EOF integer constant. */
-#define _GLIBCXX_STDIO_EOF -1
-/* Define to the value of the SEEK_CUR integer constant. */
-#define _GLIBCXX_STDIO_SEEK_CUR 1
-/* Define to the value of the SEEK_END integer constant. */
-#define _GLIBCXX_STDIO_SEEK_END 2
-/* Define to use symbol versioning in the shared library. */
-/* #undef _GLIBCXX_SYMVER */
-/* Define to use darwin versioning in the shared library. */
-/* #undef _GLIBCXX_SYMVER_DARWIN */
-/* Define to use GNU versioning in the shared library. */
-/* #undef _GLIBCXX_SYMVER_GNU */
-/* Define to use GNU namespace versioning in the shared library. */
-/* #undef _GLIBCXX_SYMVER_GNU_NAMESPACE */
-/* Define to use Sun versioning in the shared library. */
-/* #undef _GLIBCXX_SYMVER_SUN */
-/* Define if C99 functions or macros from <wchar.h>, <math.h>, <complex.h>,
-   <stdio.h>, and <stdlib.h> can be used or exposed. */
-/* #undef _GLIBCXX_USE_C99 */
-/* Define if C99 functions in <complex.h> should be used in <complex>. Using
-   compiler builtins for these functions requires corresponding C99 library
-   functions to be present. */
-/* #undef _GLIBCXX_USE_C99_COMPLEX */
-/* Define if C99 functions in <complex.h> should be used in <tr1/complex>.
-   Using compiler builtins for these functions requires corresponding C99
-   library functions to be present. */
-/* #undef _GLIBCXX_USE_C99_COMPLEX_TR1 */
-/* Define if C99 functions in <ctype.h> should be imported in <tr1/cctype> in
-   namespace std::tr1. */
-/* #undef _GLIBCXX_USE_C99_CTYPE_TR1 */
-/* Define if C99 functions in <fenv.h> should be imported in <tr1/cfenv> in
-   namespace std::tr1. */
-/* #undef _GLIBCXX_USE_C99_FENV_TR1 */
-/* Define if C99 functions in <inttypes.h> should be imported in
-   <tr1/cinttypes> in namespace std::tr1. */
-#define _GLIBCXX_USE_C99_INTTYPES_TR1 1
-/* Define if wchar_t C99 functions in <inttypes.h> should be imported in
-   <tr1/cinttypes> in namespace std::tr1. */
-#define _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 1
-/* Define if C99 functions or macros in <math.h> should be imported in <cmath>
-   in namespace std. */
-#define _GLIBCXX_USE_C99_MATH 1
-/* Define if C99 functions or macros in <math.h> should be imported in
-   <tr1/cmath> in namespace std::tr1. */
-#define _GLIBCXX_USE_C99_MATH_TR1 1
-/* Define if C99 types in <stdint.h> should be imported in <tr1/cstdint> in
-   namespace std::tr1. */
-#define _GLIBCXX_USE_C99_STDINT_TR1 1
-/* Defined if clock_gettime has monotonic clock support. */
-/* #undef _GLIBCXX_USE_CLOCK_MONOTONIC */
-/* Defined if clock_gettime syscall has monotonic and realtime clock support. */
-/* #undef _GLIBCXX_USE_CLOCK_GETTIME_SYSCALL */
-/* Defined if clock_gettime has realtime clock support. */
-/* #undef _GLIBCXX_USE_CLOCK_REALTIME */
-/* Define if ISO/IEC TR 24733 decimal floating point types are supported on
-   this host. */
-#define _GLIBCXX_USE_DECIMAL_FLOAT 1
-/* Define if __float128 is supported on this host. */
-#define _GLIBCXX_USE_FLOAT128 1
-/* Defined if gettimeofday is available. */
-#define _GLIBCXX_USE_GETTIMEOFDAY 1
-/* Define if get_nprocs is available in <sys/sysinfo.h>. */
-/* #undef _GLIBCXX_USE_GET_NPROCS */
-/* Define if __int128 is supported on this host. */
-/* #undef _GLIBCXX_USE_INT128 */
-/* Define if LFS support is available. */
-/* #undef _GLIBCXX_USE_LFS */
-/* Define if code specialized for long long should be used. */
-#define _GLIBCXX_USE_LONG_LONG 1
-/* Defined if nanosleep is available. */
-/* #undef _GLIBCXX_USE_NANOSLEEP */
-/* Define if NLS translations are to be used. */
-/* #undef _GLIBCXX_USE_NLS */
-/* Define if pthreads_num_processors_np is available in <pthread.h>. */
-/* #undef _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP */
-/* Define if /dev/random and /dev/urandom are available for the random_device
-   of TR1 (Chapter 5.1). */
-/* #undef _GLIBCXX_USE_RANDOM_TR1 */
-/* Defined if sched_yield is available. */
-/* #undef _GLIBCXX_USE_SCHED_YIELD */
-/* Define if _SC_NPROCESSORS_ONLN is available in <unistd.h>. */
-/* #undef _GLIBCXX_USE_SC_NPROCESSORS_ONLN */
-/* Define if _SC_NPROC_ONLN is available in <unistd.h>. */
-/* #undef _GLIBCXX_USE_SC_NPROC_ONLN */
-/* Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>. */
-/* #undef _GLIBCXX_USE_SYSCTL_HW_NCPU */
-/* Define if code specialized for wchar_t should be used. */
-//#define _GLIBCXX_USE_WCHAR_T 1
-/* Define to 1 if a verbose library is built, or 0 otherwise. */
-#define _GLIBCXX_VERBOSE 1
-/* Defined if as can handle rdrand. */
-#define _GLIBCXX_X86_RDRAND 1
-/* Define to 1 if mutex_timedlock is available. */
-#define _GTHREAD_USE_MUTEX_TIMEDLOCK 1
-#if defined (HAVE__ACOSF) && ! defined (HAVE_ACOSF)
-# define HAVE_ACOSF 1
-# define acosf _acosf
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+   significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
 #endif
-#if defined (HAVE__ACOSL) && ! defined (HAVE_ACOSL)
-# define HAVE_ACOSL 1
-# define acosl _acosl
+#else
+# ifndef WORDS_BIGENDIAN
+/* #  undef WORDS_BIGENDIAN */
 #endif
-#if defined (HAVE__ASINF) && ! defined (HAVE_ASINF)
-# define HAVE_ASINF 1
-# define asinf _asinf
 #endif
-#if defined (HAVE__ASINL) && ! defined (HAVE_ASINL)
-# define HAVE_ASINL 1
-# define asinl _asinl
-#endif
+/* Number of bits in a file offset, on hosts where this is settable. */
+/* #undef _FILE_OFFSET_BITS */
-#if defined (HAVE__ATAN2F) && ! defined (HAVE_ATAN2F)
-# define HAVE_ATAN2F 1
-# define atan2f _atan2f
-#endif
+/* Define for large files, on AIX-style hosts. */
+/* #undef _LARGE_FILES */
-#if defined (HAVE__ATAN2L) && ! defined (HAVE_ATAN2L)
-# define HAVE_ATAN2L 1
-# define atan2l _atan2l
-#endif
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */
-#if defined (HAVE__ATANF) && ! defined (HAVE_ATANF)
-# define HAVE_ATANF 1
-# define atanf _atanf
+/* Define to `__inline__' or `__inline' if that's what the C compiler
+   calls it, or to nothing if 'inline' is not supported under any name.  */
+#ifndef __cplusplus
+/* #undef inline */
 #endif
-#if defined (HAVE__ATANL) && ! defined (HAVE_ATANL)
-# define HAVE_ATANL 1
-# define atanl _atanl
-#endif
+/* Define to the type of a signed integer type wide enough to hold a pointer,
+   if such a type exists, and if the system does not define it. */
+/* #undef intptr_t */
-#if defined (HAVE__CEILF) && ! defined (HAVE_CEILF)
-# define HAVE_CEILF 1
-# define ceilf _ceilf
-#endif
+/* Define to `int' if <sys/types.h> does not define. */
+/* #undef pid_t */
-#if defined (HAVE__CEILL) && ! defined (HAVE_CEILL)
-# define HAVE_CEILL 1
-# define ceill _ceill
-#endif
+/* Define to `int' if <sys/types.h> does not define. */
+/* #undef ssize_t */
-#if defined (HAVE__COSF) && ! defined (HAVE_COSF)
-# define HAVE_COSF 1
-# define cosf _cosf
-#endif
+/* Define to the type of an unsigned integer type wide enough to hold a
+   pointer, if such a type exists, and if the system does not define it. */
+/* #undef uintptr_t */
-#if defined (HAVE__COSHF) && ! defined (HAVE_COSHF)
-# define HAVE_COSHF 1
-# define coshf _coshf
-#endif
-#if defined (HAVE__COSHL) && ! defined (HAVE_COSHL)
-# define HAVE_COSHL 1
-# define coshl _coshl
-#endif
-#if defined (HAVE__COSL) && ! defined (HAVE_COSL)
-# define HAVE_COSL 1
-# define cosl _cosl
-#endif
-#if defined (HAVE__EXPF) && ! defined (HAVE_EXPF)
-# define HAVE_EXPF 1
-# define expf _expf
-#endif
-#if defined (HAVE__EXPL) && ! defined (HAVE_EXPL)
-# define HAVE_EXPL 1
-# define expl _expl
-#endif
-#if defined (HAVE__FABSF) && ! defined (HAVE_FABSF)
-# define HAVE_FABSF 1
-# define fabsf _fabsf
-#endif
-#if defined (HAVE__FABSL) && ! defined (HAVE_FABSL)
-# define HAVE_FABSL 1
-# define fabsl _fabsl
-#endif
-#if defined (HAVE__FINITE) && ! defined (HAVE_FINITE)
-# define HAVE_FINITE 1
-# define finite _finite
-#endif
-#if defined (HAVE__FINITEF) && ! defined (HAVE_FINITEF)
-# define HAVE_FINITEF 1
-# define finitef _finitef
-#endif
-#if defined (HAVE__FINITEL) && ! defined (HAVE_FINITEL)
-# define HAVE_FINITEL 1
-# define finitel _finitel
-#endif
-#if defined (HAVE__FLOORF) && ! defined (HAVE_FLOORF)
-# define HAVE_FLOORF 1
-# define floorf _floorf
-#endif
-#if defined (HAVE__FLOORL) && ! defined (HAVE_FLOORL)
-# define HAVE_FLOORL 1
-# define floorl _floorl
-#endif
-#if defined (HAVE__FMODF) && ! defined (HAVE_FMODF)
-# define HAVE_FMODF 1
-# define fmodf _fmodf
-#endif
-#if defined (HAVE__FMODL) && ! defined (HAVE_FMODL)
-# define HAVE_FMODL 1
-# define fmodl _fmodl
-#endif
-#if defined (HAVE__FPCLASS) && ! defined (HAVE_FPCLASS)
-# define HAVE_FPCLASS 1
-# define fpclass _fpclass
-#endif
-#if defined (HAVE__FREXPF) && ! defined (HAVE_FREXPF)
-# define HAVE_FREXPF 1
-# define frexpf _frexpf
-#endif
-#if defined (HAVE__FREXPL) && ! defined (HAVE_FREXPL)
-# define HAVE_FREXPL 1
-# define frexpl _frexpl
-#endif
-#if defined (HAVE__HYPOT) && ! defined (HAVE_HYPOT)
-# define HAVE_HYPOT 1
-# define hypot _hypot
-#endif
-#if defined (HAVE__HYPOTF) && ! defined (HAVE_HYPOTF)
-# define HAVE_HYPOTF 1
-# define hypotf _hypotf
-#endif
-#if defined (HAVE__HYPOTL) && ! defined (HAVE_HYPOTL)
-# define HAVE_HYPOTL 1
-# define hypotl _hypotl
-#endif
-#if defined (HAVE__ISINF) && ! defined (HAVE_ISINF)
-# define HAVE_ISINF 1
-# define isinf _isinf
-#endif
-#if defined (HAVE__ISINFF) && ! defined (HAVE_ISINFF)
-# define HAVE_ISINFF 1
-# define isinff _isinff
-#endif
-#if defined (HAVE__ISINFL) && ! defined (HAVE_ISINFL)
-# define HAVE_ISINFL 1
-# define isinfl _isinfl
-#endif
-#if defined (HAVE__ISNAN) && ! defined (HAVE_ISNAN)
-# define HAVE_ISNAN 1
-# define isnan _isnan
-#endif
-#if defined (HAVE__ISNANF) && ! defined (HAVE_ISNANF)
-# define HAVE_ISNANF 1
-# define isnanf _isnanf
-#endif
-#if defined (HAVE__ISNANL) && ! defined (HAVE_ISNANL)
-# define HAVE_ISNANL 1
-# define isnanl _isnanl
-#endif
-#if defined (HAVE__LDEXPF) && ! defined (HAVE_LDEXPF)
-# define HAVE_LDEXPF 1
-# define ldexpf _ldexpf
-#endif
-#if defined (HAVE__LDEXPL) && ! defined (HAVE_LDEXPL)
-# define HAVE_LDEXPL 1
-# define ldexpl _ldexpl
-#endif
-#if defined (HAVE__LOG10F) && ! defined (HAVE_LOG10F)
-# define HAVE_LOG10F 1
-# define log10f _log10f
-#endif
-#if defined (HAVE__LOG10L) && ! defined (HAVE_LOG10L)
-# define HAVE_LOG10L 1
-# define log10l _log10l
-#endif
-#if defined (HAVE__LOGF) && ! defined (HAVE_LOGF)
-# define HAVE_LOGF 1
-# define logf _logf
-#endif
-#if defined (HAVE__LOGL) && ! defined (HAVE_LOGL)
-# define HAVE_LOGL 1
-# define logl _logl
-#endif
-#if defined (HAVE__MODF) && ! defined (HAVE_MODF)
-# define HAVE_MODF 1
-# define modf _modf
-#endif
-#if defined (HAVE__MODFF) && ! defined (HAVE_MODFF)
-# define HAVE_MODFF 1
-# define modff _modff
-#endif
-#if defined (HAVE__MODFL) && ! defined (HAVE_MODFL)
-# define HAVE_MODFL 1
-# define modfl _modfl
-#endif
-#if defined (HAVE__POWF) && ! defined (HAVE_POWF)
-# define HAVE_POWF 1
-# define powf _powf
-#endif
-#if defined (HAVE__POWL) && ! defined (HAVE_POWL)
-# define HAVE_POWL 1
-# define powl _powl
-#endif
-#if defined (HAVE__QFPCLASS) && ! defined (HAVE_QFPCLASS)
-# define HAVE_QFPCLASS 1
-# define qfpclass _qfpclass
-#endif
-#if defined (HAVE__SINCOS) && ! defined (HAVE_SINCOS)
-# define HAVE_SINCOS 1
-# define sincos _sincos
-#endif
-#if defined (HAVE__SINCOSF) && ! defined (HAVE_SINCOSF)
-# define HAVE_SINCOSF 1
-# define sincosf _sincosf
-#endif
-#if defined (HAVE__SINCOSL) && ! defined (HAVE_SINCOSL)
-# define HAVE_SINCOSL 1
-# define sincosl _sincosl
-#endif
-#if defined (HAVE__SINF) && ! defined (HAVE_SINF)
-# define HAVE_SINF 1
-# define sinf _sinf
-#endif
-#if defined (HAVE__SINHF) && ! defined (HAVE_SINHF)
-# define HAVE_SINHF 1
-# define sinhf _sinhf
-#endif
-#if defined (HAVE__SINHL) && ! defined (HAVE_SINHL)
-# define HAVE_SINHL 1
-# define sinhl _sinhl
-#endif
-#if defined (HAVE__SINL) && ! defined (HAVE_SINL)
-# define HAVE_SINL 1
-# define sinl _sinl
-#endif
-#if defined (HAVE__SQRTF) && ! defined (HAVE_SQRTF)
-# define HAVE_SQRTF 1
-# define sqrtf _sqrtf
-#endif
-#if defined (HAVE__SQRTL) && ! defined (HAVE_SQRTL)
-# define HAVE_SQRTL 1
-# define sqrtl _sqrtl
-#endif
-#if defined (HAVE__STRTOF) && ! defined (HAVE_STRTOF)
-# define HAVE_STRTOF 1
-# define strtof _strtof
-#endif
-#if defined (HAVE__STRTOLD) && ! defined (HAVE_STRTOLD)
-# define HAVE_STRTOLD 1
-# define strtold _strtold
-#endif
-#if defined (HAVE__TANF) && ! defined (HAVE_TANF)
-# define HAVE_TANF 1
-# define tanf _tanf
-#endif
-#if defined (HAVE__TANHF) && ! defined (HAVE_TANHF)
-# define HAVE_TANHF 1
-# define tanhf _tanhf
-#endif
-#if defined (HAVE__TANHL) && ! defined (HAVE_TANHL)
-# define HAVE_TANHL 1
-# define tanhl _tanhl
-#endif
-#if defined (HAVE__TANL) && ! defined (HAVE_TANL)
-# define HAVE_TANL 1
-# define tanl _tanl
-#endif
+/* Define as `fork' if `vfork' does not work. */
+#define vfork fork

 /contrib/sdk/sources/libstdc++-v3/libsupc++/dyncast.cc
 ,6 → 56,18
   const __class_type_info *whole_type = prefix->whole_type;
   __class_type_info::__dyncast_result result;
+  // If the whole object vptr doesn't refer to the whole object type, we're
+  // in the middle of constructing a primary base, and src is a separate
+  // base.  This has undefined behavior and we can't find anything outside
+  // of the base we're actually constructing, so fail now rather than
+  // segfault later trying to use a vbase offset that doesn't exist.
+  const void *whole_vtable = *static_cast <const void *const *> (whole_ptr);
+  const vtable_prefix *whole_prefix =
+    adjust_pointer <vtable_prefix> (whole_vtable,
+                                    -offsetof (vtable_prefix, origin));
+  if (whole_prefix->whole_type != whole_type)
+    return NULL;
   whole_type->__do_dyncast (src2dst, __class_type_info::__contained_public,
                             dst_type, whole_ptr, src_type, src_ptr, result);
   if (!result.dst_ptr)

 /contrib/sdk/sources/libstdc++-v3/libsupc++/eh_alloc.cc
 ,12 → 129,6
         std::terminate ();
     }
-  // We have an uncaught exception as soon as we allocate memory.  This
-  // yields uncaught_exception() true during the copy-constructor that
-  // initializes the exception object.  See Issue 475.
-  __cxa_eh_globals *globals = __cxa_get_globals ();
-  globals->uncaughtExceptions += 1;
   memset (ret, 0, sizeof (__cxa_refcounted_exception));
   return (void *)((char *)ret + sizeof (__cxa_refcounted_exception));
 ,12 → 185,6
         std::terminate ();
     }
-  // We have an uncaught exception as soon as we allocate memory.  This
-  // yields uncaught_exception() true during the copy-constructor that
-  // initializes the exception object.  See Issue 475.
-  __cxa_eh_globals *globals = __cxa_get_globals ();
-  globals->uncaughtExceptions += 1;
   memset (ret, 0, sizeof (__cxa_dependent_exception));
   return ret;

 /contrib/sdk/sources/libstdc++-v3/libsupc++/eh_call.cc
 ,7 → 140,11
                                &new_ptr) != ctm_failed)
             __throw_exception_again;
-          if (catch_type->__do_catch(&bad_exc, 0, 1))
+          // If the exception spec allows std::bad_exception, throw that.
+          // We don't have a thrown object to compare against, but since
+          // bad_exception doesn't have virtual bases, that's OK; just pass NULL.
+          void* obj = NULL;
+          if (catch_type->__do_catch(&bad_exc, &obj, 1))
             bad_exception_allowed = true;
         }

 /contrib/sdk/sources/libstdc++-v3/libsupc++/eh_personality.cc
 ,6 → 378,12
   switch (state & _US_ACTION_MASK)
     {
     case _US_VIRTUAL_UNWIND_FRAME:
+      // If the unwind state pattern is
+      // _US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND
+      // then we don't need to search for any handler as it is not a real
+      // exception. Just unwind the stack.
+      if (state & _US_FORCE_UNWIND)
+        CONTINUE_UNWINDING;
       actions = _UA_SEARCH_PHASE;
       break;

 /contrib/sdk/sources/libstdc++-v3/libsupc++/eh_throw.cc
 ,6 → 62,9
 {
   PROBE2 (throw, obj, tinfo);
+  __cxa_eh_globals *globals = __cxa_get_globals ();
+  globals->uncaughtExceptions += 1;
   // Definitely a primary.
   __cxa_refcounted_exception *header
     = __get_refcounted_exception_header_from_obj (obj);

 /contrib/sdk/sources/libstdc++-v3/libsupc++/libiberty.h
 ,11 → 85,11
 /* Expand "@file" arguments in argv.  */
-extern void expandargv PARAMS ((int *, char ***));
+extern void expandargv (int *, char ***);
 /* Write argv to an @-file, inserting necessary quoting.  */
-extern int writeargv PARAMS ((char **, FILE *));
+extern int writeargv (char **, FILE *);
 /* Return the number of elements in argv.  */

 /contrib/sdk/sources/libstdc++-v3/src/c++11/thread.cc
 ,7 → 183,7
         ::usleep(__us);
       }
 # else
-    ::sleep(__s.count() + (__ns >= 1000000));
+    ::sleep(__s.count() + (__ns.count() >= 1000000));
 # endif
 #elif defined(_GLIBCXX_HAVE_WIN32_SLEEP)
     unsigned long ms = __ns.count() / 1000000;

 /contrib/sdk/sources/libstdc++-v3/src/c++98/ios_init.cc
 ,7 → 37,7
 {
   using namespace __gnu_cxx;
-  // Extern declarations for global objects in src/globals.cc.
+  // Extern declarations for global objects in src/c++98/globals.cc.
   extern stdio_sync_filebuf<char> buf_cout_sync;
   extern stdio_sync_filebuf<char> buf_cin_sync;
   extern stdio_sync_filebuf<char> buf_cerr_sync;

Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 6324 → Rev 6325