git-svn-id: https://llvm.org/svn/llvm-project/libcxx/tags/libcpp-4@107023 91177308-0d34-0410-b5e6-96231b3b80d8

CMakeLists.txt

@@ -1,159 +0,0 @@
-# See www/CMake.html for instructions on how to build libcxx with CMake.
-
-#===============================================================================
-# Setup Project
-#===============================================================================
-
-project(libcxx CXX C)
-cmake_minimum_required(VERSION 2.8)
-
-set(PACKAGE_NAME libcxx)
-set(PACKAGE_VERSION trunk-svn)
-set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
-set(PACKAGE_BUGREPORT "llvmbugs@cs.uiuc.edu")
-
-# Add path for custom modules
-set(CMAKE_MODULE_PATH
-  ${CMAKE_MODULE_PATH}
-  "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
-  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
-  )
-
-# Require out of source build.
-include(MacroEnsureOutOfSourceBuild)
-MACRO_ENSURE_OUT_OF_SOURCE_BUILD(
- "${PROJECT_NAME} requires an out of source build. Please create a separate
- build directory and run 'cmake /path/to/${PROJECT_NAME} [options]' there."
- )
-
-#===============================================================================
-# Setup CMake Options
-#===============================================================================
-
-# Define options.
-option(LIBCXX_ENABLE_EXCEPTIONS "Use exceptions." ON)
-option(LIBCXX_ENABLE_RTTI "Use run time type information." ON)
-option(LIBCXX_ENABLE_ASSERTIONS "Enable assertions independent of build mode." ON)
-option(LIBCXX_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
-option(LIBCXX_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)
-option(LIBCXX_ENABLE_CXX0X "Enable -std=c++0x and use of c++0x language features if the compiler supports it." ON)
-option(LIBCXX_ENABLE_SHARED "Build libc++ as a shared library." ON)
-
-#===============================================================================
-# Configure System
-#===============================================================================
-
-# Get triples.
-include(GetTriple)
-get_host_triple(LIBCXX_HOST_TRIPLE
-  LIBCXX_HOST_ARCH
-  LIBCXX_HOST_VENDOR
-  LIBCXX_HOST_OS
-  )
-set(LIBCXX_HOST_TRIPLE ${LIBCXX_HOST_TRIPLE} CACHE STRING "Host triple.")
-get_target_triple(LIBCXX_TARGET_TRIPLE
-  LIBCXX_TARGET_ARCH
-  LIBCXX_TARGET_VENDOR
-  LIBCXX_TARGET_OS
-  )
-set(LIBCXX_TARGET_TRIPLE ${LIBCXX_TARGET_TRIPLE} CACHE STRING "Target triple.")
-
-# Configure compiler.
-include(config-ix)
-
-#===============================================================================
-# Setup Compiler Flags
-#===============================================================================
-
-# Get required flags.
-# On all systems the system c++ standard library headers need to be excluded.
-if (MSVC)
-  # MSVC only has -X, which disables all default includes; including the crt.
-  # Thus, we do nothing and hope we don't accidentally include any of the C++
-  # headers.
-else()
-  if (LIBCXX_HAS_NOSTDINCXX_FLAG)
-    set(LIBCXX_CXX_REQUIRED_FLAGS -nostdinc++)
-  endif()
-  if (LIBCXX_ENABLE_CXX0X AND LIBCXX_HAS_STDCXX0X_FLAG)
-    list(APPEND LIBCXX_CXX_REQUIRED_FLAGS -std=c++0x)
-  endif()
-endif()
-
-macro(append_if list condition var)
-  if (${condition})
-    list(APPEND ${list} ${var})
-  endif()
-endmacro()
-
-# Get warning flags
-append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WALL_FLAG -Wall)
-append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_W_FLAG -W)
-append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WNO_UNUSED_PARAMETER_FLAG -Wno-unused-parameter)
-append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WWRITE_STRINGS_FLAG -Wwrite-strings)
-append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WNO_LONG_LONG_FLAG -Wno-long-long)
-if (LIBCXX_ENABLE_WERROR)
-  append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WERROR_FLAG -Werror)
-  append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WX_FLAG -WX)
-endif()
-if (LIBCXX_ENABLE_PEDANTIC)
-  append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_PEDANTIC_FLAG -pedantic)
-endif()
-
-# Get feature flags.
-# Exceptions
-if (LIBCXX_ENABLE_EXCEPTIONS)
-  # Catches C++ exceptions only and tells the compiler to assume that extern C
-  # functions never throw a C++ exception.
-  append_if(LIBCXX_CXX_FEATURE_FLAGS LIBCXX_HAS_EHSC_FLAG -EHsc)
-else()
-  list(APPEND LIBCXX_CXX_FEATURE_FLAGS -D_LIBCPP_NO_EXCEPTIONS)
-  append_if(LIBCXX_CXX_FEATURE_FLAGS LIBCXX_HAS_NO_EHS_FLAG -EHs-)
-  append_if(LIBCXX_CXX_FEATURE_FLAGS LIBCXX_HAS_NO_EHA_FLAG -EHa-)
-  append_if(LIBCXX_CXX_FEATURE_FLAGS LIBCXX_HAS_FNO_EXCEPTIONS_FLAG -fno-exceptions)
-endif()
-# RTTI
-if (NOT LIBCXX_ENABLE_RTTI)
-  list(APPEND LIBCXX_CXX_FEATURE_FLAGS -D_LIBCPP_NO_RTTI)
-  append_if(LIBCXX_CXX_FEATURE_FLAGS LIBCXX_HAS_NO_GR_FLAG -GR-)
-  append_if(LIBCXX_CXX_FEATURE_FLAGS LIBCXX_HAS_FNO_RTTI_FLAG -fno-rtti)
-endif()
-# Assert
-if (LLVM_ENABLE_ASSERTIONS)
-  # MSVC doesn't like _DEBUG on release builds. See PR 4379.
-  if (NOT MSVC)
-    list(APPEND LIBCXX_CXX_FEATURE_FLAGS -D_DEBUG)
-  endif()
-  # On Release builds cmake automatically defines NDEBUG, so we
-  # explicitly undefine it:
-  if (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
-    list(APPEND LIBCXX_CXX_FEATURE_FLAGS -UNDEBUG)
-  endif()
-else()
-  if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
-    list(APPEND LIBCXX_CXX_FEATURE_FLAGS -DNDEBUG)
-  endif()
-endif()
-
-# This is the _ONLY_ place where add_definitions is called.
-add_definitions(
- ${LIBCXX_CXX_REQUIRED_FLAGS}
- ${LIBCXX_CXX_WARNING_FLAGS}
- ${LIBCXX_CXX_FEATURE_FLAGS}
- )
-
-#===============================================================================
-# Setup Source Code
-#===============================================================================
-
-include_directories(include)
-
-# Add source code. This also contains all of the logic for deciding linker flags
-# soname, etc...
-add_subdirectory(lib)
-
-#===============================================================================
-# Setup Tests
-#===============================================================================
-
-add_subdirectory(test)

CREDITS.TXT

@@ -1,22 +0,0 @@
-This file is a partial list of people who have contributed to the LLVM/libc++
-project.  If you have contributed a patch or made some other contribution to
-LLVM/libc++, please submit a patch to this file to add yourself, and it will be
-done!
-
-The list is sorted by surname and formatted to allow easy grepping and
-beautification by scripts.  The fields are: name (N), email (E), web-address
-(W), PGP key ID and fingerprint (P), description (D), and snail-mail address
-(S).
-
-N: Howard Hinnant
-E: hhinnant@apple.com
-D: Architect and primary author of libc++
-
-N: Marshall Clow
-E: marshall@idio.com
-E: mclow@qualcomm.com
-D: Minor patches and bug fixes.
-
-N: Bjorn Reese
-E: breese@users.sourceforge.net
-D: Initial regex prototype

LICENSE.TXT

@@ -1,21 +1,10 @@
 ==============================================================================
-libc++ License
+LLVM Release License
 ==============================================================================
-
-The libc++ library is dual licensed under both the University of Illinois
-"BSD-Like" license and the MIT license.  As a user of this code you may choose
-to use it under either license.  As a contributor, you agree to allow your code
-to be used under both.
-
-Full text of the relevant licenses is included below.
-
-==============================================================================
-
 University of Illinois/NCSA
 Open Source License
 
-Copyright (c) 2009-2010 by the contributors listed in CREDITS.TXT
-
+Copyright (c) 2007-2010 University of Illinois at Urbana-Champaign.
 All rights reserved.
 
 Developed by:
@@ -54,23 +43,21 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
 SOFTWARE.
 
 ==============================================================================
+The LLVM software contains code written by third parties.  Such software will
+have its own individual LICENSE.TXT file in the directory in which it appears.
+This file will describe the copyrights, license, and restrictions which apply
+to that code.
 
-Copyright (c) 2009-2010 by the contributors listed in CREDITS.TXT
+The disclaimer of warranty in the University of Illinois Open Source License
+applies to all code in the LLVM Distribution, and nothing in any of the
+other licenses gives permission to use the names of the LLVM Team or the
+University of Illinois to endorse or promote products derived from this
+Software.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+The following pieces of software have additional or alternate copyrights,
+licenses, and/or restrictions:
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+Program             Directory
+-------             ---------
+<none yet>
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

Makefile

@@ -9,16 +9,10 @@ OBJROOT=.
 SYMROOT=.
 export TRIPLE=-apple-
 
-ifeq (,$(RC_INDIGO))
-	INSTALL_PREFIX=""
-else
-	INSTALL_PREFIX="$(SDKROOT)"
-endif
-
 installsrc:: $(SRCROOT)
 
 	ditto $(SRCDIRS)/include $(SRCROOT)/include
-	ditto $(SRCDIRS)/lib $(SRCROOT)/lib
+	ditto $(SRCDIRS)/lib/buildit $(SRCROOT)/lib/buildit
 	ditto $(SRCDIRS)/src $(SRCROOT)/src
 	ditto $(SRCDIRS)/Makefile $(SRCROOT)/Makefile
 
@@ -26,19 +20,21 @@ clean::
 
 installhdrs::
 
-	mkdir -p $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/ext
-	rsync -r --exclude=".*" $(SRCDIRS)/include/* $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/
-	chown -R root:wheel $(DSTROOT)/$(INSTALL_PREFIX)/usr/include
-	chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1
-	chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/*
-	chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/ext
-	chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/ext/*
+	mkdir -p $(DSTROOT)/usr/include/c++/v1/ext
+	rsync -r --exclude=".*" $(SRCDIRS)/include/* $(DSTROOT)/usr/include/c++/v1/
+	chown -R root:wheel $(DSTROOT)/usr/include
+	chmod 755 $(DSTROOT)/usr/include/c++/v1
+	chmod 644 $(DSTROOT)/usr/include/c++/v1/*
+	chmod 755 $(DSTROOT)/usr/include/c++/v1/ext
+	chmod 644 $(DSTROOT)/usr/include/c++/v1/ext/*
 
 install:: installhdrs $(DESTDIR)
 
 	cd lib && ./buildit
 	ditto lib/libc++.1.dylib $(SYMROOT)/usr/lib/libc++.1.dylib
 	cd lib && dsymutil -o $(SYMROOT)/libc++.1.dylib.dSYM  $(SYMROOT)/usr/lib/libc++.1.dylib
-	mkdir -p $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib
-	strip -S -o $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/libc++.1.dylib $(SYMROOT)/usr/lib/libc++.1.dylib
-	cd $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib && ln -s libc++.1.dylib libc++.dylib
+	mkdir -p $(DSTROOT)/usr/lib
+	strip -S -o $(DSTROOT)/usr/lib/libc++.1.dylib $(SYMROOT)/usr/lib/libc++.1.dylib
+	cd $(DSTROOT)/usr/lib && ln -s libc++.1.dylib libc++.dylib
+	
+	

cmake/Modules/GetTriple.cmake

@@ -1,53 +0,0 @@
-# Define functions to get the host and target triple.
-
-function(get_host_triple out out_arch out_vendor out_os)
-  # Get the architecture.
-  set(arch ${CMAKE_HOST_SYSTEM_PROCESSOR})
-  if (arch STREQUAL "x86")
-    set(arch "i686")
-  endif()
-  # Get the vendor.
-  if (${CMAKE_HOST_SYSTEM_NAME} STREQUAL "Darwin")
-    set(vendor "apple")
-  else()
-    set(vendor "pc")
-  endif()
-  # Get os.
-  if (${CMAKE_HOST_SYSTEM_NAME} STREQUAL "Windows")
-    set(os "win32")
-  else()
-    string(TOLOWER ${CMAKE_HOST_SYSTEM_NAME} os)
-  endif()
-  set(triple "${arch}-${vendor}-${os}")
-  set(${out} ${triple} PARENT_SCOPE)
-  set(${out_arch} ${arch} PARENT_SCOPE)
-  set(${out_vendor} ${vendor} PARENT_SCOPE)
-  set(${out_os} ${os} PARENT_SCOPE)
-  message(STATUS "Host triple: ${triple}")
-endfunction()
-
-function(get_target_triple out out_arch out_vendor out_os)
-  # Get the architecture.
-  set(arch ${CMAKE_SYSTEM_PROCESSOR})
-  if (arch STREQUAL "x86")
-    set(arch "i686")
-  endif()
-  # Get the vendor.
-  if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-    set(vendor "apple")
-  else()
-    set(vendor "pc")
-  endif()
-  # Get os.
-  if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-    set(os "win32")
-  else()
-    string(TOLOWER ${CMAKE_SYSTEM_NAME} os)
-  endif()
-  set(triple "${arch}-${vendor}-${os}")
-  set(${out} ${triple} PARENT_SCOPE)
-  set(${out_arch} ${arch} PARENT_SCOPE)
-  set(${out_vendor} ${vendor} PARENT_SCOPE)
-  set(${out_os} ${os} PARENT_SCOPE)
-  message(STATUS "Target triple: ${triple}")
-endfunction()

cmake/Modules/MacroEnsureOutOfSourceBuild.cmake

@@ -1,18 +0,0 @@
-# MACRO_ENSURE_OUT_OF_SOURCE_BUILD(<errorMessage>)
-
-macro( MACRO_ENSURE_OUT_OF_SOURCE_BUILD _errorMessage )
-
-string( COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" _insource )
-if( _insource )
- message( SEND_ERROR "${_errorMessage}" )
- message( FATAL_ERROR
- "In-source builds are not allowed.
- CMake would overwrite the makefiles distributed with Compiler-RT.
- Please create a directory and run cmake from there, passing the path
- to this source directory as the last argument.
- This process created the file `CMakeCache.txt' and the directory `CMakeFiles'.
- Please delete them."
- )
-endif( _insource )
-
-endmacro( MACRO_ENSURE_OUT_OF_SOURCE_BUILD )

cmake/config-ix.cmake

@@ -1,38 +0,0 @@
-include(CheckLibraryExists)
-include(CheckCXXCompilerFlag)
-
-# Check compiler flags
-check_cxx_compiler_flag(-std=c++0x            LIBCXX_HAS_STDCXX0X_FLAG)
-check_cxx_compiler_flag(-fPIC                 LIBCXX_HAS_FPIC_FLAG)
-check_cxx_compiler_flag(-nodefaultlibs        LIBCXX_HAS_NODEFAULTLIBS_FLAG)
-check_cxx_compiler_flag(-nostdinc++           LIBCXX_HAS_NOSTDINCXX_FLAG)
-check_cxx_compiler_flag(-Wall                 LIBCXX_HAS_WALL_FLAG)
-check_cxx_compiler_flag(-W                    LIBCXX_HAS_W_FLAG)
-check_cxx_compiler_flag(-Wno-unused-parameter LIBCXX_HAS_WNO_UNUSED_PARAMETER_FLAG)
-check_cxx_compiler_flag(-Wwrite-strings       LIBCXX_HAS_WWRITE_STRINGS_FLAG)
-check_cxx_compiler_flag(-Wno-long-long        LIBCXX_HAS_WNO_LONG_LONG_FLAG)
-check_cxx_compiler_flag(-pedantic             LIBCXX_HAS_PEDANTIC_FLAG)
-check_cxx_compiler_flag(-Werror               LIBCXX_HAS_WERROR_FLAG)
-check_cxx_compiler_flag(-fno-exceptions       LIBCXX_HAS_FNO_EXCEPTIONS_FLAG)
-check_cxx_compiler_flag(-fno-rtti             LIBCXX_HAS_FNO_RTTI_FLAG)
-check_cxx_compiler_flag(/WX                   LIBCXX_HAS_WX_FLAG)
-check_cxx_compiler_flag(/EHsc                 LIBCXX_HAS_EHSC_FLAG)
-check_cxx_compiler_flag(/EHs-                 LIBCXX_HAS_NO_EHS_FLAG)
-check_cxx_compiler_flag(/EHa-                 LIBCXX_HAS_NO_EHA_FLAG)
-check_cxx_compiler_flag(/GR-                  LIBCXX_HAS_NO_GR_FLAG)
-
-# Check libraries
-check_library_exists(pthread pthread_create "" LIBCXX_HAS_PTHREAD_LIB)
-check_library_exists(c printf "" LIBCXX_HAS_C_LIB)
-check_library_exists(m ccos "" LIBCXX_HAS_M_LIB)
-check_library_exists(rt clock_gettime "" LIBCXX_HAS_RT_LIB)
-check_library_exists(gcc_s __gcc_personality_v0 "" LIBCXX_HAS_GCC_S_LIB)
-
-# Check C++0x features
-if (LIBCXX_ENABLE_CXX0X)
-  if (LIBCXX_HAS_STDCXX0X_FLAG)
-    set(CMAKE_REQUIRED_DEFINITIONS -std=c++0x)
-  endif()
-else()
-  set(LIBCXX_HAS_STDCXX0X_FLAG FALSE)
-endif()

include/__bit_reference

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -38,13 +38,11 @@ class __bit_reference
     friend class __bit_const_reference<_C>;
     friend class __bit_iterator<_C, false>;
 public:
-    _LIBCPP_INLINE_VISIBILITY operator bool() const _NOEXCEPT
-        {return static_cast<bool>(*__seg_ & __mask_);}
-    _LIBCPP_INLINE_VISIBILITY bool operator ~() const _NOEXCEPT
-        {return !static_cast<bool>(*this);}
+    _LIBCPP_INLINE_VISIBILITY operator bool() const {return static_cast<bool>(*__seg_ & __mask_);}
+    _LIBCPP_INLINE_VISIBILITY bool operator ~() const {return !static_cast<bool>(*this);}
 
     _LIBCPP_INLINE_VISIBILITY
-    __bit_reference& operator=(bool __x) _NOEXCEPT
+    __bit_reference& operator=(bool __x)
     {
         if (__x)
             *__seg_ |= __mask_;
@@ -52,24 +50,22 @@ public:
             *__seg_ &= ~__mask_;
         return *this;
     }
-
+    
     _LIBCPP_INLINE_VISIBILITY
-    __bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT
-        {return operator=(static_cast<bool>(__x));}
+    __bit_reference& operator=(const __bit_reference& __x) {return operator=(static_cast<bool>(__x));}
 
-    _LIBCPP_INLINE_VISIBILITY void flip() _NOEXCEPT {*__seg_ ^= __mask_;}
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator<_C, false> operator&() const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY void flip() {*__seg_ ^= __mask_;}
+    _LIBCPP_INLINE_VISIBILITY __bit_iterator<_C, false> operator&() const
         {return __bit_iterator<_C, false>(__seg_, static_cast<unsigned>(__ctz(__mask_)));}
 private:
     _LIBCPP_INLINE_VISIBILITY
-    __bit_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
-        : __seg_(__s), __mask_(__m) {}
+    __bit_reference(__storage_pointer __s, __storage_type __m) : __seg_(__s), __mask_(__m) {}
 };
 
 template <class _C, class _D>
 _LIBCPP_INLINE_VISIBILITY inline
 void
-swap(__bit_reference<_C> __x, __bit_reference<_D> __y) _NOEXCEPT
+swap(__bit_reference<_C> __x, __bit_reference<_D> __y)
 {
     bool __t = __x;
     __x = __y;
@@ -79,7 +75,7 @@ swap(__bit_reference<_C> __x, __bit_reference<_D> __y) _NOEXCEPT
 template <class _C>
 _LIBCPP_INLINE_VISIBILITY inline
 void
-swap(__bit_reference<_C> __x, bool& __y) _NOEXCEPT
+swap(__bit_reference<_C> __x, bool& __y)
 {
     bool __t = __x;
     __x = __y;
@@ -89,7 +85,7 @@ swap(__bit_reference<_C> __x, bool& __y) _NOEXCEPT
 template <class _C>
 _LIBCPP_INLINE_VISIBILITY inline
 void
-swap(bool& __x, __bit_reference<_C> __y) _NOEXCEPT
+swap(bool& __x, __bit_reference<_C> __y)
 {
     bool __t = __x;
     __x = __y;
@@ -113,18 +109,16 @@ class __bit_const_reference
     friend class __bit_iterator<_C, true>;
 public:
     _LIBCPP_INLINE_VISIBILITY
-    __bit_const_reference(const __bit_reference<_C>& __x) _NOEXCEPT
+    __bit_const_reference(const __bit_reference<_C>& __x)
         : __seg_(__x.__seg_), __mask_(__x.__mask_) {}
 
-    _LIBCPP_INLINE_VISIBILITY operator bool() const _NOEXCEPT
-        {return static_cast<bool>(*__seg_ & __mask_);}
+    _LIBCPP_INLINE_VISIBILITY operator bool() const {return static_cast<bool>(*__seg_ & __mask_);}
 
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator<_C, true> operator&() const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY __bit_iterator<_C, true> operator&() const
         {return __bit_iterator<_C, true>(__seg_, static_cast<unsigned>(__ctz(__mask_)));}
 private:
     _LIBCPP_INLINE_VISIBILITY
-    __bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
-        : __seg_(__s), __mask_(__m) {}
+    __bit_const_reference(__storage_pointer __s, __storage_type __m) : __seg_(__s), __mask_(__m) {}
 
     __bit_const_reference& operator=(const __bit_const_reference& __x);
 };
@@ -1034,7 +1028,6 @@ __equal_aligned(__bit_iterator<_C, true> __first1, __bit_iterator<_C, true> __la
 }
 
 template <class _C, bool _IC1, bool _IC2>
-inline _LIBCPP_INLINE_VISIBILITY
 bool
 equal(__bit_iterator<_C, _IC1> __first1, __bit_iterator<_C, _IC1> __last1, __bit_iterator<_C, _IC2> __first2)
 {
@@ -1063,14 +1056,12 @@ private:
     unsigned          __ctz_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY __bit_iterator() {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __bit_iterator(const __bit_iterator<_C, false>& __it) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY __bit_iterator(const __bit_iterator<_C, false>& __it)
         : __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
 
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT
-        {return reference(__seg_, __storage_type(1) << __ctz_);}
+    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return reference(__seg_, __storage_type(1) << __ctz_);}
 
     _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator++()
     {
@@ -1083,14 +1074,14 @@ public:
         }
         return *this;
     }
-
+    
     _LIBCPP_INLINE_VISIBILITY __bit_iterator operator++(int)
     {
         __bit_iterator __tmp = *this;
         ++(*this);
         return __tmp;
     }
-
+    
     _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator--()
     {
         if (__ctz_ != 0)
@@ -1102,14 +1093,14 @@ public:
         }
         return *this;
     }
-
+    
     _LIBCPP_INLINE_VISIBILITY __bit_iterator operator--(int)
     {
         __bit_iterator __tmp = *this;
         --(*this);
         return __tmp;
     }
-
+    
     _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator+=(difference_type __n)
     {
         if (__n >= 0)
@@ -1121,19 +1112,19 @@ public:
         __ctz_ = static_cast<unsigned>((__n + __ctz_)  % __bits_per_word);
         return *this;
     }
-
+    
     _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator-=(difference_type __n)
     {
         return *this += -__n;
     }
-
+    
     _LIBCPP_INLINE_VISIBILITY __bit_iterator operator+(difference_type __n) const
     {
         __bit_iterator __t(*this);
         __t += __n;
         return __t;
     }
-
+    
     _LIBCPP_INLINE_VISIBILITY __bit_iterator operator-(difference_type __n) const
     {
         __bit_iterator __t(*this);
@@ -1170,8 +1161,7 @@ public:
 
 private:
     _LIBCPP_INLINE_VISIBILITY
-    __bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT
-        : __seg_(__s), __ctz_(__ctz) {}
+    __bit_iterator(__storage_pointer __s, unsigned __ctz) : __seg_(__s), __ctz_(__ctz) {}
 
 #if defined(__clang__)
     friend typename _C::__self;

include/__config

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -26,31 +26,15 @@
 #if __LITTLE_ENDIAN__
 #define _LIBCPP_LITTLE_ENDIAN 1
 #define _LIBCPP_BIG_ENDIAN    0
-#endif  // __LITTLE_ENDIAN__
-#endif  // __LITTLE_ENDIAN__
+#endif
+#endif
 
 #ifdef __BIG_ENDIAN__
 #if __BIG_ENDIAN__
 #define _LIBCPP_LITTLE_ENDIAN 0
 #define _LIBCPP_BIG_ENDIAN    1
-#endif  // __BIG_ENDIAN__
-#endif  // __BIG_ENDIAN__
-
-#ifdef __FreeBSD__
-# include <sys/endian.h>
-#  if _BYTE_ORDER == _LITTLE_ENDIAN
-#   define _LIBCPP_LITTLE_ENDIAN 1
-#   define _LIBCPP_BIG_ENDIAN    0
-# else  // _BYTE_ORDER == _LITTLE_ENDIAN
-#   define _LIBCPP_LITTLE_ENDIAN 0
-#   define _LIBCPP_BIG_ENDIAN    1
-# endif  // _BYTE_ORDER == _LITTLE_ENDIAN
-#endif  // __FreeBSD__
-
-#ifdef _WIN32
-#  define _LIBCPP_LITTLE_ENDIAN 1
-#  define _LIBCPP_BIG_ENDIAN    0
-#endif  // _WIN32
+#endif
+#endif
 
 #if !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
 # include <endian.h>
@@ -60,10 +44,10 @@
 # elif __BYTE_ORDER == __BIG_ENDIAN
 #  define _LIBCPP_LITTLE_ENDIAN 0
 #  define _LIBCPP_BIG_ENDIAN    1
-# else  // __BYTE_ORDER == __BIG_ENDIAN
+# else
 #  error unable to determine endian
 # endif
-#endif  // !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
+#endif
 
 #ifndef _LIBCPP_VISIBILITY_TAG
 #define _LIBCPP_VISIBILITY_TAG 1
@@ -72,10 +56,10 @@
 #if _LIBCPP_VISIBILITY_TAG
 #define _LIBCPP_HIDDEN __attribute__ ((__visibility__("hidden")))
 #define _LIBCPP_VISIBLE __attribute__ ((__visibility__("default")))
-#else  // _LIBCPP_VISIBILITY_TAG
+#else
 #define _LIBCPP_HIDDEN
 #define _LIBCPP_VISIBLE
-#endif  // _LIBCPP_VISIBILITY_TAG
+#endif
 
 #ifndef _LIBCPP_INLINE_VISIBILITY
 #define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__visibility__("hidden"), __always_inline__))
@@ -87,158 +71,41 @@
 
 #define _LIBCPP_CANTTHROW __attribute__ ((__nothrow__))
 
-#define _LIBCPP_ALWAYS_INLINE  __attribute__ ((__visibility__("hidden"), __always_inline__))
+#define _LIBCPP_ALWAYS_INLINE  __attribute__((__always_inline__))
 
-#if defined(__clang__)
-
-#if !__has_feature(cxx_alias_templates)
-#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-#endif
-
-#ifndef __GXX_EXPERIMENTAL_CXX0X__
-#ifdef __linux__
-#define _LIBCPP_HAS_NO_UNICODE_CHARS
-#else
-typedef __char16_t char16_t;
-typedef __char32_t char32_t;
-#endif
-#endif
-
-#if !(__has_feature(cxx_exceptions))
-#define _LIBCPP_NO_EXCEPTIONS
-#endif
-
-#if !(__has_feature(cxx_rtti))
-#define _LIBCPP_NO_RTTI
-#endif
-
-#if !(__has_feature(cxx_decltype))
-#define _LIBCPP_HAS_NO_DECLTYPE
-#endif
-
-#if __has_feature(cxx_attributes)
-#  define _ATTRIBUTE(x) [[x]]
-#else
-#  define _ATTRIBUTE(x) __attribute__ ((x))
-#endif
-
-#define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
-
-#if !(__has_feature(cxx_deleted_functions))
-#define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
-#endif  // !(__has_feature(cxx_deleted_functions))
-
-#if !(__has_feature(cxx_lambdas))
-#define _LIBCPP_HAS_NO_LAMBDAS
-#endif
-
-#if !(__has_feature(cxx_nullptr))
-#define _LIBCPP_HAS_NO_NULLPTR
-#endif
-
-#if !(__has_feature(cxx_rvalue_references))
-#define _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#endif
-
-#if !(__has_feature(cxx_static_assert))
-#define _LIBCPP_HAS_NO_STATIC_ASSERT
-#endif
-
-#if !(__has_feature(cxx_auto_type))
-#define _LIBCPP_HAS_NO_AUTO_TYPE
-#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#endif
-
-#if !(__has_feature(cxx_variadic_templates))
-#define _LIBCPP_HAS_NO_VARIADICS
-#endif
-
-#if !(__has_feature(cxx_trailing_return))
-#define _LIBCPP_HAS_NO_TRAILING_RETURN
-#endif
-
-// Inline namespaces are available in Clang regardless of C++ dialect.
-#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {inline namespace _LIBCPP_NAMESPACE {
-#define _LIBCPP_END_NAMESPACE_STD  } }
-#define _STD std::_LIBCPP_NAMESPACE
-
-namespace std {
-  inline namespace _LIBCPP_NAMESPACE {
-  }
-}
-
-#if !(__has_feature(cxx_constexpr))
-#define _LIBCPP_HAS_NO_CONSTEXPR
-#endif
-
-#if (__has_feature(cxx_noexcept))
-#  define _NOEXCEPT noexcept
-#  define _NOEXCEPT_(x) noexcept(x)
-#else
-#  define _NOEXCEPT throw()
-#  define _NOEXCEPT_(x)
-#endif
-
-// end defined(__clang__)
-
-#elif defined(__GNUC__)
-
-#define _ATTRIBUTE(x) __attribute__((x))
-
-#if !__EXCEPTIONS
-#define _LIBCPP_NO_EXCEPTIONS
-#endif
-
-#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-#define _LIBCPP_HAS_NO_CONSTEXPR
-
-#define _NOEXCEPT throw()
-#define _NOEXCEPT_(x)
-
-#ifndef __GXX_EXPERIMENTAL_CXX0X__
-
-#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#define _LIBCPP_HAS_NO_DECLTYPE
-#define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
-#define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
-#define _LIBCPP_HAS_NO_NULLPTR
-#define _LIBCPP_HAS_NO_STATIC_ASSERT
-#define _LIBCPP_HAS_NO_UNICODE_CHARS
-#define _LIBCPP_HAS_NO_VARIADICS
-#define _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#define _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
-
-#else  // __GXX_EXPERIMENTAL_CXX0X__
-
-#define _LIBCPP_HAS_NO_TRAILING_RETURN
-#define _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
-
-#if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 3)
-#define _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if __GNUC__ >= 4 && __GNUC_MINOR__ >= 3
+#define _LIBCPP_MOVE
 #endif
 
 #if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 3)
 #define _LIBCPP_HAS_NO_STATIC_ASSERT
 #endif
 
+#define _LIBCPP_HAS_NO_NULLPTR
+
+#if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 3)
+#define _LIBCPP_HAS_NO_VARIADICS
+#define _LIBCPP_HAS_NO_DECLTYPE
+#endif
+
 #if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 4)
-#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
-#define _LIBCPP_HAS_NO_DECLTYPE
-#define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
-#define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
 #define _LIBCPP_HAS_NO_UNICODE_CHARS
-#define _LIBCPP_HAS_NO_VARIADICS
-#endif  // !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 4)
-
-#if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 6)
-#define _LIBCPP_HAS_NO_NULLPTR
+#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
 #endif
 
-#endif  // __GXX_EXPERIMENTAL_CXX0X__
+#if defined(__clang__)
+#define _LIBCPP_HAS_NO_STRONG_USING
+#endif
 
+#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+
+#ifdef _LIBCPP_HAS_NO_STRONG_USING
+#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {
+#define _LIBCPP_END_NAMESPACE_STD }
+#define _STD std
+#else
 #define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { namespace _LIBCPP_NAMESPACE {
 #define _LIBCPP_END_NAMESPACE_STD  } }
-#define _STD std::_LIBCPP_NAMESPACE
 
 namespace std {
 namespace _LIBCPP_NAMESPACE {
@@ -246,12 +113,13 @@ namespace _LIBCPP_NAMESPACE {
 using namespace _LIBCPP_NAMESPACE __attribute__((__strong__));
 }
 
-#endif  // defined(__GNUC__)
+#define _STD std::_LIBCPP_NAMESPACE
+#endif
 
 #ifdef _LIBCPP_HAS_NO_UNICODE_CHARS
-typedef unsigned short char16_t;
-typedef unsigned int   char32_t;
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+    typedef unsigned short char16_t;
+    typedef unsigned int   char32_t;
+#endif
 
 #ifdef _LIBCPP_HAS_NO_STATIC_ASSERT
 
@@ -262,18 +130,16 @@ template <unsigned> struct __static_assert_check {};
     typedef __static_assert_check<sizeof(__static_assert_test<(__b)>)> \
     _LIBCPP_CONCAT(__t, __LINE__)
 
-#endif  // _LIBCPP_HAS_NO_STATIC_ASSERT
+#endif
 
 #ifdef _LIBCPP_HAS_NO_DECLTYPE
+
 #define decltype(x) __typeof__(x)
+
 #endif
 
-#ifdef _LIBCPP_HAS_NO_CONSTEXPR
-#define constexpr const
-#endif
-
-#ifndef __has_feature
-#define __has_feature(__x) 0
+#if !__EXCEPTIONS
+#define _LIBCPP_NO_EXCEPTIONS
 #endif
 
 #endif  // _LIBCPP_CONFIG

include/__functional_base

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -21,21 +21,21 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Arg, class _Result>
-struct _LIBCPP_VISIBLE unary_function
+struct unary_function
 {
     typedef _Arg    argument_type;
     typedef _Result result_type;
 };
 
 template <class _Arg1, class _Arg2, class _Result>
-struct _LIBCPP_VISIBLE binary_function
+struct binary_function
 {
     typedef _Arg1   first_argument_type;
     typedef _Arg2   second_argument_type;
     typedef _Result result_type;
 };
 
-template <class _Tp> struct _LIBCPP_VISIBLE hash;
+template <class _Tp> struct hash;
 
 template <class _Tp>
 struct __has_result_type
@@ -281,55 +281,161 @@ struct __weak_result_type<_R (_C::*)(_A1, _A2, _A3...) const volatile>
 
 // __invoke
 
-// bullets 1 and 2
+// first bullet
 
-template <class _F, class _A0, class ..._Args>
+template <class _R, class _T, class _T1, class ..._Param, class ..._Arg>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
-__invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
-    -> decltype((_STD::forward<_A0>(__a0).*__f)(_STD::forward<_Args>(__args)...))
+typename enable_if
+<
+    sizeof...(_Param) == sizeof...(_Arg) &&
+    is_base_of<_T, typename remove_reference<_T1>::type>::value,
+    _R
+>::type
+__invoke(_R (_T::*__f)(_Param...), _T1&& __t1, _Arg&& ...__arg)
 {
-    return (_STD::forward<_A0>(__a0).*__f)(_STD::forward<_Args>(__args)...);
+    return (_STD::forward<_T>(__t1).*__f)(_STD::forward<_Arg>(__arg)...);
 }
 
-template <class _F, class _A0, class ..._Args>
+template <class _R, class _T, class _T1, class ..._Param, class ..._Arg>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
-__invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
-    -> decltype(((*_STD::forward<_A0>(__a0)).*__f)(_STD::forward<_Args>(__args)...))
+typename enable_if
+<
+    sizeof...(_Param) == sizeof...(_Arg) &&
+    is_base_of<_T, typename remove_reference<_T1>::type>::value,
+    _R
+>::type
+__invoke(_R (_T::*__f)(_Param...) const, _T1&& __t1, _Arg&& ...__arg)
 {
-    return ((*_STD::forward<_A0>(__a0)).*__f)(_STD::forward<_Args>(__args)...);
+    return (_STD::forward<_T>(__t1).*__f)(_STD::forward<_Arg>(__arg)...);
 }
 
-// bullets 3 and 4
-
-template <class _F, class _A0>
+template <class _R, class _T, class _T1, class ..._Param, class ..._Arg>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
-__invoke(_F&& __f, _A0&& __a0)
-    -> decltype(_STD::forward<_A0>(__a0).*__f)
+typename enable_if
+<
+    sizeof...(_Param) == sizeof...(_Arg) &&
+    is_base_of<_T, typename remove_reference<_T1>::type>::value,
+    _R
+>::type
+__invoke(_R (_T::*__f)(_Param...) volatile, _T1&& __t1, _Arg&& ...__arg)
 {
-    return _STD::forward<_A0>(__a0).*__f;
+    return (_STD::forward<_T>(__t1).*__f)(_STD::forward<_Arg>(__arg)...);
 }
 
-template <class _F, class _A0>
+template <class _R, class _T, class _T1, class ..._Param, class ..._Arg>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
-__invoke(_F&& __f, _A0&& __a0)
-    -> decltype((*_STD::forward<_A0>(__a0)).*__f)
+typename enable_if
+<
+    sizeof...(_Param) == sizeof...(_Arg) &&
+    is_base_of<_T, typename remove_reference<_T1>::type>::value,
+    _R
+>::type
+__invoke(_R (_T::*__f)(_Param...) const volatile, _T1&& __t1, _Arg&& ...__arg)
 {
-    return (*_STD::forward<_A0>(__a0)).*__f;
+    return (_STD::forward<_T>(__t1).*__f)(_STD::forward<_Arg>(__arg)...);
 }
 
-// bullet 5
+// second bullet
 
-template <class _F, class ..._Args>
+template <class _R, class _T, class _T1, class ..._Param, class ..._Arg>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
-__invoke(_F&& __f, _Args&& ...__args)
-    -> decltype(_STD::forward<_F>(__f)(_STD::forward<_Args>(__args)...))
+typename enable_if
+<
+    sizeof...(_Param) == sizeof...(_Arg) &&
+    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
+    _R
+>::type
+__invoke(_R (_T::*__f)(_Param...), _T1&& __t1, _Arg&& ...__arg)
 {
-    return _STD::forward<_F>(__f)(_STD::forward<_Args>(__args)...);
+    return ((*_STD::forward<_T1>(__t1)).*__f)(_STD::forward<_Arg>(__arg)...);
+}
+
+template <class _R, class _T, class _T1, class ..._Param, class ..._Arg>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    sizeof...(_Param) == sizeof...(_Arg) &&
+    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
+    _R
+>::type
+__invoke(_R (_T::*__f)(_Param...) const, _T1&& __t1, _Arg&& ...__arg)
+{
+    return ((*_STD::forward<_T1>(__t1)).*__f)(_STD::forward<_Arg>(__arg)...);
+}
+
+template <class _R, class _T, class _T1, class ..._Param, class ..._Arg>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    sizeof...(_Param) == sizeof...(_Arg) &&
+    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
+    _R
+>::type
+__invoke(_R (_T::*__f)(_Param...) volatile, _T1&& __t1, _Arg&& ...__arg)
+{
+    return ((*_STD::forward<_T1>(__t1)).*__f)(_STD::forward<_Arg>(__arg)...);
+}
+
+template <class _R, class _T, class _T1, class ..._Param, class ..._Arg>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    sizeof...(_Param) == sizeof...(_Arg) &&
+    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
+    _R
+>::type
+__invoke(_R (_T::*__f)(_Param...) const volatile, _T1&& __t1, _Arg&& ...__arg)
+{
+    return ((*_STD::forward<_T1>(__t1)).*__f)(_STD::forward<_Arg>(__arg)...);
+}
+
+// third bullet
+
+template <class _R, class _T, class _T1>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_T, typename remove_reference<_T1>::type>::value,
+    typename __apply_cv<_T1, _R>::type&&
+>::type
+__invoke(_R _T::* __f, _T1&& __t1)
+{
+    return _STD::forward<_T1>(__t1).*__f;
+}
+
+// forth bullet
+
+template <class _T1, class _R, bool>
+struct __4th_helper
+{
+};
+
+template <class _T1, class _R>
+struct __4th_helper<_T1, _R, true>
+{
+    typedef typename __apply_cv<decltype(*_STD::declval<_T1>()), _R>::type type;
+};
+
+template <class _R, class _T, class _T1>
+inline _LIBCPP_INLINE_VISIBILITY
+typename __4th_helper<_T1, _R,
+                      !is_base_of<_T,
+                                  typename remove_reference<_T1>::type
+                                 >::value
+                     >::type&&
+__invoke(_R _T::* __f, _T1&& __t1)
+{
+    return (*_STD::forward<_T1>(__t1)).*__f;
+}
+
+// fifth bullet
+
+template <class _F, class ..._T>
+inline _LIBCPP_INLINE_VISIBILITY
+typename result_of<_F(_T...)>::type
+__invoke(_F&& __f, _T&& ...__t)
+{
+    return _STD::forward<_F>(__f)(_STD::forward<_T>(__t)...);
 }
 
 template <class _Tp, class ..._Args>
@@ -339,7 +445,7 @@ struct __invoke_return
 };
 
 template <class _Tp>
-class _LIBCPP_VISIBLE reference_wrapper
+class reference_wrapper
     : public __weak_result_type<_Tp>
 {
 public:
@@ -350,19 +456,18 @@ private:
 
 public:
     // construct/copy/destroy
-    _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) _NOEXCEPT : __f_(&__f) {}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) : __f_(&__f) {}
+#ifdef _LIBCPP_MOVE
     private: reference_wrapper(type&&); public: // = delete; // do not bind to temps
 #endif
 
     // access
-    _LIBCPP_INLINE_VISIBILITY operator type&    () const _NOEXCEPT {return *__f_;}
-    _LIBCPP_INLINE_VISIBILITY          type& get() const _NOEXCEPT {return *__f_;}
+    _LIBCPP_INLINE_VISIBILITY operator type&    () const {return *__f_;}
+    _LIBCPP_INLINE_VISIBILITY          type& get() const {return *__f_;}
 
     // invoke
     template <class... _ArgTypes>
-       _LIBCPP_INLINE_VISIBILITY
-       typename __invoke_of<type&, _ArgTypes...>::type
+       typename __invoke_return<type&, _ArgTypes...>::type
           operator() (_ArgTypes&&... __args) const
           {
               return __invoke(get(), _STD::forward<_ArgTypes>(__args)...);
@@ -377,7 +482,7 @@ template <class _Tp> struct __is_reference_wrapper
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 reference_wrapper<_Tp>
-ref(_Tp& __t) _NOEXCEPT
+ref(_Tp& __t)
 {
     return reference_wrapper<_Tp>(__t);
 }
@@ -385,7 +490,7 @@ ref(_Tp& __t) _NOEXCEPT
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 reference_wrapper<_Tp>
-ref(reference_wrapper<_Tp> __t) _NOEXCEPT
+ref(reference_wrapper<_Tp> __t)
 {
     return ref(__t.get());
 }
@@ -393,7 +498,7 @@ ref(reference_wrapper<_Tp> __t) _NOEXCEPT
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 reference_wrapper<const _Tp>
-cref(const _Tp& __t) _NOEXCEPT
+cref(const _Tp& __t)
 {
     return reference_wrapper<const _Tp>(__t);
 }
@@ -401,25 +506,15 @@ cref(const _Tp& __t) _NOEXCEPT
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 reference_wrapper<const _Tp>
-cref(reference_wrapper<_Tp> __t) _NOEXCEPT
+cref(reference_wrapper<_Tp> __t)
 {
     return cref(__t.get());
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
-
-template <class _Tp> void ref(const _Tp&& __t) = delete;
-template <class _Tp> void cref(const _Tp&& __t) = delete;
-
-#else  // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
-
-template <class _Tp> void ref(const _Tp&& __t);// = delete;
-template <class _Tp> void cref(const _Tp&& __t);// = delete;
-
-#endif  // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
+template <class _Tp> void ref(const _Tp&& __t);// = delete; // LWG 688
+template <class _Tp> void cref(const _Tp&& __t);// = delete; // LWG 688
+#endif
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 

include/__functional_base_03

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -235,84 +235,84 @@ struct __weak_result_type<_R (_C::*)(_A1, _A2) volatile>
 // __invoke
 
 // __ref_return0
-//
+// 
 // template <class _Tp, bool _HasResultType>
 // struct ________ref_return0  // _HasResultType is true
 // {
 //     typedef typename _Tp::result_type type;
 // };
-//
+// 
 // template <class _Tp>
 // struct ________ref_return0<_Tp, false>
 // {
 //     typedef void type;
 // };
-//
+// 
 // template <class _Tp, bool _IsClass>
 // struct ____ref_return0  // _IsClass is true
 //     : public ________ref_return0<_Tp, __has_result_type<typename remove_cv<_Tp>::type>::value>
 // {
 // };
-//
+// 
 // template <class _Tp, bool _HasResultType>
 // struct ______ref_return0  // _HasResultType is true
 // {
 //     typedef typename __callable_type<_Tp>::result_type type;
 // };
-//
+// 
 // template <class _Tp>
 // struct ______ref_return0<_Tp, false>  // pointer to member data
 // {
 //     typedef void type;
 // };
-//
+// 
 // template <class _Tp>
 // struct ____ref_return0<_Tp, false>
 //     : public ______ref_return0<typename remove_cv<_Tp>::type,
 //                  __has_result_type<__callable_type<typename remove_cv<_Tp>::type> >::value>
 // {
 // };
-//
+// 
 // template <class _Tp>
 // struct __ref_return0
 //     : public ____ref_return0<typename remove_reference<_Tp>::type,
 //                    is_class<typename remove_reference<_Tp>::type>::value>
 // {
 // };
-//
+// 
 // __ref_return1
-//
+// 
 // template <class _Tp, bool _IsClass, class _A0>
 // struct ____ref_return1  // _IsClass is true
 // {
 //     typedef typename result_of<_Tp(_A0)>::type type;
 // };
-//
+// 
 // template <class _Tp, bool _HasResultType, class _A0>
 // struct ______ref_return1  // _HasResultType is true
 // {
 //     typedef typename __callable_type<_Tp>::result_type type;
 // };
-//
+// 
 // template <class _Tp, class _A0, bool>
 // struct __ref_return1_member_data1;
-//
+// 
 // template <class _R, class _C, class _A0>
 // struct __ref_return1_member_data1<_R _C::*, _A0, true>
 // {
 //     typedef typename __apply_cv<_A0, _R>::type& type;
 // };
-//
+// 
 // template <class _R, class _C, class _A0>
 // struct __ref_return1_member_data1<_R _C::*, _A0, false>
 // {
 //     static _A0 __a;
 //     typedef typename __apply_cv<decltype(*__a), _R>::type& type;
 // };
-//
+// 
 // template <class _Tp, class _A0>
 // struct __ref_return1_member_data;
-//
+// 
 // template <class _R, class _C, class _A0>
 // struct __ref_return1_member_data<_R _C::*, _A0>
 //     : public __ref_return1_member_data1<_R _C::*, _A0,
@@ -320,90 +320,90 @@ struct __weak_result_type<_R (_C::*)(_A1, _A2) volatile>
 //                         typename remove_cv<typename remove_reference<_A0>::type>::type>::value>
 // {
 // };
-//
+// 
 // template <class _Tp, class _A0>
 // struct ______ref_return1<_Tp, false, _A0>  // pointer to member data
 //     : public __ref_return1_member_data<typename remove_cv<_Tp>::type, _A0>
 // {
 // };
-//
+// 
 // template <class _Tp, class _A0>
 // struct ____ref_return1<_Tp, false, _A0>
 //     : public ______ref_return1<typename remove_cv<_Tp>::type,
 //                  __has_result_type<__callable_type<typename remove_cv<_Tp>::type> >::value, _A0>
 // {
 // };
-//
+// 
 // template <class _Tp, class _A0>
 // struct __ref_return1
 //     : public ____ref_return1<typename remove_reference<_Tp>::type,
 //                    is_class<typename remove_reference<_Tp>::type>::value, _A0>
 // {
 // };
-//
+// 
 // __ref_return2
-//
+// 
 // template <class _Tp, bool _IsClass, class _A0, class _A1>
 // struct ____ref_return2  // _IsClass is true
 // {
 //     typedef typename result_of<_Tp(_A0, _A1)>::type type;
 // };
-//
+// 
 // template <class _Tp, bool _HasResultType, class _A0, class _A1>
 // struct ______ref_return2  // _HasResultType is true
 // {
 //     typedef typename __callable_type<_Tp>::result_type type;
 // };
-//
+// 
 // template <class _Tp>
 // struct ______ref_return2<_Tp, false, class _A0, class _A1>  // pointer to member data
 // {
 //     static_assert(sizeof(_Tp) == 0, "An attempt has been made to `call` a pointer"
 //                          " to member data with too many arguments.");
 // };
-//
+// 
 // template <class _Tp, class _A0, class _A1>
 // struct ____ref_return2<_Tp, false, _A0, _A1>
 //     : public ______ref_return2<typename remove_cv<_Tp>::type,
 //                  __has_result_type<__callable_type<typename remove_cv<_Tp>::type> >::value, _A0, _A1>
 // {
 // };
-//
+// 
 // template <class _Tp, class _A0, class _A1>
 // struct __ref_return2
 //     : public ____ref_return2<typename remove_reference<_Tp>::type,
 //                    is_class<typename remove_reference<_Tp>::type>::value, _A0, _A1>
 // {
 // };
-//
+// 
 // __ref_return3
-//
+// 
 // template <class _Tp, bool _IsClass, class _A0, class _A1, class _A2>
 // struct ____ref_return3  // _IsClass is true
 // {
 //     typedef typename result_of<_Tp(_A0, _A1, _A2)>::type type;
 // };
-//
+// 
 // template <class _Tp, bool _HasResultType, class _A0, class _A1, class _A2>
 // struct ______ref_return3  // _HasResultType is true
 // {
 //     typedef typename __callable_type<_Tp>::result_type type;
 // };
-//
+// 
 // template <class _Tp>
 // struct ______ref_return3<_Tp, false, class _A0, class _A1, class _A2>  // pointer to member data
 // {
 //     static_assert(sizeof(_Tp) == 0, "An attempt has been made to `call` a pointer"
 //                          " to member data with too many arguments.");
 // };
-//
+// 
 // template <class _Tp, class _A0, class _A1, class _A2>
 // struct ____ref_return3<_Tp, false, _A0, _A1, _A2>
 //     : public ______ref_return3<typename remove_cv<_Tp>::type,
 //                  __has_result_type<__callable_type<typename remove_cv<_Tp>::type> >::value, _A0, _A1, _A2>
 // {
 // };
-//
+// 
 // template <class _Tp, class _A0, class _A1, class _A2>
 // struct __ref_return3
 //     : public ____ref_return3<typename remove_reference<_Tp>::type,
@@ -411,6 +411,7 @@ struct __weak_result_type<_R (_C::*)(_A1, _A2) volatile>
 // {
 // };
 
+
 // first bullet
 
 template <class _R, class _T, class _T1>
@@ -873,7 +874,7 @@ __invoke(_R _T::* __f, _T1& __t1)
 
 template <class _F>
 inline _LIBCPP_INLINE_VISIBILITY
-decltype(declval<_F>()())
+typename result_of<_F()>::type
 __invoke(_F __f)
 {
     return __f();
@@ -881,7 +882,7 @@ __invoke(_F __f)
 
 template <class _F, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
-decltype(declval<_F>()(declval<_A0&>()))
+typename result_of<_F(_A0)>::type
 __invoke(_F __f, _A0& __a0)
 {
     return __f(__a0);
@@ -889,7 +890,7 @@ __invoke(_F __f, _A0& __a0)
 
 template <class _F, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
-decltype(declval<_F>()(declval<_A0&>(), declval<_A1&>()))
+typename result_of<_F(_A0, _A1)>::type
 __invoke(_F __f, _A0& __a0, _A1& __a1)
 {
     return __f(__a0, __a1);
@@ -897,7 +898,7 @@ __invoke(_F __f, _A0& __a0, _A1& __a1)
 
 template <class _F, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
-decltype(declval<_F>()(declval<_A0&>(), declval<_A1&>(), declval<_A2&>()))
+typename result_of<_F(_A0, _A1, _A2)>::type
 __invoke(_F __f, _A0& __a0, _A1& __a1, _A2& __a2)
 {
     return __f(__a0, __a1, __a2);
@@ -910,7 +911,7 @@ __invoke(_F __f, _A0& __a0, _A1& __a1, _A2& __a2)
 // {
 //     return __f();
 // }
-//
+// 
 // template <class _R, class _F, class _A0>
 // inline _LIBCPP_INLINE_VISIBILITY
 // typename enable_if
@@ -922,7 +923,7 @@ __invoke(_F __f, _A0& __a0, _A1& __a1, _A2& __a2)
 // {
 //     return __f(__a0);
 // }
-//
+// 
 // template <class _R, class _F, class _A0, class _A1>
 // inline _LIBCPP_INLINE_VISIBILITY
 // _R
@@ -930,7 +931,7 @@ __invoke(_F __f, _A0& __a0, _A1& __a1, _A2& __a2)
 // {
 //     return __f(__a0, __a1);
 // }
-//
+// 
 // template <class _R, class _F, class _A0, class _A1, class _A2>
 // inline _LIBCPP_INLINE_VISIBILITY
 // _R
@@ -996,7 +997,7 @@ struct __invoke_return2
 };
 
 template <class _Tp>
-class _LIBCPP_VISIBLE reference_wrapper
+class reference_wrapper
     : public __weak_result_type<_Tp>
 {
 public:
@@ -1015,7 +1016,6 @@ public:
 
     // invoke
 
-    _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return<type&>::type
        operator() () const
        {
@@ -1023,7 +1023,6 @@ public:
        }
 
     template <class _A0>
-       _LIBCPP_INLINE_VISIBILITY
        typename __invoke_return0<type&, _A0>::type
           operator() (_A0& __a0) const
           {
@@ -1031,7 +1030,6 @@ public:
           }
 
     template <class _A0, class _A1>
-       _LIBCPP_INLINE_VISIBILITY
        typename __invoke_return1<type&, _A0, _A1>::type
           operator() (_A0& __a0, _A1& __a1) const
           {
@@ -1039,7 +1037,6 @@ public:
           }
 
     template <class _A0, class _A1, class _A2>
-       _LIBCPP_INLINE_VISIBILITY
        typename __invoke_return2<type&, _A0, _A1, _A2>::type
           operator() (_A0& __a0, _A1& __a1, _A2& __a2) const
           {
@@ -1084,4 +1081,4 @@ cref(reference_wrapper<_Tp> __t)
     return cref(__t.get());
 }
 
-#endif  // _LIBCPP_FUNCTIONAL_BASE_03
+#endif

include/__locale

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -27,10 +27,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 class locale;
 
-template <class _Facet> bool has_facet(const locale&) _NOEXCEPT;
+template <class _Facet> bool has_facet(const locale&) throw();
 template <class _Facet> const _Facet& use_facet(const locale&);
 
-class _LIBCPP_VISIBLE locale
+class locale
 {
 public:
     // types:
@@ -49,19 +49,18 @@ public:
         all = collate | ctype | monetary | numeric | time | messages;
 
     // construct/copy/destroy:
-    locale()  _NOEXCEPT;
-    locale(const locale&)  _NOEXCEPT;
+    locale() throw();
+    locale(const locale&) throw();
     explicit locale(const char*);
     explicit locale(const string&);
     locale(const locale&, const char*, category);
     locale(const locale&, const string&, category);
-    template <class _Facet>
-        _LIBCPP_INLINE_VISIBILITY locale(const locale&, _Facet*);
+    template <class _Facet> locale(const locale&, _Facet*);
     locale(const locale&, const locale&, category);
 
-    ~locale();
+    ~locale() throw();
 
-    const locale& operator=(const locale&)  _NOEXCEPT;
+    const locale& operator=(const locale&) throw();
 
     template <class _Facet> locale combine(const locale&) const;
 
@@ -86,15 +85,14 @@ private:
     bool has_facet(id&) const;
     const facet* use_facet(id&) const;
 
-    template <class _Facet> friend bool has_facet(const locale&)  _NOEXCEPT;
+    template <class _Facet> friend bool has_facet(const locale&) throw();
     template <class _Facet> friend const _Facet& use_facet(const locale&);
 };
 
-class _LIBCPP_VISIBLE locale::facet
+class locale::facet
     : public __shared_count
 {
 protected:
-    _LIBCPP_INLINE_VISIBILITY
     explicit facet(size_t __refs = 0)
         : __shared_count(static_cast<long>(__refs)-1) {}
 
@@ -103,17 +101,17 @@ protected:
 //    facet(const facet&) = delete;     // effectively done in __shared_count
 //    void operator=(const facet&) = delete;
 private:
-    virtual void __on_zero_shared() _NOEXCEPT;
+    virtual void __on_zero_shared();
 };
 
-class _LIBCPP_VISIBLE locale::id
+class locale::id
 {
     once_flag      __flag_;
     int32_t        __id_;
-
+   
     static int32_t __next_id;
 public:
-    _LIBCPP_INLINE_VISIBILITY id() {}
+    id() {}
 private:
     void __init();
     void operator=(const id&); // = delete;
@@ -136,17 +134,15 @@ template <class _Facet>
 locale
 locale::combine(const locale& __other) const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (!_STD::has_facet<_Facet>(__other))
         throw runtime_error("locale::combine: locale missing facet");
-#endif  // _LIBCPP_NO_EXCEPTIONS
     return locale(*this, &const_cast<_Facet&>(_STD::use_facet<_Facet>(__other)));
 }
 
 template <class _Facet>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-has_facet(const locale& __l)  _NOEXCEPT
+has_facet(const locale& __l) throw()
 {
     return __l.has_facet(_Facet::id);
 }
@@ -162,31 +158,27 @@ use_facet(const locale& __l)
 // template <class _CharT> class collate;
 
 template <class _CharT>
-class _LIBCPP_VISIBLE collate
+class collate
     : public locale::facet
 {
 public:
     typedef _CharT char_type;
     typedef basic_string<char_type> string_type;
 
-    _LIBCPP_INLINE_VISIBILITY
     explicit collate(size_t __refs = 0)
         : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
     int compare(const char_type* __lo1, const char_type* __hi1,
                 const char_type* __lo2, const char_type* __hi2) const
     {
         return do_compare(__lo1, __hi1, __lo2, __hi2);
     }
 
-    _LIBCPP_INLINE_VISIBILITY
     string_type transform(const char_type* __lo, const char_type* __hi) const
     {
         return do_transform(__lo, __hi);
     }
 
-    _LIBCPP_INLINE_VISIBILITY
     long hash(const char_type* __lo, const char_type* __hi) const
     {
         return do_hash(__lo, __hi);
@@ -241,15 +233,15 @@ collate<_CharT>::do_hash(const char_type* lo, const char_type* hi) const
     return static_cast<long>(h);
 }
 
-extern template class _LIBCPP_VISIBLE collate<char>;
-extern template class _LIBCPP_VISIBLE collate<wchar_t>;
+extern template class collate<char>;
+extern template class collate<wchar_t>;
 
 // template <class CharT> class collate_byname;
 
-template <class _CharT> class _LIBCPP_VISIBLE collate_byname;
+template <class _CharT> class collate_byname;
 
 template <>
-class _LIBCPP_VISIBLE collate_byname<char>
+class collate_byname<char>
     : public collate<char>
 {
     locale_t __l;
@@ -268,7 +260,7 @@ protected:
 };
 
 template <>
-class _LIBCPP_VISIBLE collate_byname<wchar_t>
+class collate_byname<wchar_t>
     : public collate<wchar_t>
 {
     locale_t __l;
@@ -299,8 +291,7 @@ locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
 
 // template <class charT> class ctype
 
-class _LIBCPP_VISIBLE ctype_base
-{
+class ctype_base {
 public:
     typedef __uint32_t mask;
 
@@ -315,7 +306,7 @@ public:
     static const mask punct  = _CTYPE_P;
     static const mask xdigit = _CTYPE_X;
     static const mask blank  = _CTYPE_B;
-#else  // __APPLE__
+#else  /* !__APPLE__ */
     static const mask space  = _ISspace;
     static const mask print  = _ISprint;
     static const mask cntrl  = _IScntrl;
@@ -326,23 +317,23 @@ public:
     static const mask punct  = _ISpunct;
     static const mask xdigit = _ISxdigit;
     static const mask blank  = _ISblank;
-#endif  // __APPLE__
+#endif  /* __APPLE__ */
     static const mask alnum  = alpha | digit;
     static const mask graph  = alnum | punct;
 
     _LIBCPP_ALWAYS_INLINE ctype_base() {}
 };
 
-template <class _CharT> class _LIBCPP_VISIBLE ctype;
+template <class _CharT> class ctype;
 
 template <>
-class _LIBCPP_VISIBLE ctype<wchar_t>
+class ctype<wchar_t>
     : public locale::facet,
       public ctype_base
 {
 public:
     typedef wchar_t char_type;
-
+   
     _LIBCPP_ALWAYS_INLINE
     explicit ctype(size_t __refs = 0)
         : locale::facet(__refs) {}
@@ -438,7 +429,7 @@ protected:
 };
 
 template <>
-class _LIBCPP_VISIBLE ctype<char>
+class ctype<char>
     : public locale::facet, public ctype_base
 {
     const mask* __tab_;
@@ -451,7 +442,7 @@ public:
     _LIBCPP_ALWAYS_INLINE
     bool is(mask __m, char_type __c) const
     {
-        return isascii(__c) ? (__tab_ ? __tab_[__c] & __m : isctype(__c, __m)) : false;
+        return isascii(__c) ? __tab_[__c] & __m : false;
     }
 
     _LIBCPP_ALWAYS_INLINE
@@ -535,8 +526,8 @@ public:
 #else
     static const size_t table_size = 256;  // FIXME: Don't hardcode this.
 #endif
-    _LIBCPP_ALWAYS_INLINE const mask* table() const  _NOEXCEPT {return __tab_;}
-    static const mask* classic_table()  _NOEXCEPT;
+    const mask* table() const throw() {return __tab_;}
+    static const mask* classic_table() throw();
 
 protected:
     ~ctype();
@@ -552,10 +543,10 @@ protected:
 
 // template <class CharT> class ctype_byname;
 
-template <class _CharT> class _LIBCPP_VISIBLE ctype_byname;
+template <class _CharT> class ctype_byname;
 
 template <>
-class _LIBCPP_VISIBLE ctype_byname<char>
+class ctype_byname<char>
     : public ctype<char>
 {
     locale_t __l;
@@ -573,7 +564,7 @@ protected:
 };
 
 template <>
-class _LIBCPP_VISIBLE ctype_byname<wchar_t>
+class ctype_byname<wchar_t>
     : public ctype<wchar_t>
 {
     locale_t __l;
@@ -704,7 +695,7 @@ tolower(_CharT __c, const locale& __loc)
 
 // codecvt_base
 
-class _LIBCPP_VISIBLE codecvt_base
+class codecvt_base
 {
 public:
     _LIBCPP_ALWAYS_INLINE codecvt_base() {}
@@ -713,12 +704,12 @@ public:
 
 // template <class internT, class externT, class stateT> class codecvt;
 
-template <class _InternT, class _ExternT, class _StateT> class _LIBCPP_VISIBLE codecvt;
+template <class _InternT, class _ExternT, class _StateT> class codecvt;
 
 // template <> class codecvt<char, char, mbstate_t>
 
 template <>
-class _LIBCPP_VISIBLE codecvt<char, char, mbstate_t>
+class codecvt<char, char, mbstate_t>
     : public locale::facet,
       public codecvt_base
 {
@@ -755,13 +746,13 @@ public:
     }
 
     _LIBCPP_ALWAYS_INLINE
-    int encoding() const  _NOEXCEPT
+    int encoding() const throw()
     {
         return do_encoding();
     }
 
     _LIBCPP_ALWAYS_INLINE
-    bool always_noconv() const  _NOEXCEPT
+    bool always_noconv() const throw()
     {
         return do_always_noconv();
     }
@@ -773,7 +764,7 @@ public:
     }
 
     _LIBCPP_ALWAYS_INLINE
-    int max_length() const  _NOEXCEPT
+    int max_length() const throw()
     {
         return do_max_length();
     }
@@ -795,16 +786,16 @@ protected:
                          intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result do_unshift(state_type& __st,
                               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
+    virtual int do_encoding() const throw();
+    virtual bool do_always_noconv() const throw();
     virtual int do_length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+    virtual int do_max_length() const throw();
 };
 
 // template <> class codecvt<wchar_t, char, mbstate_t>
 
 template <>
-class _LIBCPP_VISIBLE codecvt<wchar_t, char, mbstate_t>
+class codecvt<wchar_t, char, mbstate_t>
     : public locale::facet,
       public codecvt_base
 {
@@ -840,13 +831,13 @@ public:
     }
 
     _LIBCPP_ALWAYS_INLINE
-    int encoding() const  _NOEXCEPT
+    int encoding() const throw()
     {
         return do_encoding();
     }
 
     _LIBCPP_ALWAYS_INLINE
-    bool always_noconv() const  _NOEXCEPT
+    bool always_noconv() const throw()
     {
         return do_always_noconv();
     }
@@ -858,7 +849,7 @@ public:
     }
 
     _LIBCPP_ALWAYS_INLINE
-    int max_length() const  _NOEXCEPT
+    int max_length() const throw()
     {
         return do_max_length();
     }
@@ -878,16 +869,16 @@ protected:
                          intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result do_unshift(state_type& __st,
                               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
+    virtual int do_encoding() const throw();
+    virtual bool do_always_noconv() const throw();
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+    virtual int do_max_length() const throw();
 };
 
 // template <> class codecvt<char16_t, char, mbstate_t>
 
 template <>
-class _LIBCPP_VISIBLE codecvt<char16_t, char, mbstate_t>
+class codecvt<char16_t, char, mbstate_t>
     : public locale::facet,
       public codecvt_base
 {
@@ -924,13 +915,13 @@ public:
     }
 
     _LIBCPP_ALWAYS_INLINE
-    int encoding() const  _NOEXCEPT
+    int encoding() const throw()
     {
         return do_encoding();
     }
 
     _LIBCPP_ALWAYS_INLINE
-    bool always_noconv() const  _NOEXCEPT
+    bool always_noconv() const throw()
     {
         return do_always_noconv();
     }
@@ -942,7 +933,7 @@ public:
     }
 
     _LIBCPP_ALWAYS_INLINE
-    int max_length() const  _NOEXCEPT
+    int max_length() const throw()
     {
         return do_max_length();
     }
@@ -964,16 +955,16 @@ protected:
                          intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result do_unshift(state_type& __st,
                               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
+    virtual int do_encoding() const throw();
+    virtual bool do_always_noconv() const throw();
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+    virtual int do_max_length() const throw();
 };
 
 // template <> class codecvt<char32_t, char, mbstate_t>
 
 template <>
-class _LIBCPP_VISIBLE codecvt<char32_t, char, mbstate_t>
+class codecvt<char32_t, char, mbstate_t>
     : public locale::facet,
       public codecvt_base
 {
@@ -1010,13 +1001,13 @@ public:
     }
 
     _LIBCPP_ALWAYS_INLINE
-    int encoding() const  _NOEXCEPT
+    int encoding() const throw()
     {
         return do_encoding();
     }
 
     _LIBCPP_ALWAYS_INLINE
-    bool always_noconv() const  _NOEXCEPT
+    bool always_noconv() const throw()
     {
         return do_always_noconv();
     }
@@ -1028,7 +1019,7 @@ public:
     }
 
     _LIBCPP_ALWAYS_INLINE
-    int max_length() const  _NOEXCEPT
+    int max_length() const throw()
     {
         return do_max_length();
     }
@@ -1050,23 +1041,21 @@ protected:
                          intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result do_unshift(state_type& __st,
                               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
+    virtual int do_encoding() const throw();
+    virtual bool do_always_noconv() const throw();
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+    virtual int do_max_length() const throw();
 };
 
 // template <class _InternT, class _ExternT, class _StateT> class codecvt_byname
 
 template <class _InternT, class _ExternT, class _StateT>
-class _LIBCPP_VISIBLE codecvt_byname
+class codecvt_byname
     : public codecvt<_InternT, _ExternT, _StateT>
 {
 public:
-    _LIBCPP_ALWAYS_INLINE
     explicit codecvt_byname(const char* __nm, size_t __refs = 0)
         : codecvt<_InternT, _ExternT, _StateT>(__nm, __refs) {}
-    _LIBCPP_ALWAYS_INLINE
     explicit codecvt_byname(const string& __nm, size_t __refs = 0)
         : codecvt<_InternT, _ExternT, _StateT>(__nm.c_str(), __refs) {}
 protected:
@@ -1083,7 +1072,7 @@ extern template class codecvt_byname<wchar_t, char, mbstate_t>;
 extern template class codecvt_byname<char16_t, char, mbstate_t>;
 extern template class codecvt_byname<char32_t, char, mbstate_t>;
 
-_LIBCPP_VISIBLE void __throw_runtime_error(const char*);
+void __throw_runtime_error(const char*);
 
 template <size_t _N>
 struct __narrow_to_utf8
@@ -1267,10 +1256,10 @@ struct __widen_from_utf8<32>
 
 // template <class charT> class numpunct
 
-template <class _CharT> class _LIBCPP_VISIBLE numpunct;
+template <class _CharT> class numpunct;
 
 template <>
-class _LIBCPP_VISIBLE numpunct<char>
+class numpunct<char>
     : public locale::facet
 {
 public:
@@ -1301,7 +1290,7 @@ protected:
 };
 
 template <>
-class _LIBCPP_VISIBLE numpunct<wchar_t>
+class numpunct<wchar_t>
     : public locale::facet
 {
 public:
@@ -1333,10 +1322,10 @@ protected:
 
 // template <class charT> class numpunct_byname
 
-template <class charT> class _LIBCPP_VISIBLE numpunct_byname;
+template <class charT> class numpunct_byname;
 
 template <>
-class _LIBCPP_VISIBLE numpunct_byname<char>
+class numpunct_byname<char>
 : public numpunct<char>
 {
 public:
@@ -1354,7 +1343,7 @@ private:
 };
 
 template <>
-class _LIBCPP_VISIBLE numpunct_byname<wchar_t>
+class numpunct_byname<wchar_t>
 : public numpunct<wchar_t>
 {
 public:

include/__mutex_base

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -18,24 +18,13 @@
 
 #pragma GCC system_header
 
-#ifdef _LIBCPP_SHARED_LOCK
-
-namespace ting {
-template <class> class shared_lock;
-template <class> class upgrade_lock;
-}
-
-#endif  // _LIBCPP_SHARED_LOCK
-
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_VISIBLE mutex
+class mutex
 {
     pthread_mutex_t __m_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
      mutex() {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;}
      ~mutex();
 
@@ -49,12 +38,12 @@ public:
     void unlock();
 
     typedef pthread_mutex_t* native_handle_type;
-    _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
+    native_handle_type native_handle() {return &__m_;}
 };
 
-struct _LIBCPP_VISIBLE defer_lock_t {};
-struct _LIBCPP_VISIBLE try_to_lock_t {};
-struct _LIBCPP_VISIBLE adopt_lock_t {};
+struct defer_lock_t {};
+struct try_to_lock_t {};
+struct adopt_lock_t {};
 
 //constexpr
 extern const
@@ -69,7 +58,7 @@ extern const
 adopt_lock_t  adopt_lock;
 
 template <class _Mutex>
-class _LIBCPP_VISIBLE lock_guard
+class lock_guard
 {
 public:
     typedef _Mutex mutex_type;
@@ -78,13 +67,10 @@ private:
     mutex_type& __m_;
 public:
 
-    _LIBCPP_INLINE_VISIBILITY
     explicit lock_guard(mutex_type& __m)
         : __m_(__m) {__m_.lock();}
-    _LIBCPP_INLINE_VISIBILITY
     lock_guard(mutex_type& __m, adopt_lock_t)
         : __m_(__m) {}
-    _LIBCPP_INLINE_VISIBILITY
     ~lock_guard() {__m_.unlock();}
 
 private:
@@ -93,7 +79,7 @@ private:
 };
 
 template <class _Mutex>
-class _LIBCPP_VISIBLE unique_lock
+class unique_lock
 {
 public:
     typedef _Mutex mutex_type;
@@ -103,29 +89,21 @@ private:
     bool __owns_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
     unique_lock() : __m_(nullptr), __owns_(false) {}
-    _LIBCPP_INLINE_VISIBILITY
     explicit unique_lock(mutex_type& __m)
         : __m_(&__m), __owns_(true) {__m_->lock();}
-    _LIBCPP_INLINE_VISIBILITY
     unique_lock(mutex_type& __m, defer_lock_t)
         : __m_(&__m), __owns_(false) {}
-    _LIBCPP_INLINE_VISIBILITY
     unique_lock(mutex_type& __m, try_to_lock_t)
         : __m_(&__m), __owns_(__m.try_lock()) {}
-    _LIBCPP_INLINE_VISIBILITY
     unique_lock(mutex_type& __m, adopt_lock_t)
         : __m_(&__m), __owns_(true) {}
     template <class _Clock, class _Duration>
-    _LIBCPP_INLINE_VISIBILITY
         unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
             : __m_(&__m), __owns_(__m.try_lock_until(__t)) {}
     template <class _Rep, class _Period>
-    _LIBCPP_INLINE_VISIBILITY
         unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
             : __m_(&__m), __owns_(__m.try_lock_for(__d)) {}
-    _LIBCPP_INLINE_VISIBILITY
     ~unique_lock()
     {
         if (__owns_)
@@ -137,12 +115,10 @@ private:
     unique_lock& operator=(unique_lock const&); // = delete;
 
 public:
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     unique_lock(unique_lock&& __u)
         : __m_(__u.__m_), __owns_(__u.__owns_)
         {__u.__m_ = nullptr; __u.__owns_ = false;}
-    _LIBCPP_INLINE_VISIBILITY
     unique_lock& operator=(unique_lock&& __u)
         {
             if (__owns_)
@@ -153,29 +129,7 @@ public:
             __u.__owns_ = false;
             return *this;
         }
-
-#ifdef _LIBCPP_SHARED_LOCK
-
-    unique_lock(ting::shared_lock<mutex_type>&&, try_to_lock_t);
-    template <class _Clock, class _Duration>
-        unique_lock(ting::shared_lock<mutex_type>&&,
-                    const chrono::time_point<_Clock, _Duration>&);
-    template <class _Rep, class _Period>
-        unique_lock(ting::shared_lock<mutex_type>&&,
-                    const chrono::duration<_Rep, _Period>&);
-
-    explicit unique_lock(ting::upgrade_lock<mutex_type>&&);
-    unique_lock(ting::upgrade_lock<mutex_type>&&, try_to_lock_t);
-    template <class _Clock, class _Duration>
-        unique_lock(ting::upgrade_lock<mutex_type>&&,
-                    const chrono::time_point<_Clock, _Duration>&);
-    template <class _Rep, class _Period>
-        unique_lock(ting::upgrade_lock<mutex_type>&&,
-                    const chrono::duration<_Rep, _Period>&);
-
-#endif  // _LIBCPP_SHARED_LOCK
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
     void lock();
     bool try_lock();
@@ -187,13 +141,11 @@ public:
 
     void unlock();
 
-    _LIBCPP_INLINE_VISIBILITY
     void swap(unique_lock& __u)
     {
         _STD::swap(__m_, __u.__m_);
         _STD::swap(__owns_, __u.__owns_);
     }
-    _LIBCPP_INLINE_VISIBILITY
     mutex_type* release()
     {
         mutex_type* __m = __m_;
@@ -202,12 +154,9 @@ public:
         return __m;
     }
 
-    _LIBCPP_INLINE_VISIBILITY
     bool owns_lock() const {return __owns_;}
-    _LIBCPP_INLINE_VISIBILITY
 //    explicit
         operator bool () const {return __owns_;}
-    _LIBCPP_INLINE_VISIBILITY
     mutex_type* mutex() const {return __m_;}
 };
 
@@ -272,11 +221,11 @@ unique_lock<_Mutex>::unlock()
 }
 
 template <class _Mutex>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) {__x.swap(__y);}
 
-struct _LIBCPP_VISIBLE cv_status
+struct cv_status
 {
     enum _ {
         no_timeout,
@@ -285,16 +234,15 @@ struct _LIBCPP_VISIBLE cv_status
 
     _ __v_;
 
-    _LIBCPP_INLINE_VISIBILITY cv_status(_ __v) : __v_(__v) {}
-    _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;}
+    cv_status(_ __v) : __v_(__v) {}
+    operator int() const {return __v_;}
 
 };
 
-class _LIBCPP_VISIBLE condition_variable
+class condition_variable
 {
     pthread_cond_t __cv_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
     condition_variable() {__cv_ = (pthread_cond_t)PTHREAD_COND_INITIALIZER;}
     ~condition_variable();
 
@@ -338,7 +286,7 @@ public:
                  _Predicate __pred);
 
     typedef pthread_cond_t* native_handle_type;
-    _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__cv_;}
+    native_handle_type native_handle() {return &__cv_;}
 
 private:
     void __do_timed_wait(unique_lock<mutex>& __lk,
@@ -346,7 +294,7 @@ private:
 };
 
 template <class _To, class _Rep, class _Period>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     chrono::__is_duration<_To>::value,
@@ -414,21 +362,21 @@ condition_variable::wait_for(unique_lock<mutex>& __lk,
                              const chrono::duration<_Rep, _Period>& __d)
 {
     using namespace chrono;
-    system_clock::time_point __s_now = system_clock::now();
-    steady_clock::time_point __c_now = steady_clock::now();
+    system_clock::time_point     __s_now = system_clock::now();
+    monotonic_clock::time_point  __c_now = monotonic_clock::now();
     __do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__d));
-    return steady_clock::now() - __c_now < __d ? cv_status::no_timeout :
-                                                 cv_status::timeout;
+    return monotonic_clock::now() - __c_now < __d ? cv_status::no_timeout :
+                                                    cv_status::timeout;
 }
 
 template <class _Rep, class _Period, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 condition_variable::wait_for(unique_lock<mutex>& __lk,
                              const chrono::duration<_Rep, _Period>& __d,
                              _Predicate __pred)
 {
-    return wait_until(__lk, chrono::steady_clock::now() + __d,
+    return wait_until(__lk, chrono::monotonic_clock::now() + __d,
                       _STD::move(__pred));
 }
 

include/__split_buffer

@@ -18,7 +18,7 @@ protected:
     void __throw_out_of_range() const;
 };
 
-template <class _Tp, class _Allocator = allocator<_Tp> >
+template <class _Tp, class _Allocator>
 struct __split_buffer
     : private __split_buffer_common<true>
 {
@@ -26,7 +26,7 @@ private:
     __split_buffer(const __split_buffer&);
     __split_buffer& operator=(const __split_buffer&);
 public:
-    typedef _Tp                                             value_type;
+    typedef _Tp                                             value_type; 
     typedef _Allocator                                      allocator_type;
     typedef typename remove_reference<allocator_type>::type __alloc_rr;
     typedef allocator_traits<__alloc_rr>                    __alloc_traits;
@@ -47,36 +47,29 @@ public:
     typedef typename add_lvalue_reference<allocator_type>::type __alloc_ref;
     typedef typename add_lvalue_reference<allocator_type>::type __alloc_const_ref;
 
-    _LIBCPP_INLINE_VISIBILITY __alloc_rr&           __alloc() _NOEXCEPT         {return __end_cap_.second();}
-    _LIBCPP_INLINE_VISIBILITY const __alloc_rr&     __alloc() const _NOEXCEPT   {return __end_cap_.second();}
-    _LIBCPP_INLINE_VISIBILITY pointer&              __end_cap() _NOEXCEPT       {return __end_cap_.first();}
-    _LIBCPP_INLINE_VISIBILITY const pointer&        __end_cap() const _NOEXCEPT {return __end_cap_.first();}
+    _LIBCPP_INLINE_VISIBILITY __alloc_rr&           __alloc()         {return __end_cap_.second();}
+    _LIBCPP_INLINE_VISIBILITY const __alloc_rr&     __alloc() const   {return __end_cap_.second();}
+    _LIBCPP_INLINE_VISIBILITY pointer&              __end_cap()       {return __end_cap_.first();}
+    _LIBCPP_INLINE_VISIBILITY const pointer&        __end_cap() const {return __end_cap_.first();}
 
-    __split_buffer()
-        _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
+    __split_buffer();
     explicit __split_buffer(__alloc_rr& __a);
     explicit __split_buffer(const __alloc_rr& __a);
     __split_buffer(size_type __cap, size_type __start, __alloc_rr& __a);
     ~__split_buffer();
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    __split_buffer(__split_buffer&& __c)
-        _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
+#ifdef _LIBCPP_MOVE
+    __split_buffer(__split_buffer&& __c);
     __split_buffer(__split_buffer&& __c, const __alloc_rr& __a);
-    __split_buffer& operator=(__split_buffer&& __c)
-        _NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&
-                is_nothrow_move_assignable<allocator_type>::value) ||
-               !__alloc_traits::propagate_on_container_move_assignment::value);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    __split_buffer& operator=(__split_buffer&& __c);
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY       iterator begin() _NOEXCEPT       {return __begin_;}
-    _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT {return __begin_;}
-    _LIBCPP_INLINE_VISIBILITY       iterator end() _NOEXCEPT         {return __end_;}
-    _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT   {return __end_;}
+    _LIBCPP_INLINE_VISIBILITY       iterator begin()       {return __begin_;}
+    _LIBCPP_INLINE_VISIBILITY const_iterator begin() const {return __begin_;}
+    _LIBCPP_INLINE_VISIBILITY       iterator end()         {return __end_;}
+    _LIBCPP_INLINE_VISIBILITY const_iterator end() const   {return __end_;}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT
-        {__destruct_at_end(__begin_);}
+    _LIBCPP_INLINE_VISIBILITY void clear() {__destruct_at_end(__begin_);}
     _LIBCPP_INLINE_VISIBILITY size_type size() const {return static_cast<size_type>(__end_ - __begin_);}
     _LIBCPP_INLINE_VISIBILITY bool empty()     const {return __end_ == __begin_;}
     _LIBCPP_INLINE_VISIBILITY size_type capacity() const {return static_cast<size_type>(__end_cap() - __first_);}
@@ -89,23 +82,25 @@ public:
     _LIBCPP_INLINE_VISIBILITY const_reference back() const  {return *(__end_ - 1);}
 
     void reserve(size_type __n);
-    void shrink_to_fit() _NOEXCEPT;
+    void shrink_to_fit();
     void push_front(const_reference __x);
     void push_back(const_reference __x);
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
+#ifdef _LIBCPP_MOVE
     void push_front(value_type&& __x);
     void push_back(value_type&& __x);
-#if !defined(_LIBCPP_HAS_NO_VARIADICS)
     template <class... _Args>
         void emplace_back(_Args&&... __args);
-#endif  // !defined(_LIBCPP_HAS_NO_VARIADICS)
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
+#endif
 
     _LIBCPP_INLINE_VISIBILITY void pop_front() {__destruct_at_begin(__begin_+1);}
     _LIBCPP_INLINE_VISIBILITY void pop_back() {__destruct_at_end(__end_-1);}
 
     void __construct_at_end(size_type __n);
+        void __construct_at_end(size_type __n, false_type);
+        void __construct_at_end(size_type __n, true_type);
     void __construct_at_end(size_type __n, const_reference __x);
+        void __construct_at_end(size_type __n, const_reference __x, false_type);
+        void __construct_at_end(size_type __n, const_reference __x, true_type);
     template <class _InputIter>
         typename enable_if
         <
@@ -123,51 +118,38 @@ public:
         __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
 
     _LIBCPP_INLINE_VISIBILITY void __destruct_at_begin(pointer __new_begin)
-        {__destruct_at_begin(__new_begin, is_trivially_destructible<value_type>());}
+        {__destruct_at_begin(__new_begin, has_trivial_destructor<value_type>());}
         void __destruct_at_begin(pointer __new_begin, false_type);
         void __destruct_at_begin(pointer __new_begin, true_type);
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __destruct_at_end(pointer __new_last) _NOEXCEPT
-        {__destruct_at_end(__new_last, is_trivially_destructible<value_type>());}
-        void __destruct_at_end(pointer __new_last, false_type) _NOEXCEPT;
-        void __destruct_at_end(pointer __new_last, true_type) _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY void __destruct_at_end(pointer __new_last)
+        {__destruct_at_end(__new_last, has_trivial_destructor<value_type>());}
+        void __destruct_at_end(pointer __new_last, false_type);
+        void __destruct_at_end(pointer __new_last, true_type);
 
-    void swap(__split_buffer& __x)
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value||
-                   __is_nothrow_swappable<__alloc_rr>::value);
+    void swap(__split_buffer& __x);
 
     bool __invariants() const;
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(const __split_buffer& __c, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
         {
             __alloc() = _STD::move(__c.__alloc());
         }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(const __split_buffer& __c, false_type) _NOEXCEPT
+    void __move_assign_alloc(const __split_buffer& __c, false_type)
         {}
 
-    _LIBCPP_INLINE_VISIBILITY
     static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y)
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value||
-                   __is_nothrow_swappable<__alloc_rr>::value)
         {__swap_alloc(__x, __y, integral_constant<bool,
                       __alloc_traits::propagate_on_container_swap::value>());}
 
-    _LIBCPP_INLINE_VISIBILITY
     static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y, true_type)
-        _NOEXCEPT_(__is_nothrow_swappable<__alloc_rr>::value)
         {
             using _STD::swap;
             swap(__x, __y);
         }
-
-    _LIBCPP_INLINE_VISIBILITY
-    static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y, false_type) _NOEXCEPT
+    static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y, false_type)
         {}
 };
 
@@ -202,8 +184,16 @@ __split_buffer<_Tp, _Allocator>::__invariants() const
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == size() + __n
 template <class _Tp, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
 void
 __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
+{
+    __construct_at_end(__n, __is_zero_default_constructible<value_type>());
+}
+
+template <class _Tp, class _Allocator>
+void
+__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, false_type)
 {
     __alloc_rr& __a = this->__alloc();
     do
@@ -214,6 +204,15 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
     } while (__n > 0);
 }
 
+template <class _Tp, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
+void
+__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, true_type)
+{
+    _STD::memset(this->__end_, 0, __n*sizeof(value_type));
+    this->__end_ += __n;
+}
+
 //  Copy constructs __n objects starting at __end_ from __x
 //  throws if construction throws
 //  Precondition:  __n > 0
@@ -221,8 +220,17 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
 //  Postcondition:  size() == old size() + __n
 //  Postcondition:  [i] == __x for all i in [size() - __n, __n)
 template <class _Tp, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
 void
 __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
+{
+    __construct_at_end(__n, __x, integral_constant<bool, has_trivial_copy_constructor<value_type>::value &&
+                                                         has_trivial_copy_assign<value_type>::value>());
+}
+
+template <class _Tp, class _Allocator>
+void
+__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x, false_type)
 {
     __alloc_rr& __a = this->__alloc();
     do
@@ -233,6 +241,15 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_referen
     } while (__n > 0);
 }
 
+template <class _Tp, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
+void
+__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x, true_type)
+{
+    _STD::fill_n(this->__end_, __n, __x);
+    this->__end_ += __n;
+}
+
 template <class _Tp, class _Allocator>
 template <class _InputIter>
 typename enable_if
@@ -298,7 +315,7 @@ __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, true_t
 template <class _Tp, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 void
-__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT
+__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type)
 {
     while (__new_last < __end_)
         __alloc_traits::destroy(__alloc(), --__end_);
@@ -307,7 +324,7 @@ __split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_typ
 template <class _Tp, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 void
-__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, true_type) _NOEXCEPT
+__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, true_type)
 {
     __end_ = __new_last;
 }
@@ -324,7 +341,6 @@ __split_buffer<_Tp, _Allocator>::__split_buffer(size_type __cap, size_type __sta
 template <class _Tp, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 __split_buffer<_Tp, _Allocator>::__split_buffer()
-    _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __first_(0), __begin_(0), __end_(0), __end_cap_(0)
 {
 }
@@ -351,11 +367,10 @@ __split_buffer<_Tp, _Allocator>::~__split_buffer()
         __alloc_traits::deallocate(__alloc(), __first_, capacity());
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Tp, class _Allocator>
 __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c)
-    _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
     : __first_(_STD::move(__c.__first_)),
       __begin_(_STD::move(__c.__begin_)),
       __end_(_STD::move(__c.__end_)),
@@ -396,9 +411,6 @@ __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c, const __al
 template <class _Tp, class _Allocator>
 __split_buffer<_Tp, _Allocator>&
 __split_buffer<_Tp, _Allocator>::operator=(__split_buffer&& __c)
-    _NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&
-                is_nothrow_move_assignable<allocator_type>::value) ||
-               !__alloc_traits::propagate_on_container_move_assignment::value)
 {
     clear();
     shrink_to_fit();
@@ -413,13 +425,11 @@ __split_buffer<_Tp, _Allocator>::operator=(__split_buffer&& __c)
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _Tp, class _Allocator>
 void
 __split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x)
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value||
-                   __is_nothrow_swappable<__alloc_rr>::value)
 {
     _STD::swap(__first_, __x.__first_);
     _STD::swap(__begin_, __x.__begin_);
@@ -446,14 +456,14 @@ __split_buffer<_Tp, _Allocator>::reserve(size_type __n)
 
 template <class _Tp, class _Allocator>
 void
-__split_buffer<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
+__split_buffer<_Tp, _Allocator>::shrink_to_fit()
 {
     if (capacity() > size())
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
             __split_buffer<value_type, __alloc_rr&> __t(size(), 0, __alloc());
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
@@ -467,7 +477,7 @@ __split_buffer<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
         catch (...)
         {
         }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     }
 }
 
@@ -487,7 +497,7 @@ __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
         else
         {
             size_type __c = max<size_type>(2 * (__end_cap() - __first_), 1);
-            __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
+            __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 2) / 4, __alloc());
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
             _STD::swap(__first_, __t.__first_);
@@ -500,7 +510,7 @@ __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
     --__begin_;
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Tp, class _Allocator>
 void
@@ -518,7 +528,7 @@ __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
         else
         {
             size_type __c = max<size_type>(2 * (__end_cap() - __first_), 1);
-            __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
+            __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 2) / 4, __alloc());
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
             _STD::swap(__first_, __t.__first_);
@@ -532,7 +542,7 @@ __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
     --__begin_;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _Tp, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
@@ -564,7 +574,7 @@ __split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
     ++__end_;
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Tp, class _Allocator>
 void
@@ -596,8 +606,6 @@ __split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
     ++__end_;
 }
 
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
 template <class _Tp, class _Allocator>
 template <class... _Args>
 void
@@ -629,19 +637,7 @@ __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
     ++__end_;
 }
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
-void
-swap(__split_buffer<_Tp, _Allocator>& __x, __split_buffer<_Tp, _Allocator>& __y)
-        _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
-}
-
+#endif
 
 _LIBCPP_END_NAMESPACE_STD
 

include/__sso_allocator

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -64,9 +64,7 @@ public:
     }
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const throw() {return size_type(~0) / sizeof(_Tp);}
 
-    _LIBCPP_INLINE_VISIBILITY
     bool operator==(__sso_allocator& __a) const {return &buf_ == &__a.buf_;}
-    _LIBCPP_INLINE_VISIBILITY
     bool operator!=(__sso_allocator& __a) const {return &buf_ != &__a.buf_;}
 };
 

include/__std_stream

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -97,7 +97,7 @@ typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::__getchar(bool __consume)
 {
     char __extbuf[__limit];
-    int __nread = _STD::max(1, __encoding_);
+    int __nread = max(1, __encoding_);
     for (int __i = 0; __i < __nread; ++__i)
     {
         char __c = getc(__file_);
@@ -288,12 +288,12 @@ __stdoutbuf<_CharT>::sync()
         __r = __cv_->unshift(__st_, __extbuf,
                                     __extbuf + sizeof(__extbuf),
                                     __extbe);
-        if (__r == codecvt_base::error)
-            return -1;
         size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
         if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
             return -1;
     } while (__r == codecvt_base::partial);
+    if (__r == codecvt_base::error)
+        return -1;
     if (fflush(__file_))
         return -1;
     return 0;

include/__tree

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -22,12 +22,12 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class, class, class> class __tree;
-template <class, class, class> class _LIBCPP_VISIBLE __tree_iterator;
-template <class, class, class> class _LIBCPP_VISIBLE __tree_const_iterator;
-template <class, class, class, class> class _LIBCPP_VISIBLE map;
-template <class, class, class, class> class _LIBCPP_VISIBLE multimap;
-template <class, class, class> class _LIBCPP_VISIBLE set;
-template <class, class, class> class _LIBCPP_VISIBLE multiset;
+template <class, class, class> class __tree_iterator;
+template <class, class, class> class __tree_const_iterator;
+template <class, class, class, class> class map;
+template <class, class, class, class> class multimap;
+template <class, class, class> class set;
+template <class, class, class> class multiset;
 
 /*
 
@@ -53,9 +53,9 @@ __root, have a non-null __parent_ field.
 // Returns:  true if __x is a left child of its parent, else false
 // Precondition:  __x != nullptr.
 template <class _NodePtr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
-__tree_is_left_child(_NodePtr __x) _NOEXCEPT
+__tree_is_left_child(_NodePtr __x)
 {
     return __x == __x->__parent_->__left_;
 }
@@ -119,9 +119,9 @@ __tree_invariant(_NodePtr __root)
 // Returns:  pointer to the left-most node under __x.
 // Precondition:  __x != nullptr.
 template <class _NodePtr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _NodePtr
-__tree_min(_NodePtr __x) _NOEXCEPT
+__tree_min(_NodePtr __x)
 {
     while (__x->__left_ != nullptr)
         __x = __x->__left_;
@@ -131,9 +131,9 @@ __tree_min(_NodePtr __x) _NOEXCEPT
 // Returns:  pointer to the right-most node under __x.
 // Precondition:  __x != nullptr.
 template <class _NodePtr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _NodePtr
-__tree_max(_NodePtr __x) _NOEXCEPT
+__tree_max(_NodePtr __x)
 {
     while (__x->__right_ != nullptr)
         __x = __x->__right_;
@@ -144,7 +144,7 @@ __tree_max(_NodePtr __x) _NOEXCEPT
 // Precondition:  __x != nullptr.
 template <class _NodePtr>
 _NodePtr
-__tree_next(_NodePtr __x) _NOEXCEPT
+__tree_next(_NodePtr __x)
 {
     if (__x->__right_ != nullptr)
         return __tree_min(__x->__right_);
@@ -157,7 +157,7 @@ __tree_next(_NodePtr __x) _NOEXCEPT
 // Precondition:  __x != nullptr.
 template <class _NodePtr>
 _NodePtr
-__tree_prev(_NodePtr __x) _NOEXCEPT
+__tree_prev(_NodePtr __x)
 {
     if (__x->__left_ != nullptr)
         return __tree_max(__x->__left_);
@@ -170,7 +170,7 @@ __tree_prev(_NodePtr __x) _NOEXCEPT
 // Precondition:  __x != nullptr.
 template <class _NodePtr>
 _NodePtr
-__tree_leaf(_NodePtr __x) _NOEXCEPT
+__tree_leaf(_NodePtr __x)
 {
     while (true)
     {
@@ -194,7 +194,7 @@ __tree_leaf(_NodePtr __x) _NOEXCEPT
 // Precondition:  __x->__right_ != nullptr
 template <class _NodePtr>
 void
-__tree_left_rotate(_NodePtr __x) _NOEXCEPT
+__tree_left_rotate(_NodePtr __x)
 {
     _NodePtr __y = __x->__right_;
     __x->__right_ = __y->__left_;
@@ -214,7 +214,7 @@ __tree_left_rotate(_NodePtr __x) _NOEXCEPT
 // Precondition:  __x->__left_ != nullptr
 template <class _NodePtr>
 void
-__tree_right_rotate(_NodePtr __x) _NOEXCEPT
+__tree_right_rotate(_NodePtr __x)
 {
     _NodePtr __y = __x->__left_;
     __x->__left_ = __y->__right_;
@@ -239,7 +239,7 @@ __tree_right_rotate(_NodePtr __x) _NOEXCEPT
 //                may be different than the value passed in as __root.
 template <class _NodePtr>
 void
-__tree_balance_after_insert(_NodePtr __root, _NodePtr __x) _NOEXCEPT
+__tree_balance_after_insert(_NodePtr __root, _NodePtr __x)
 {
     __x->__is_black_ = __x == __root;
     while (__x != __root && !__x->__parent_->__is_black_)
@@ -309,7 +309,7 @@ __tree_balance_after_insert(_NodePtr __root, _NodePtr __x) _NOEXCEPT
 //                may be different than the value passed in as __root.
 template <class _NodePtr>
 void
-__tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
+__tree_remove(_NodePtr __root, _NodePtr __z)
 {
     // __z will be removed from the tree.  Client still needs to destruct/deallocate it
     // __y is either __z, or if __z has two children, __tree_next(__z).
@@ -343,7 +343,7 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
     //    but copy __z's color.  This does not impact __x or __w.
     if (__y != __z)
     {
-        // __z->__left_ != nulptr but __z->__right_ might == __x == nullptr
+        // __z->__left_ != nulptr but __z->__right_ might == __x == nullptr 
         __y->__parent_ = __z->__parent_;
         if (__tree_is_left_child(__z))
             __y->__parent_->__left_ = __y;
@@ -413,8 +413,8 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
                         }
                         // reset sibling, and it still can't be null
                         __w = __tree_is_left_child(__x) ?
-                                    __x->__parent_->__right_ :
-                                    __x->__parent_->__left_;
+                                    __x->__parent_->__right_ : 
+                                    __x->__parent_->__left_; 
                         // continue;
                     }
                     else  // __w has a red child
@@ -465,8 +465,8 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
                         }
                         // reset sibling, and it still can't be null
                         __w = __tree_is_left_child(__x) ?
-                                    __x->__parent_->__right_ :
-                                    __x->__parent_->__left_;
+                                    __x->__parent_->__right_ : 
+                                    __x->__parent_->__left_; 
                         // continue;
                     }
                     else  // __w has a red child
@@ -496,6 +496,7 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
 
 template <class> class __map_node_destructor;
 
+
 template <class _Allocator>
 class __tree_node_destructor
 {
@@ -513,17 +514,15 @@ private:
 public:
     bool __value_constructed;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __tree_node_destructor(allocator_type& __na) _NOEXCEPT
+    explicit __tree_node_destructor(allocator_type& __na)
         : __na_(__na),
           __value_constructed(false)
         {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()(pointer __p) _NOEXCEPT
+    void operator()(pointer __p)
     {
         if (__value_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_));
+            __alloc_traits::destroy(__na_, addressof(__p->__value_));
         if (__p)
             __alloc_traits::deallocate(__na_, __p, 1);
     }
@@ -540,8 +539,7 @@ public:
     typedef _Pointer pointer;
     pointer __left_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __tree_end_node() _NOEXCEPT : __left_() {}
+    __tree_end_node() : __left_() {}
 };
 
 template <class _VoidPtr>
@@ -579,9 +577,7 @@ public:
     pointer __parent_;
     bool __is_black_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __tree_node_base() _NOEXCEPT
-        : __right_(), __parent_(), __is_black_(false) {}
+    __tree_node_base() : __right_(), __parent_(), __is_black_(false) {}
 };
 
 template <class _Tp, class _VoidPtr>
@@ -594,23 +590,21 @@ public:
 
     value_type __value_;
 
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+#ifdef _LIBCPP_MOVE
     template <class ..._Args>
-        _LIBCPP_INLINE_VISIBILITY
         explicit __tree_node(_Args&& ...__args)
             : __value_(_STD::forward<_Args>(__args)...) {}
-#else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
-    _LIBCPP_INLINE_VISIBILITY
+#else
     explicit __tree_node(const value_type& __v)
             : __value_(__v) {}
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+#endif
 };
 
 template <class> class __map_iterator;
 template <class> class __map_const_iterator;
 
 template <class _Tp, class _NodePtr, class _DiffType>
-class _LIBCPP_VISIBLE __tree_iterator
+class __tree_iterator
 {
     typedef _NodePtr                                              __node_pointer;
     typedef typename pointer_traits<__node_pointer>::element_type __node;
@@ -633,48 +627,41 @@ public:
 #endif
                                        pointer;
 
-    _LIBCPP_INLINE_VISIBILITY __tree_iterator() _NOEXCEPT {}
+    __tree_iterator() {}
 
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return __ptr_->__value_;}
-    _LIBCPP_INLINE_VISIBILITY pointer operator->() const {return &__ptr_->__value_;}
+    reference operator*() const {return __ptr_->__value_;}
+    pointer operator->() const {return &__ptr_->__value_;}
 
-    _LIBCPP_INLINE_VISIBILITY
     __tree_iterator& operator++()
         {__ptr_ = static_cast<__node_pointer>(__tree_next(static_cast<__node_base_pointer>(__ptr_)));
          return *this;}
-    _LIBCPP_INLINE_VISIBILITY
     __tree_iterator operator++(int)
         {__tree_iterator __t(*this); ++(*this); return __t;}
 
-    _LIBCPP_INLINE_VISIBILITY
     __tree_iterator& operator--()
         {__ptr_ = static_cast<__node_pointer>(__tree_prev(static_cast<__node_base_pointer>(__ptr_)));
          return *this;}
-    _LIBCPP_INLINE_VISIBILITY
     __tree_iterator operator--(int)
         {__tree_iterator __t(*this); --(*this); return __t;}
 
-    friend _LIBCPP_INLINE_VISIBILITY 
-        bool operator==(const __tree_iterator& __x, const __tree_iterator& __y)
+    friend bool operator==(const __tree_iterator& __x, const __tree_iterator& __y)
         {return __x.__ptr_ == __y.__ptr_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const __tree_iterator& __x, const __tree_iterator& __y)
+    friend bool operator!=(const __tree_iterator& __x, const __tree_iterator& __y)
         {return !(__x == __y);}
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __tree_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+    explicit __tree_iterator(__node_pointer __p) : __ptr_(__p) {}
     template <class, class, class> friend class __tree;
-    template <class, class, class> friend class _LIBCPP_VISIBLE __tree_const_iterator;
-    template <class> friend class _LIBCPP_VISIBLE __map_iterator;
-    template <class, class, class, class> friend class _LIBCPP_VISIBLE map;
-    template <class, class, class, class> friend class _LIBCPP_VISIBLE multimap;
-    template <class, class, class> friend class _LIBCPP_VISIBLE set;
-    template <class, class, class> friend class _LIBCPP_VISIBLE multiset;
+    template <class, class, class> friend class __tree_const_iterator;
+    template <class> friend class __map_iterator;
+    template <class, class, class, class> friend class map;
+    template <class, class, class, class> friend class multimap;
+    template <class, class, class> friend class set;
+    template <class, class, class> friend class multiset;
 };
 
 template <class _Tp, class _ConstNodePtr, class _DiffType>
-class _LIBCPP_VISIBLE __tree_const_iterator
+class __tree_const_iterator
 {
     typedef _ConstNodePtr                                         __node_pointer;
     typedef typename pointer_traits<__node_pointer>::element_type __node;
@@ -703,7 +690,7 @@ public:
 #endif
                                        pointer;
 
-    _LIBCPP_INLINE_VISIBILITY __tree_const_iterator() {}
+    __tree_const_iterator() {}
 private:
     typedef typename remove_const<__node>::type  __non_const_node;
     typedef typename pointer_traits<__node_pointer>::template
@@ -716,46 +703,36 @@ private:
     typedef __tree_iterator<value_type, __non_const_node_pointer, difference_type>
                                                  __non_const_iterator;
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __tree_const_iterator(__non_const_iterator __p) _NOEXCEPT
-        : __ptr_(__p.__ptr_) {}
+    __tree_const_iterator(__non_const_iterator __p) : __ptr_(__p.__ptr_) {}
 
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return __ptr_->__value_;}
-    _LIBCPP_INLINE_VISIBILITY pointer operator->() const {return &__ptr_->__value_;}
+    reference operator*() const {return __ptr_->__value_;}
+    pointer operator->() const {return &__ptr_->__value_;}
 
-    _LIBCPP_INLINE_VISIBILITY
     __tree_const_iterator& operator++()
         {__ptr_ = static_cast<__node_pointer>(__tree_next(static_cast<__node_base_pointer>(__ptr_)));
          return *this;}
-    _LIBCPP_INLINE_VISIBILITY
     __tree_const_iterator operator++(int)
         {__tree_const_iterator __t(*this); ++(*this); return __t;}
 
-    _LIBCPP_INLINE_VISIBILITY
     __tree_const_iterator& operator--()
         {__ptr_ = static_cast<__node_pointer>(__tree_prev(static_cast<__node_base_pointer>(__ptr_)));
          return *this;}
-    _LIBCPP_INLINE_VISIBILITY
     __tree_const_iterator operator--(int)
         {__tree_const_iterator __t(*this); --(*this); return __t;}
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
+    friend bool operator==(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
         {return __x.__ptr_ == __y.__ptr_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
+    friend bool operator!=(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
         {return !(__x == __y);}
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __tree_const_iterator(__node_pointer __p) _NOEXCEPT
-        : __ptr_(__p) {}
+    explicit __tree_const_iterator(__node_pointer __p) : __ptr_(__p) {}
     template <class, class, class> friend class __tree;
-    template <class, class, class, class> friend class _LIBCPP_VISIBLE map;
-    template <class, class, class, class> friend class _LIBCPP_VISIBLE multimap;
-    template <class, class, class> friend class _LIBCPP_VISIBLE set;
-    template <class, class, class> friend class _LIBCPP_VISIBLE multiset;
-    template <class> friend class _LIBCPP_VISIBLE __map_const_iterator;
+    template <class, class, class, class> friend class map;
+    template <class, class, class, class> friend class multimap;
+    template <class, class, class> friend class set;
+    template <class, class, class> friend class multiset;
+    template <class> friend class __map_const_iterator;
 };
 
 template <class _Tp, class _Compare, class _Allocator>
@@ -772,7 +749,6 @@ public:
     typedef typename __alloc_traits::difference_type difference_type;
 
     typedef __tree_node<value_type, typename __alloc_traits::void_pointer> __node;
-    typedef __tree_node_base<typename __alloc_traits::void_pointer> __node_base;
     typedef typename __alloc_traits::template
 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
             rebind_alloc<__node>
@@ -783,10 +759,10 @@ public:
     typedef allocator_traits<__node_allocator>       __node_traits;
     typedef typename __node_traits::pointer          __node_pointer;
     typedef typename __node_traits::const_pointer    __node_const_pointer;
-    typedef typename __node_base::pointer            __node_base_pointer;
-    typedef typename __node_base::const_pointer      __node_base_const_pointer;
+    typedef typename __node::base::pointer           __node_base_pointer;
+    typedef typename __node::base::const_pointer     __node_base_const_pointer;
 private:
-    typedef typename __node_base::base __end_node_t;
+    typedef typename __node::base::base __end_node_t;
     typedef typename pointer_traits<__node_pointer>::template
 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
             rebind<__end_node_t>
@@ -807,62 +783,43 @@ private:
     __compressed_pair<size_type, value_compare>        __pair3_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __node_pointer __end_node() _NOEXCEPT
+    __node_pointer __end_node()
     {
         return static_cast<__node_pointer>
                (
                    pointer_traits<__end_node_ptr>::pointer_to(__pair1_.first())
                );
     }
-    _LIBCPP_INLINE_VISIBILITY
-    __node_const_pointer __end_node() const _NOEXCEPT
+    __node_const_pointer __end_node() const
     {
         return static_cast<__node_const_pointer>
                (
                    pointer_traits<__end_node_const_ptr>::pointer_to(__pair1_.first())
                );
     }
-    _LIBCPP_INLINE_VISIBILITY
-          __node_allocator& __node_alloc() _NOEXCEPT {return __pair1_.second();}
+          __node_allocator& __node_alloc()       {return __pair1_.second();}
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    const __node_allocator& __node_alloc() const _NOEXCEPT
-        {return __pair1_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-          __node_pointer& __begin_node() _NOEXCEPT {return __begin_node_;}
-    _LIBCPP_INLINE_VISIBILITY
-    const __node_pointer& __begin_node() const _NOEXCEPT {return __begin_node_;}
+    const __node_allocator& __node_alloc() const {return __pair1_.second();}
+          __node_pointer& __begin_node()         {return __begin_node_;}
+    const __node_pointer& __begin_node()   const {return __begin_node_;}
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type __alloc() const _NOEXCEPT
-        {return allocator_type(__node_alloc());}
+    allocator_type __alloc() const {return allocator_type(__node_alloc());}
 private:
-    _LIBCPP_INLINE_VISIBILITY
-          size_type& size() _NOEXCEPT {return __pair3_.first();}
+          size_type& size()                      {return __pair3_.first();}
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    const size_type& size() const _NOEXCEPT {return __pair3_.first();}
-    _LIBCPP_INLINE_VISIBILITY
-          value_compare& value_comp() _NOEXCEPT {return __pair3_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-    const value_compare& value_comp() const _NOEXCEPT
-        {return __pair3_.second();}
+    const size_type& size()                const {return __pair3_.first();}
+          value_compare& value_comp()            {return __pair3_.second();}
+    const value_compare& value_comp()      const {return __pair3_.second();}
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __node_pointer __root() _NOEXCEPT
+    __node_pointer       __root()
         {return static_cast<__node_pointer>      (__end_node()->__left_);}
-    _LIBCPP_INLINE_VISIBILITY
-    __node_const_pointer __root() const _NOEXCEPT
+    __node_const_pointer __root() const
         {return static_cast<__node_const_pointer>(__end_node()->__left_);}
 
     typedef __tree_iterator<value_type, __node_pointer, difference_type>             iterator;
     typedef __tree_const_iterator<value_type, __node_const_pointer, difference_type> const_iterator;
 
-    explicit __tree(const value_compare& __comp)
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<__node_allocator>::value &&
-            is_nothrow_copy_constructible<value_compare>::value);
+    explicit __tree(const value_compare& __comp);
     explicit __tree(const allocator_type& __a);
     __tree(const value_compare& __comp, const allocator_type& __a);
     __tree(const __tree& __t);
@@ -871,44 +828,26 @@ public:
         void __assign_unique(_InputIterator __first, _InputIterator __last);
     template <class _InputIterator>
         void __assign_multi(_InputIterator __first, _InputIterator __last);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    __tree(__tree&& __t)
-        _NOEXCEPT_(
-            is_nothrow_move_constructible<__node_allocator>::value &&
-            is_nothrow_move_constructible<value_compare>::value);
+#ifdef _LIBCPP_MOVE
+    __tree(__tree&& __t);
     __tree(__tree&& __t, const allocator_type& __a);
-    __tree& operator=(__tree&& __t)
-        _NOEXCEPT_(
-            __node_traits::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<value_compare>::value &&
-            is_nothrow_move_assignable<__node_allocator>::value);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    __tree& operator=(__tree&& __t);
+#endif
 
     ~__tree();
 
-    _LIBCPP_INLINE_VISIBILITY
-          iterator begin()  _NOEXCEPT {return       iterator(__begin_node());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return const_iterator(__begin_node());}
-    _LIBCPP_INLINE_VISIBILITY
-          iterator end() _NOEXCEPT {return       iterator(__end_node());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end() const _NOEXCEPT {return const_iterator(__end_node());}
+          iterator begin()       {return       iterator(__begin_node());}
+    const_iterator begin() const {return const_iterator(__begin_node());}
+          iterator end()         {return       iterator(__end_node());}
+    const_iterator end()   const {return const_iterator(__end_node());}
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT
-        {return __node_traits::max_size(__node_alloc());}
+    size_type max_size() const {return __node_traits::max_size(__node_alloc());}
 
-    void clear() _NOEXCEPT;
+    void clear();
 
-    void swap(__tree& __t)
-        _NOEXCEPT_(
-            __is_nothrow_swappable<value_compare>::value &&
-            (!__node_traits::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<__node_allocator>::value));
+    void swap(__tree& __t);
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#ifdef _LIBCPP_MOVE
     template <class... _Args>
         pair<iterator, bool>
         __emplace_unique(_Args&&... __args);
@@ -922,7 +861,6 @@ public:
     template <class... _Args>
         iterator
         __emplace_hint_multi(const_iterator __p, _Args&&... __args);
-#endif  // _LIBCPP_HAS_NO_VARIADICS
 
     template <class _V>
         pair<iterator, bool> __insert_unique(_V&& __v);
@@ -932,12 +870,13 @@ public:
         iterator __insert_multi(_V&& __v);
     template <class _V>
         iterator __insert_multi(const_iterator __p, _V&& __v);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#else
 
     pair<iterator, bool> __insert_unique(const value_type& __v);
     iterator __insert_unique(const_iterator __p, const value_type& __v);
     iterator __insert_multi(const value_type& __v);
     iterator __insert_multi(const_iterator __p, const value_type& __v);
+#endif
 
     pair<iterator, bool> __node_insert_unique(__node_pointer __nd);
     iterator             __node_insert_unique(const_iterator __p,
@@ -968,7 +907,6 @@ public:
         size_type __count_multi(const _Key& __k) const;
 
     template <class _Key>
-        _LIBCPP_INLINE_VISIBILITY
         iterator lower_bound(const _Key& __v)
             {return __lower_bound(__v, __root(), __end_node());}
     template <class _Key>
@@ -976,7 +914,6 @@ public:
                                __node_pointer __root,
                                __node_pointer __result);
     template <class _Key>
-        _LIBCPP_INLINE_VISIBILITY
         const_iterator lower_bound(const _Key& __v) const
             {return __lower_bound(__v, __root(), __end_node());}
     template <class _Key>
@@ -984,7 +921,6 @@ public:
                                      __node_const_pointer __root,
                                      __node_const_pointer __result) const;
     template <class _Key>
-        _LIBCPP_INLINE_VISIBILITY
         iterator upper_bound(const _Key& __v)
             {return __upper_bound(__v, __root(), __end_node());}
     template <class _Key>
@@ -992,7 +928,6 @@ public:
                                __node_pointer __root,
                                __node_pointer __result);
     template <class _Key>
-        _LIBCPP_INLINE_VISIBILITY
         const_iterator upper_bound(const _Key& __v) const
             {return __upper_bound(__v, __root(), __end_node());}
     template <class _Key>
@@ -1016,80 +951,60 @@ public:
     typedef __tree_node_destructor<__node_allocator> _D;
     typedef unique_ptr<__node, _D> __node_holder;
 
-    __node_holder remove(const_iterator __p) _NOEXCEPT;
+    __node_holder remove(const_iterator __p);
 private:
-    typename __node_base::pointer&
-        __find_leaf_low(typename __node_base::pointer& __parent, const value_type& __v);
-    typename __node_base::pointer&
-        __find_leaf_high(typename __node_base::pointer& __parent, const value_type& __v);
-    typename __node_base::pointer&
+    typename __node::base::pointer&
+        __find_leaf_low(typename __node::base::pointer& __parent, const value_type& __v);
+    typename __node::base::pointer&
+        __find_leaf_high(typename __node::base::pointer& __parent, const value_type& __v);
+    typename __node::base::pointer&
         __find_leaf(const_iterator __hint,
-                    typename __node_base::pointer& __parent, const value_type& __v);
+                    typename __node::base::pointer& __parent, const value_type& __v);
     template <class _Key>
-        typename __node_base::pointer&
-        __find_equal(typename __node_base::pointer& __parent, const _Key& __v);
+        typename __node::base::pointer&
+        __find_equal(typename __node::base::pointer& __parent, const _Key& __v);
     template <class _Key>
-        typename __node_base::pointer&
-        __find_equal(const_iterator __hint, typename __node_base::pointer& __parent,
+        typename __node::base::pointer&
+        __find_equal(const_iterator __hint, typename __node::base::pointer& __parent,
                      const _Key& __v);
 
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+#ifdef _LIBCPP_MOVE
     template <class ..._Args>
         __node_holder __construct_node(_Args&& ...__args);
-#else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+#else
         __node_holder __construct_node(const value_type& __v);
 #endif
 
-    void destroy(__node_pointer __nd) _NOEXCEPT;
+    void destroy(__node_pointer __nd);
 
-    _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const __tree& __t)
         {__copy_assign_alloc(__t, integral_constant<bool,
              __node_traits::propagate_on_container_copy_assignment::value>());}
 
-    _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const __tree& __t, true_type)
         {__node_alloc() = __t.__node_alloc();}
-    _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const __tree& __t, false_type) {}
 
     void __move_assign(__tree& __t, false_type);
-    void __move_assign(__tree& __t, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
-                   is_nothrow_move_assignable<__node_allocator>::value);
+    void __move_assign(__tree& __t, true_type);
 
-    _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(__tree& __t)
-        _NOEXCEPT_(
-            !__node_traits::propagate_on_container_move_assignment::value ||
-            is_nothrow_move_assignable<__node_allocator>::value)
         {__move_assign_alloc(__t, integral_constant<bool,
              __node_traits::propagate_on_container_move_assignment::value>());}
 
-    _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(__tree& __t, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
         {__node_alloc() = _STD::move(__t.__node_alloc());}
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__tree& __t, false_type) _NOEXCEPT {}
+    void __move_assign_alloc(__tree& __t, false_type) {}
 
-    _LIBCPP_INLINE_VISIBILITY
     static void __swap_alloc(__node_allocator& __x, __node_allocator& __y)
-        _NOEXCEPT_(
-            !__node_traits::propagate_on_container_swap::value ||
-            __is_nothrow_swappable<__node_allocator>::value)
         {__swap_alloc(__x, __y, integral_constant<bool,
                       __node_traits::propagate_on_container_swap::value>());}
-    _LIBCPP_INLINE_VISIBILITY
     static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, true_type)
-        _NOEXCEPT_(__is_nothrow_swappable<__node_allocator>::value)
         {
             using _STD::swap;
             swap(__x, __y);
         }
-    _LIBCPP_INLINE_VISIBILITY
     static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, false_type)
-        _NOEXCEPT
         {}
 
     __node_pointer __detach();
@@ -1098,9 +1013,6 @@ private:
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp)
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<__node_allocator>::value &&
-            is_nothrow_copy_constructible<value_compare>::value)
     : __pair3_(0, __comp)
 {
     __begin_node() = __end_node();
@@ -1190,10 +1102,8 @@ __tree<_Tp, _Compare, _Allocator>::__assign_unique(_InputIterator __first, _Inpu
     if (size() != 0)
     {
         __node_pointer __cache = __detach();
-#ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
-#endif  // _LIBCPP_NO_EXCEPTIONS
             for (; __cache != nullptr && __first != __last; ++__first)
             {
                 __cache->__value_ = *__first;
@@ -1201,7 +1111,6 @@ __tree<_Tp, _Compare, _Allocator>::__assign_unique(_InputIterator __first, _Inpu
                 __node_insert_unique(__cache);
                 __cache = __next;
             }
-#ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
@@ -1210,7 +1119,6 @@ __tree<_Tp, _Compare, _Allocator>::__assign_unique(_InputIterator __first, _Inpu
             destroy(__cache);
             throw;
         }
-#endif  // _LIBCPP_NO_EXCEPTIONS
         if (__cache != nullptr)
         {
             while (__cache->__parent_ != nullptr)
@@ -1230,10 +1138,8 @@ __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _Input
     if (size() != 0)
     {
         __node_pointer __cache = __detach();
-#ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
-#endif  // _LIBCPP_NO_EXCEPTIONS
             for (; __cache != nullptr && __first != __last; ++__first)
             {
                 __cache->__value_ = *__first;
@@ -1241,7 +1147,6 @@ __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _Input
                 __node_insert_multi(__cache);
                 __cache = __next;
             }
-#ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
@@ -1250,7 +1155,6 @@ __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _Input
             destroy(__cache);
             throw;
         }
-#endif  // _LIBCPP_NO_EXCEPTIONS
         if (__cache != nullptr)
         {
             while (__cache->__parent_ != nullptr)
@@ -1271,13 +1175,10 @@ __tree<_Tp, _Compare, _Allocator>::__tree(const __tree& __t)
     __begin_node() = __end_node();
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)
-    _NOEXCEPT_(
-        is_nothrow_move_constructible<__node_allocator>::value &&
-        is_nothrow_move_constructible<value_compare>::value)
     : __begin_node_(_STD::move(__t.__begin_node_)),
       __pair1_(_STD::move(__t.__pair1_)),
       __pair3_(_STD::move(__t.__pair3_))
@@ -1322,8 +1223,6 @@ __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __
 template <class _Tp, class _Compare, class _Allocator>
 void
 __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, true_type)
-    _NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
-               is_nothrow_move_assignable<__node_allocator>::value)
 {
     destroy(static_cast<__node_pointer>(__end_node()->__left_));
     __begin_node_ = __t.__begin_node_;
@@ -1354,10 +1253,8 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
         if (size() != 0)
         {
             __node_pointer __cache = __detach();
-#ifndef _LIBCPP_NO_EXCEPTIONS
             try
             {
-#endif  // _LIBCPP_NO_EXCEPTIONS
                 while (__cache != nullptr && __t.size() != 0)
                 {
                     __cache->__value_ = _STD::move(__t.remove(__t.begin())->__value_);
@@ -1365,7 +1262,6 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
                     __node_insert_multi(__cache);
                     __cache = __next;
                 }
-#ifndef _LIBCPP_NO_EXCEPTIONS
             }
             catch (...)
             {
@@ -1374,7 +1270,6 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
                 destroy(__cache);
                 throw;
             }
-#endif  // _LIBCPP_NO_EXCEPTIONS
             if (__cache != nullptr)
             {
                 while (__cache->__parent_ != nullptr)
@@ -1390,18 +1285,13 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>&
 __tree<_Tp, _Compare, _Allocator>::operator=(__tree&& __t)
-    _NOEXCEPT_(
-        __node_traits::propagate_on_container_move_assignment::value &&
-        is_nothrow_move_assignable<value_compare>::value &&
-        is_nothrow_move_assignable<__node_allocator>::value)
-        
 {
     __move_assign(__t, integral_constant<bool,
                   __node_traits::propagate_on_container_move_assignment::value>());
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::~__tree()
@@ -1411,14 +1301,14 @@ __tree<_Tp, _Compare, _Allocator>::~__tree()
 
 template <class _Tp, class _Compare, class _Allocator>
 void
-__tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT
+__tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd)
 {
     if (__nd != nullptr)
     {
         destroy(static_cast<__node_pointer>(__nd->__left_));
         destroy(static_cast<__node_pointer>(__nd->__right_));
         __node_allocator& __na = __node_alloc();
-        __node_traits::destroy(__na, _STD::addressof(__nd->__value_));
+        __node_traits::destroy(__na, addressof(__nd->__value_));
         __node_traits::deallocate(__na, __nd, 1);
     }
 }
@@ -1426,10 +1316,6 @@ __tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT
 template <class _Tp, class _Compare, class _Allocator>
 void
 __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)
-    _NOEXCEPT_(
-        __is_nothrow_swappable<value_compare>::value &&
-        (!__node_traits::propagate_on_container_swap::value ||
-         __is_nothrow_swappable<__node_allocator>::value))
 {
     using _STD::swap;
     swap(__begin_node_, __t.__begin_node_);
@@ -1448,7 +1334,7 @@ __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)
 
 template <class _Tp, class _Compare, class _Allocator>
 void
-__tree<_Tp, _Compare, _Allocator>::clear() _NOEXCEPT
+__tree<_Tp, _Compare, _Allocator>::clear()
 {
     destroy(__root());
     size() = 0;
@@ -1460,8 +1346,8 @@ __tree<_Tp, _Compare, _Allocator>::clear() _NOEXCEPT
 // Set __parent to parent of null leaf
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_leaf_low(typename __node_base::pointer& __parent,
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
+__tree<_Tp, _Compare, _Allocator>::__find_leaf_low(typename __node::base::pointer& __parent,
                                                    const value_type& __v)
 {
     __node_pointer __nd = __root();
@@ -1499,8 +1385,8 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_low(typename __node_base::pointer
 // Set __parent to parent of null leaf
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_leaf_high(typename __node_base::pointer& __parent,
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
+__tree<_Tp, _Compare, _Allocator>::__find_leaf_high(typename __node::base::pointer& __parent,
                                                     const value_type& __v)
 {
     __node_pointer __nd = __root();
@@ -1541,9 +1427,9 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_high(typename __node_base::pointe
 // Set __parent to parent of null leaf
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
 __tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint,
-                                               typename __node_base::pointer& __parent,
+                                               typename __node::base::pointer& __parent,
                                                const value_type& __v)
 {
     if (__hint == end() || !value_comp()(*__hint, __v))  // check before
@@ -1577,8 +1463,8 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint,
 // If __v exists, set parent to node of __v and return reference to node of __v
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_equal(typename __node_base::pointer& __parent,
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
+__tree<_Tp, _Compare, _Allocator>::__find_equal(typename __node::base::pointer& __parent,
                                                 const _Key& __v)
 {
     __node_pointer __nd = __root();
@@ -1626,9 +1512,9 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(typename __node_base::pointer& _
 // If __v exists, set parent to node of __v and return reference to node of __v
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
 __tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
-                                                typename __node_base::pointer& __parent,
+                                                typename __node::base::pointer& __parent,
                                                 const _Key& __v)
 {
     if (__hint == end() || value_comp()(__v, *__hint))  // check before
@@ -1658,7 +1544,7 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
         const_iterator __next = _STD::next(__hint);
         if (__next == end() || value_comp()(__v, *__next))
         {
-            // *__hint < __v < *_STD::next(__hint)
+            // *__hint < __v < *next(__hint)
             if (__hint.__ptr_->__right_ == nullptr)
             {
                 __parent = const_cast<__node_pointer&>(__hint.__ptr_);
@@ -1694,8 +1580,7 @@ __tree<_Tp, _Compare, _Allocator>::__insert_node_at(__node_base_pointer __parent
     ++size();
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#ifdef _LIBCPP_MOVE
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class ..._Args>
@@ -1704,7 +1589,7 @@ __tree<_Tp, _Compare, _Allocator>::__construct_node(_Args&& ...__args)
 {
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, addressof(__h->__value_), _STD::forward<_Args>(__args)...);
     __h.get_deleter().__value_constructed = true;
     return __h;
 }
@@ -1770,18 +1655,23 @@ __tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p,
     return iterator(static_cast<__node_pointer>(__h.release()));
 }
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-
 template <class _Tp, class _Compare, class _Allocator>
 template <class _V>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
 __tree<_Tp, _Compare, _Allocator>::__insert_unique(_V&& __v)
 {
-    __node_holder __h = __construct_node(_STD::forward<_V>(__v));
-    pair<iterator, bool> __r = __node_insert_unique(__h.get());
-    if (__r.second)
-        __h.release();
-    return __r;
+    __node_base_pointer __parent;
+    __node_base_pointer& __child = __find_equal(__parent, __v);
+    __node_pointer __r = static_cast<__node_pointer>(__child);
+    bool __inserted = false;
+    if (__child == nullptr)
+    {
+        __node_holder __h = __construct_node(_STD::forward<_V>(__v));
+        __insert_node_at(__parent, __child, __h.get());
+        __r = __h.release();
+        __inserted = true;
+    }
+    return pair<iterator, bool>(iterator(__r), __inserted);
 }
 
 template <class _Tp, class _Compare, class _Allocator>
@@ -1789,11 +1679,16 @@ template <class _V>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__insert_unique(const_iterator __p, _V&& __v)
 {
-    __node_holder __h = __construct_node(_STD::forward<_V>(__v));
-    iterator __r = __node_insert_unique(__p, __h.get());
-    if (__r.__ptr_ == __h.get())
-        __h.release();
-    return __r;
+    __node_base_pointer __parent;
+    __node_base_pointer& __child = __find_equal(__p, __parent, __v);
+    __node_pointer __r = static_cast<__node_pointer>(__child);
+    if (__child == nullptr)
+    {
+        __node_holder __h = __construct_node(_STD::forward<_V>(__v));
+        __insert_node_at(__parent, __child, __h.get());
+        __r = __h.release();
+    }
+    return iterator(__r);
 }
 
 template <class _Tp, class _Compare, class _Allocator>
@@ -1820,7 +1715,7 @@ __tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, _V&& __v)
     return iterator(__h.release());
 }
 
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#else
 
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_holder
@@ -1828,13 +1723,11 @@ __tree<_Tp, _Compare, _Allocator>::__construct_node(const value_type& __v)
 {
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
+    __node_traits::construct(__na, addressof(__h->__value_), __v);
     __h.get_deleter().__value_constructed = true;
     return _STD::move(__h);
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 template <class _Tp, class _Compare, class _Allocator>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
 __tree<_Tp, _Compare, _Allocator>::__insert_unique(const value_type& __v)
@@ -1891,6 +1784,8 @@ __tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, const valu
     return iterator(__h.release());
 }
 
+#endif
+
 template <class _Tp, class _Compare, class _Allocator>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
 __tree<_Tp, _Compare, _Allocator>::__node_insert_unique(__node_pointer __nd)
@@ -1956,7 +1851,7 @@ __tree<_Tp, _Compare, _Allocator>::erase(const_iterator __p)
         __begin_node() = __r.__ptr_;
     --size();
     __node_allocator& __na = __node_alloc();
-    __node_traits::destroy(__na, const_cast<value_type*>(_STD::addressof(*__p)));
+    __node_traits::destroy(__na, const_cast<value_type*>(addressof(*__p)));
     __tree_remove(__end_node()->__left_,
                   static_cast<__node_base_pointer>(__np));
     __node_traits::deallocate(__na, __np, 1);
@@ -2254,7 +2149,7 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) const
 
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_holder
-__tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p) _NOEXCEPT
+__tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p)
 {
     __node_pointer __np = const_cast<__node_pointer>(__p.__ptr_);
     if (__begin_node() == __np)
@@ -2270,16 +2165,6 @@ __tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p) _NOEXCEPT
     return __node_holder(__np, _D(__node_alloc()));
 }
 
-template <class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(__tree<_Tp, _Compare, _Allocator>& __x,
-     __tree<_Tp, _Compare, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
-}
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP___TREE

include/__tuple

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -21,96 +21,50 @@
 
 #include <__tuple_03>
 
-#else  // _LIBCPP_HAS_NO_VARIADICS
+#else
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> class _LIBCPP_VISIBLE tuple_size;
+template <class _Tp> class tuple_size;
+template <size_t _Ip, class _Tp> class tuple_element;
 
-template <class _Tp>
-class _LIBCPP_VISIBLE tuple_size<const _Tp>
-    : public tuple_size<_Tp> {};
-
-template <class _Tp>
-class _LIBCPP_VISIBLE tuple_size<volatile _Tp>
-    : public tuple_size<_Tp> {};
-
-template <class _Tp>
-class _LIBCPP_VISIBLE tuple_size<const volatile _Tp>
-    : public tuple_size<_Tp> {};
-
-template <size_t _Ip, class _Tp> class _LIBCPP_VISIBLE tuple_element;
-
-template <size_t _Ip, class _Tp>
-class _LIBCPP_VISIBLE tuple_element<_Ip, const _Tp>
-{
-public:
-    typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
-};
-
-template <size_t _Ip, class _Tp>
-class _LIBCPP_VISIBLE tuple_element<_Ip, volatile _Tp>
-{
-public:
-    typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
-};
-
-template <size_t _Ip, class _Tp>
-class _LIBCPP_VISIBLE tuple_element<_Ip, const volatile _Tp>
-{
-public:
-    typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
-};
-
-template <class ..._Tp> class _LIBCPP_VISIBLE tuple;
-template <class _T1, class _T2> class _LIBCPP_VISIBLE pair;
-template <class _Tp, size_t _Size> struct _LIBCPP_VISIBLE array;
+template <class ..._Tp> class tuple;
+template <class _T1, class _T2> class pair;
+template <class _Tp, size_t _Size> struct array;
 
 template <class _Tp> struct __tuple_like : false_type {};
 
-template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {};
-template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {};
-template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp> {};
-
-template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
+template <class... _Tp> struct __tuple_like<tuple<_Tp...>> : true_type {};
+template <class... _Tp> struct __tuple_like<const tuple<_Tp...>> : true_type {};
 template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
+template <class _T1, class _T2> struct __tuple_like<const pair<_T1, _T2> > : true_type {};
 template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
+template <class _Tp, size_t _Size> struct __tuple_like<const array<_Tp, _Size> > : true_type {};
+
 
 template <size_t _Ip, class ..._Tp>
-typename tuple_element<_Ip, tuple<_Tp...> >::type&
-get(tuple<_Tp...>&) _NOEXCEPT;
+typename tuple_element<_Ip, tuple<_Tp...>>::type&
+get(tuple<_Tp...>&);
 
 template <size_t _Ip, class ..._Tp>
-const typename tuple_element<_Ip, tuple<_Tp...> >::type&
-get(const tuple<_Tp...>&) _NOEXCEPT;
-
-template <size_t _Ip, class ..._Tp>
-typename tuple_element<_Ip, tuple<_Tp...> >::type&&
-get(tuple<_Tp...>&&) _NOEXCEPT;
+const typename tuple_element<_Ip, tuple<_Tp...>>::type&
+get(const tuple<_Tp...>&);
 
 template <size_t _Ip, class _T1, class _T2>
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
-get(pair<_T1, _T2>&) _NOEXCEPT;
+get(pair<_T1, _T2>&);
 
 template <size_t _Ip, class _T1, class _T2>
 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
-get(const pair<_T1, _T2>&) _NOEXCEPT;
-
-template <size_t _Ip, class _T1, class _T2>
-typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
-get(pair<_T1, _T2>&&) _NOEXCEPT;
+get(const pair<_T1, _T2>&);
 
 template <size_t _Ip, class _Tp, size_t _Size>
 _Tp&
-get(array<_Tp, _Size>&) _NOEXCEPT;
+get(array<_Tp, _Size>&);
 
 template <size_t _Ip, class _Tp, size_t _Size>
 const _Tp&
-get(const array<_Tp, _Size>&) _NOEXCEPT;
-
-template <size_t _Ip, class _Tp, size_t _Size>
-_Tp&&
-get(array<_Tp, _Size>&&) _NOEXCEPT;
+get(const array<_Tp, _Size>&);
 
 // __make_tuple_indices
 
@@ -143,7 +97,7 @@ struct __make_tuple_indices
 template <class ..._Tp> struct __tuple_types {};
 
 template <size_t _Ip>
-class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<> >
+class tuple_element<_Ip, __tuple_types<>>
 {
 public:
     static_assert(_Ip == 0, "tuple_element index out of range");
@@ -151,34 +105,29 @@ public:
 };
 
 template <class _Hp, class ..._Tp>
-class _LIBCPP_VISIBLE tuple_element<0, __tuple_types<_Hp, _Tp...> >
+class tuple_element<0, __tuple_types<_Hp, _Tp...>>
 {
 public:
     typedef _Hp type;
 };
 
 template <size_t _Ip, class _Hp, class ..._Tp>
-class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<_Hp, _Tp...> >
+class tuple_element<_Ip, __tuple_types<_Hp, _Tp...>>
 {
 public:
-    typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...> >::type type;
+    typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...>>::type type;
 };
 
 template <class ..._Tp>
-class _LIBCPP_VISIBLE tuple_size<__tuple_types<_Tp...> >
+class tuple_size<__tuple_types<_Tp...>>
     : public integral_constant<size_t, sizeof...(_Tp)>
 {
 };
 
-template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {};
+template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...>> : true_type {};
 
 // __make_tuple_types
 
-// __make_tuple_types<_Tuple<_Types...>, _Ep, _Sp>::type is a
-// __tuple_types<_Types...> using only those _Types in the range [_Sp, _Ep).
-// _Sp defaults to 0 and _Ep defaults to tuple_size<_Tuple>.  If _Tuple is a
-// lvalue_reference type, then __tuple_types<_Types&...> is the result.
-
 template <class _TupleTypes, class _Tp, size_t _Sp, size_t _Ep>
 struct __make_tuple_types_imp;
 
@@ -187,7 +136,7 @@ struct __make_tuple_types_imp<__tuple_types<_Types...>, _Tp, _Sp, _Ep>
 {
     typedef typename remove_reference<_Tp>::type _Tpr;
     typedef typename __make_tuple_types_imp<__tuple_types<_Types...,
-                                            typename conditional<is_lvalue_reference<_Tp>::value,
+                                            typename conditional<is_reference<_Tp>::value,
                                                 typename tuple_element<_Sp, _Tpr>::type&,
                                                 typename tuple_element<_Sp, _Tpr>::type>::type>,
                                             _Tp, _Sp+1, _Ep>::type type;
@@ -206,23 +155,45 @@ struct __make_tuple_types
     typedef typename __make_tuple_types_imp<__tuple_types<>, _Tp, _Sp, _Ep>::type type;
 };
 
+// __make_assignable_types
+
+template <class _Tuple, class _Tp, size_t _Sp, size_t _Ep>
+struct __make_assignable_types_imp;
+
+template <class ..._Types, class _Tp, size_t _Sp, size_t _Ep>
+struct __make_assignable_types_imp<__tuple_types<_Types...>, _Tp, _Sp, _Ep>
+{
+    typedef typename __make_assignable_types_imp<__tuple_types<_Types...,
+                                      typename remove_reference<typename tuple_element<_Sp, _Tp>::type>::type>,
+                                      _Tp, _Sp+1, _Ep>::type type;
+};
+
+template <class ..._Types, class _Tp, size_t _Ep>
+struct __make_assignable_types_imp<__tuple_types<_Types...>, _Tp, _Ep, _Ep>
+{
+    typedef __tuple_types<_Types...> type;
+};
+
+template <class _Tp, size_t _Ep = tuple_size<typename remove_reference<_Tp>::type>::value, size_t _Sp = 0>
+struct __make_assignable_types
+{
+    static_assert(_Sp <= _Ep, "__make_assignable_types input error");
+    typedef typename __make_assignable_types_imp<__tuple_types<>, typename remove_reference<_Tp>::type, _Sp, _Ep>::type type;
+};
+
 // __tuple_convertible
 
 template <bool, class _Tp, class _Up>
 struct __tuple_convertible_imp : public false_type {};
 
 template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
-struct __tuple_convertible_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
+struct __tuple_convertible_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...>>
     : public integral_constant<bool,
-#if 1 // waiting on cwg 1170
                                is_convertible<_Tp0, _Up0>::value &&
-#else
-                               is_constructible<_Up0, _Tp0>::value &&
-#endif
-                               __tuple_convertible_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
+                               __tuple_convertible_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...>>::value> {};
 
 template <>
-struct __tuple_convertible_imp<true, __tuple_types<>, __tuple_types<> >
+struct __tuple_convertible_imp<true, __tuple_types<>, __tuple_types<>>
     : public true_type {};
 
 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
@@ -239,19 +210,6 @@ struct __tuple_convertible<_Tp, _Up, true, true>
 
 // __tuple_assignable
 
-template <bool, class _Tp, class _Up>
-struct __tuple_assignable_imp : public false_type {};
-
-template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
-struct __tuple_assignable_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
-    : public integral_constant<bool,
-                               is_assignable<_Up0&, _Tp0>::value &&
-                               __tuple_assignable_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
-
-template <>
-struct __tuple_assignable_imp<true, __tuple_types<>, __tuple_types<> >
-    : public true_type {};
-
 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
                                 bool = __tuple_like<_Up>::value>
 struct __tuple_assignable
@@ -259,9 +217,9 @@ struct __tuple_assignable
 
 template <class _Tp, class _Up>
 struct __tuple_assignable<_Tp, _Up, true, true>
-    : public __tuple_assignable_imp<tuple_size<typename remove_reference<_Tp>::type>::value ==
-                                    tuple_size<_Up>::value,
-             typename __make_tuple_types<_Tp>::type, typename __make_tuple_types<_Up>::type>
+    : public __tuple_convertible_imp<tuple_size<typename remove_reference<_Tp>::type>::value ==
+                                     tuple_size<_Up>::value,
+             typename __make_tuple_types<_Tp>::type, typename __make_assignable_types<_Up>::type>
 {};
 
 _LIBCPP_END_NAMESPACE_STD

include/__tuple_03

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -17,9 +17,9 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> class _LIBCPP_VISIBLE tuple_size;
-template <size_t _Ip, class _Tp> class _LIBCPP_VISIBLE tuple_element;
+template <class _Tp> class tuple_size;
+template <size_t _Ip, class _Tp> class tuple_element;
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif  // _LIBCPP___TUPLE_03
+#endif

include/algorithm

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -256,7 +256,7 @@ template <class RandomAccessIterator, class RandomNumberGenerator>
 
 template<class RandomAccessIterator, class UniformRandomNumberGenerator>
     void shuffle(RandomAccessIterator first, RandomAccessIterator last,
-                 UniformRandomNumberGenerator&& g);
+                 UniformRandomNumberGenerator& g);
 
 template <class InputIterator, class Predicate>
     bool
@@ -469,29 +469,21 @@ template <class RandomAccessIterator, class Compare>
     void
     sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
 
-template <class RandomAccessIterator>
+template <class RandomAccessIterator> 
     bool
-    is_heap(RandomAccessIterator first, RandomAccessiterator last);
+    is_heap(RandomAccessIterator first, RandomAccessiterator last); 
 
-template <class RandomAccessIterator, class Compare>
+template <class RandomAccessIterator, class Compare> 
     bool
-    is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
+    is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 
 
-template <class RandomAccessIterator>
+template <class RandomAccessIterator> 
     RandomAccessIterator
-    is_heap_until(RandomAccessIterator first, RandomAccessiterator last);
+    is_heap_until(RandomAccessIterator first, RandomAccessiterator last); 
 
-template <class RandomAccessIterator, class Compare>
+template <class RandomAccessIterator, class Compare> 
     RandomAccessIterator
-    is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
-
-template <class ForwardIterator>
-    ForwardIterator
-    min_element(ForwardIterator first, ForwardIterator last);
-
-template <class ForwardIterator, class Compare>
-    ForwardIterator
-    min_element(ForwardIterator first, ForwardIterator last, Compare comp);
+    is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 
 
 template <class T>
     const T&
@@ -501,22 +493,6 @@ template <class T, class Compare>
     const T&
     min(const T& a, const T& b, Compare comp);
 
-template<class T>
-    T
-    min(initializer_list<T> t);
-
-template<class T, class Compare>
-    T
-    min(initializer_list<T> t, Compare comp);
-
-template <class ForwardIterator>
-    ForwardIterator
-    max_element(ForwardIterator first, ForwardIterator last);
-
-template <class ForwardIterator, class Compare>
-    ForwardIterator
-    max_element(ForwardIterator first, ForwardIterator last, Compare comp);
-
 template <class T>
     const T&
     max(const T& a, const T& b);
@@ -525,37 +501,21 @@ template <class T, class Compare>
     const T&
     max(const T& a, const T& b, Compare comp);
 
-template<class T>
-    T
-    max(initializer_list<T> t);
+template <class ForwardIterator>
+    ForwardIterator
+    min_element(ForwardIterator first, ForwardIterator last);
 
-template<class T, class Compare>
-    T
-    max(initializer_list<T> t, Compare comp);
+template <class ForwardIterator, class Compare>
+    ForwardIterator
+    min_element(ForwardIterator first, ForwardIterator last, Compare comp);
 
-template<class ForwardIterator>
-    pair<ForwardIterator, ForwardIterator>
-    minmax_element(ForwardIterator first, ForwardIterator last);
+template <class ForwardIterator>
+    ForwardIterator
+    max_element(ForwardIterator first, ForwardIterator last);
 
-template<class ForwardIterator, class Compare>
-    pair<ForwardIterator, ForwardIterator>
-    minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
-
-template<class T>
-    pair<const T&, const T&>
-    minmax(const T& a, const T& b);
-
-template<class T, class Compare>
-    pair<const T&, const T&>
-    minmax(const T& a, const T& b, Compare comp);
-
-template<class T>
-    pair<T, T>
-    minmax(initializer_list<T> t);
-
-template<class T, class Compare>
-    pair<T, T>
-    minmax(initializer_list<T> t, Compare comp);
+template <class ForwardIterator, class Compare>
+    ForwardIterator
+    max_element(ForwardIterator first, ForwardIterator last, Compare comp);
 
 template <class InputIterator1, class InputIterator2>
     bool
@@ -567,7 +527,7 @@ template <class InputIterator1, class InputIterator2, class Compare>
                             InputIterator2 first2, InputIterator2 last2, Compare comp);
 
 template <class BidirectionalIterator>
-    bool
+    bool 
     next_permutation(BidirectionalIterator first, BidirectionalIterator last);
 
 template <class BidirectionalIterator, class Compare>
@@ -1200,7 +1160,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
                 break;
             ++__first1;
         }
-#else  // !_LIBCPP_UNROLL_LOOPS
+#else  // _LIBCPP_UNROLL_LOOPS
         for (_D1 __loop_unroll = (__s - __first1) / 4; __loop_unroll > 0; --__loop_unroll)
         {
             if (__pred(*__first1, *__first2))
@@ -1230,7 +1190,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
             return __last1;
         }
     __phase2:
-#endif  // !_LIBCPP_UNROLL_LOOPS
+#endif  // _LIBCPP_UNROLL_LOOPS
         _RandomAccessIterator1 __m1 = __first1;
         _RandomAccessIterator2 __m2 = __first2;
 #if !_LIBCPP_UNROLL_LOOPS
@@ -1245,7 +1205,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
                  break;
              }
          }
-#else  // !_LIBCPP_UNROLL_LOOPS
+#else  // _LIBCPP_UNROLL_LOOPS
         ++__m2;
         ++__m1;
         for (_D2 __loop_unroll = (__last2 - __m2) / 4; __loop_unroll > 0; --__loop_unroll)
@@ -1281,7 +1241,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
         }
     __continue:
         ++__first1;
-#endif  // !_LIBCPP_UNROLL_LOOPS
+#endif  // _LIBCPP_UNROLL_LOOPS
     }
 }
 
@@ -1438,7 +1398,7 @@ template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_trivially_copy_assignable<_Tp>::value,
+    has_trivial_copy_assign<_Tp>::value,
     _Tp*
 >::type
 __unwrap_iter(move_iterator<_Tp*> __i)
@@ -1450,7 +1410,7 @@ template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_trivially_copy_assignable<_Tp>::value,
+    has_trivial_copy_assign<_Tp>::value,
     _Tp*
 >::type
 __unwrap_iter(__wrap_iter<_Tp*> __i)
@@ -1473,7 +1433,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
+    has_trivial_copy_assign<_Up>::value,
     _Up*
 >::type
 __copy(_Tp* __first, _Tp* __last, _Up* __result)
@@ -1508,7 +1468,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
+    has_trivial_copy_assign<_Up>::value,
     _Up*
 >::type
 __copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
@@ -1559,17 +1519,8 @@ typename enable_if
 >::type
 copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
 {
-    if (__n > 0)
-    {
+    for (; __n > 0; --__n, ++__first, ++__result)
         *__result = *__first;
-        ++__result;
-        for (--__n; __n > 0; --__n)
-        {
-            ++__first;
-            *__result = *__first;
-            ++__result;
-        }
-    }
     return __result;
 }
 
@@ -1582,7 +1533,7 @@ typename enable_if
 >::type
 copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
 {
-    return _STD::copy(__first, __first + __n, __result);
+    return copy(__first, __first + __n, __result);
 }
 
 // move
@@ -1602,7 +1553,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
+    has_trivial_copy_assign<_Up>::value,
     _Up*
 >::type
 __move(_Tp* __first, _Tp* __last, _Up* __result)
@@ -1637,7 +1588,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
+    has_trivial_copy_assign<_Up>::value,
     _Up*
 >::type
 __move_backward(_Tp* __first, _Tp* __last, _Up* __result)
@@ -1659,7 +1610,13 @@ move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
 
 // iter_swap
 
-// moved to <type_traits> for better swap / noexcept support
+template <class _ForwardIterator1, class _ForwardIterator2>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+{
+    swap(*__a, *__b);
+}
 
 // transform
 
@@ -1769,7 +1726,7 @@ fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
 {
    return _STD::__fill_n(__first, __n, __value, integral_constant<bool,
                                               is_pointer<_OutputIterator>::value &&
-                                              is_trivially_copy_assignable<_Tp>::value     &&
+                                              has_trivial_copy_assign<_Tp>::value     &&
                                               sizeof(_Tp) == 1>());
 }
 
@@ -1998,6 +1955,7 @@ __unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __
     return __result;
 }
 
+
 template <class _InputIterator, class _OutputIterator, class _BinaryPredicate>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
@@ -2125,7 +2083,7 @@ __rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomA
 {
     typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
     typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
-
+    
     if (__first == __middle)
         return __last;
     if (__middle == __last)
@@ -2172,7 +2130,7 @@ rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __l
                                    typename iterator_traits<_ForwardIterator>::iterator_category,
                                    random_access_iterator_tag
                                >::value &&
-                               is_trivially_copy_assignable
+                               has_trivial_copy_assign
                                <
                                    typename iterator_traits<_ForwardIterator>::value_type
                                >::value
@@ -2189,6 +2147,42 @@ rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterato
     return _STD::copy(__first, __middle, _STD::copy(__middle, __last, __result));
 }
 
+// min
+
+template <class _Tp, class _Compare>
+inline _LIBCPP_INLINE_VISIBILITY
+const _Tp&
+min(const _Tp& __a, const _Tp& __b, _Compare __comp)
+{
+    return __comp(__b, __a) ? __b : __a;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+const _Tp&
+min(const _Tp& __a, const _Tp& __b)
+{
+    return _STD::min(__a, __b, __less<_Tp>());
+}
+
+// max
+
+template <class _Tp, class _Compare>
+inline _LIBCPP_INLINE_VISIBILITY
+const _Tp&
+max(const _Tp& __a, const _Tp& __b, _Compare __comp)
+{
+    return __comp(__a, __b) ? __b : __a;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+const _Tp&
+max(const _Tp& __a, const _Tp& __b)
+{
+    return _STD::max(__a, __b, __less<_Tp>());
+}
+
 // min_element
 
 template <class _ForwardIterator, class _Compare>
@@ -2211,42 +2205,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 min_element(_ForwardIterator __first, _ForwardIterator __last)
 {
-    return _STD::min_element(__first, __last,
-              __less<typename iterator_traits<_ForwardIterator>::value_type>());
-}
-
-// min
-
-template <class _Tp, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
-const _Tp&
-min(const _Tp& __a, const _Tp& __b, _Compare __comp)
-{
-    return __comp(__b, __a) ? __b : __a;
-}
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-const _Tp&
-min(const _Tp& __a, const _Tp& __b)
-{
-    return _STD::min(__a, __b, __less<_Tp>());
-}
-
-template<class _Tp, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp
-min(initializer_list<_Tp> __t, _Compare __comp)
-{
-    return *_STD::min_element(__t.begin(), __t.end(), __comp);
-}
-
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp
-min(initializer_list<_Tp> __t)
-{
-    return *_STD::min_element(__t.begin(), __t.end());
+    return _STD::min_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
 // max_element
@@ -2271,42 +2230,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 max_element(_ForwardIterator __first, _ForwardIterator __last)
 {
-    return _STD::max_element(__first, __last,
-              __less<typename iterator_traits<_ForwardIterator>::value_type>());
-}
-
-// max
-
-template <class _Tp, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
-const _Tp&
-max(const _Tp& __a, const _Tp& __b, _Compare __comp)
-{
-    return __comp(__a, __b) ? __b : __a;
-}
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-const _Tp&
-max(const _Tp& __a, const _Tp& __b)
-{
-    return _STD::max(__a, __b, __less<_Tp>());
-}
-
-template<class _Tp, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp
-max(initializer_list<_Tp> __t, _Compare __comp)
-{
-    return *_STD::max_element(__t.begin(), __t.end(), __comp);
-}
-
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp
-max(initializer_list<_Tp> __t)
-{
-    return *_STD::max_element(__t.begin(), __t.end());
+    return _STD::max_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
 // minmax_element
@@ -2369,45 +2293,6 @@ minmax_element(_ForwardIterator __first, _ForwardIterator __last)
     return _STD::minmax_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
-// minmax
-
-template<class _Tp, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
-pair<const _Tp&, const _Tp&>
-minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
-{
-    return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) :
-                              pair<const _Tp&, const _Tp&>(__a, __b);
-}
-
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-pair<const _Tp&, const _Tp&>
-minmax(const _Tp& __a, const _Tp& __b)
-{
-    return _STD::minmax(__a, __b, __less<_Tp>());
-}
-
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-pair<_Tp, _Tp>
-minmax(initializer_list<_Tp> __t)
-{
-    pair<const _Tp*, const _Tp*> __p =
-                                   _STD::minmax_element(__t.begin(), __t.end());
-    return pair<_Tp, _Tp>(*__p.first, *__p.second);
-}
-
-template<class _Tp, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
-pair<_Tp, _Tp>
-minmax(initializer_list<_Tp> __t, _Compare __comp)
-{
-    pair<const _Tp*, const _Tp*> __p =
-                           _STD::minmax_element(__t.begin(), __t.end(), __comp);
-    return pair<_Tp, _Tp>(*__p.first, *__p.second);
-}
-
 // random_shuffle
 
 // __independent_bits_engine
@@ -2689,18 +2574,14 @@ random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
         _D __uid;
         __rs_default __g = __rs_get();
         for (--__last, --__d; __first < __last; ++__first, --__d)
-        {
-            difference_type __i = __uid(__g, _P(0, __d));
-            if (__i != difference_type(0))
-                swap(*__first, *(__first + __i));
-        }
+            swap(*__first, *(__first + __uid(__g, _P(0, __d))));
     }
 }
 
 template <class _RandomAccessIterator, class _RandomNumberGenerator>
 void
 random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
                _RandomNumberGenerator&& __rand)
 #else
                _RandomNumberGenerator& __rand)
@@ -2711,20 +2592,13 @@ random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
     if (__d > 1)
     {
         for (--__last; __first < __last; ++__first, --__d)
-        {
-            difference_type __i = __rand(__d);
-            swap(*__first, *(__first + __i));
-        }
+            swap(*__first, *(__first + __rand(__d)));
     }
 }
 
 template<class _RandomAccessIterator, class _UniformRandomNumberGenerator>
     void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-                 _UniformRandomNumberGenerator&& __g)
-#else
                  _UniformRandomNumberGenerator& __g)
-#endif
 {
     typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
     typedef uniform_int_distribution<ptrdiff_t> _D;
@@ -2734,11 +2608,7 @@ template<class _RandomAccessIterator, class _UniformRandomNumberGenerator>
     {
         _D __uid;
         for (--__last, --__d; __first < __last; ++__first, --__d)
-        {
-            difference_type __i = __uid(__g, _P(0, __d));
-            if (__i != difference_type(0))
-                swap(*__first, *(__first + __i));
-        }
+            swap(*__first, *(__first + __uid(__g, _P(0, __d))));
     }
 }
 
@@ -3164,7 +3034,7 @@ is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __co
     return __last;
 }
 
-template<class _ForwardIterator>
+template<class _ForwardIterator> 
 inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
@@ -3182,7 +3052,7 @@ is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
     return _STD::is_sorted_until(__first, __last, __comp) == __last;
 }
 
-template<class _ForwardIterator>
+template<class _ForwardIterator> 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 is_sorted(_ForwardIterator __first, _ForwardIterator __last)
@@ -3437,8 +3307,8 @@ __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __c
     // _Compare is known to be a reference type
     typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
     typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
-    const difference_type __limit = is_trivially_copy_constructible<value_type>::value &&
-                                    is_trivially_copy_assignable<value_type>::value ? 30 : 6;
+    const difference_type __limit = has_trivial_copy_constructor<value_type>::value &&
+                                    has_trivial_copy_assign<value_type>::value ? 30 : 6;
     while (true)
     {
     __restart:
@@ -3633,10 +3503,10 @@ sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __com
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     __sort<_Comp_ref>(__first, __last, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __sort<_Comp_ref>(__first, __last, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _RandomAccessIterator>
@@ -3730,10 +3600,10 @@ lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __valu
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return __lower_bound<_Comp_ref>(__first, __last, __value, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __lower_bound<_Comp_ref>(__first, __last, __value, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _ForwardIterator, class _Tp>
@@ -3778,10 +3648,10 @@ upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __valu
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return __upper_bound<_Comp_ref>(__first, __last, __value, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __upper_bound<_Comp_ref>(__first, __last, __value, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _ForwardIterator, class _Tp>
@@ -3838,10 +3708,10 @@ equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __valu
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return __equal_range<_Comp_ref>(__first, __last, __value, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __equal_range<_Comp_ref>(__first, __last, __value, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _ForwardIterator, class _Tp>
@@ -3873,10 +3743,10 @@ binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __va
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return __binary_search<_Comp_ref>(__first, __last, __value, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __binary_search<_Comp_ref>(__first, __last, __value, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _ForwardIterator, class _Tp>
@@ -3923,10 +3793,10 @@ merge(_InputIterator1 __first1, _InputIterator1 __last1,
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return _STD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return _STD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -4072,7 +3942,7 @@ __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle,
 template <class _Tp>
 struct __inplace_merge_switch
 {
-    static const unsigned value = is_trivially_copy_assignable<_Tp>::value;
+    static const unsigned value = has_trivial_copy_assign<_Tp>::value;
 };
 
 template <class _BidirectionalIterator, class _Compare>
@@ -4098,11 +3968,11 @@ inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _
     __debug_less<_Compare> __c(__comp);
     return _STD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __c, __len1, __len2,
                                             __buf.first, __buf.second);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return _STD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2,
                                             __buf.first, __buf.second);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _BidirectionalIterator>
@@ -4240,7 +4110,7 @@ __stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1
 template <class _Tp>
 struct __stable_sort_switch
 {
-    static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value;
+    static const unsigned value = 128*has_trivial_copy_assign<_Tp>::value;
 };
 
 template <class _Compare, class _RandomAccessIterator>
@@ -4308,10 +4178,10 @@ stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compar
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     __stable_sort<_Comp_ref>(__first, __last, __c, __len, __buf.first, __buf.second);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __stable_sort<_Comp_ref>(__first, __last, __comp, __len, __buf.first, __buf.second);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _RandomAccessIterator>
@@ -4351,7 +4221,7 @@ is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp
     return __last;
 }
 
-template<class _RandomAccessIterator>
+template<class _RandomAccessIterator> 
 inline _LIBCPP_INLINE_VISIBILITY
 _RandomAccessIterator
 is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
@@ -4369,7 +4239,7 @@ is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __
     return _STD::is_heap_until(__first, __last, __comp) == __last;
 }
 
-template<class _RandomAccessIterator>
+template<class _RandomAccessIterator> 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
@@ -4457,10 +4327,10 @@ push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     __push_heap_back<_Comp_ref>(__first, __last, __c, __last - __first);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __push_heap_back<_Comp_ref>(__first, __last, __comp, __last - __first);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _RandomAccessIterator>
@@ -4495,10 +4365,10 @@ pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare _
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     __pop_heap<_Comp_ref>(__first, __last, __c, __last - __first);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __pop_heap<_Comp_ref>(__first, __last, __comp, __last - __first);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _RandomAccessIterator>
@@ -4535,10 +4405,10 @@ make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     __make_heap<_Comp_ref>(__first, __last, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __make_heap<_Comp_ref>(__first, __last, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _RandomAccessIterator>
@@ -4569,10 +4439,10 @@ sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     __sort_heap<_Comp_ref>(__first, __last, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __sort_heap<_Comp_ref>(__first, __last, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _RandomAccessIterator>
@@ -4613,10 +4483,10 @@ partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _Ran
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     __partial_sort<_Comp_ref>(__first, __middle, __last, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __partial_sort<_Comp_ref>(__first, __middle, __last, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _RandomAccessIterator>
@@ -4663,10 +4533,10 @@ partial_sort_copy(_InputIterator __first, _InputIterator __last,
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _InputIterator, class _RandomAccessIterator>
@@ -4875,10 +4745,10 @@ nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomA
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     __nth_element<_Comp_ref>(__first, __nth, __last, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __nth_element<_Comp_ref>(__first, __nth, __last, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _RandomAccessIterator>
@@ -4916,10 +4786,10 @@ includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __fi
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _InputIterator1, class _InputIterator2>
@@ -4969,10 +4839,10 @@ set_union(_InputIterator1 __first1, _InputIterator1 __last1,
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -5021,10 +4891,10 @@ set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -5075,10 +4945,10 @@ set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -5134,10 +5004,10 @@ set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -5178,10 +5048,10 @@ lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _InputIterator1, class _InputIterator2>
@@ -5233,15 +5103,15 @@ next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last,
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return __next_permutation<_Comp_ref>(__first, __last, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __next_permutation<_Comp_ref>(__first, __last, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _BidirectionalIterator>
 inline _LIBCPP_INLINE_VISIBILITY
-bool
+bool 
 next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
 {
     return _STD::next_permutation(__first, __last,
@@ -5286,10 +5156,10 @@ prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last,
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return __prev_permutation<_Comp_ref>(__first, __last, __c);
-#else  // _LIBCPP_DEBUG
+#else
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __prev_permutation<_Comp_ref>(__first, __last, __comp);
-#endif  // _LIBCPP_DEBUG
+#endif
 }
 
 template <class _BidirectionalIterator>

include/array

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -16,85 +16,84 @@
 
 namespace std
 {
-template <class T, size_t N >
+template <class T, size_t N > 
 struct array
-{
-    // types:
-    typedef T & reference;
-    typedef const T & const_reference;
-    typedef implementation defined iterator;
-    typedef implementation defined const_iterator;
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-    typedef T value_type;
+{ 
+    // types: 
+    typedef T & reference; 
+    typedef const T & const_reference; 
+    typedef implementation defined iterator; 
+    typedef implementation defined const_iterator; 
+    typedef size_t size_type; 
+    typedef ptrdiff_t difference_type; 
+    typedef T value_type; 
     typedef T* pointer;
     typedef const T* const_pointer;
-    typedef std::reverse_iterator<iterator> reverse_iterator;
-    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+    typedef std::reverse_iterator<iterator> reverse_iterator; 
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 
 
-    // No explicit construct/copy/destroy for aggregate type
-    void fill(const T& u);
-    void swap(array& a) noexcept(noexcept(swap(declval<T&>(), declval<T&>())));
+    // No explicit construct/copy/destroy for aggregate type 
+    void fill(const T& u); 
+    void swap(array& a);
 
-    // iterators:
-    iterator begin() noexcept;
-    const_iterator begin() const noexcept;
-    iterator end() noexcept;
-    const_iterator end() const noexcept;
+    // iterators: 
+    iterator begin(); 
+    const_iterator begin() const; 
+    iterator end(); 
+    const_iterator end() const; 
 
-    reverse_iterator rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
+    reverse_iterator rbegin(); 
+    const_reverse_iterator rbegin() const; 
+    reverse_iterator rend(); 
+    const_reverse_iterator rend() const; 
 
-    const_iterator cbegin() const noexcept;
-    const_iterator cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
+    const_iterator cbegin() const; 
+    const_iterator cend() const; 
+    const_reverse_iterator crbegin() const;
+    const_reverse_iterator crend() const; 
 
-    // capacity:
-    constexpr size_type size() const noexcept;
-    constexpr size_type max_size() const noexcept;
-    bool empty() const noexcept;
+    // capacity: 
+    constexpr size_type size() const; 
+    constexpr size_type max_size() const; 
+    bool empty() const; 
 
-    // element access:
-    reference operator[](size_type n);
-    const_reference operator[](size_type n) const;
-    const_reference at(size_type n) const;
-    reference at(size_type n);
+    // element access: 
+    reference operator[](size_type n); 
+    const_reference operator[](size_type n) const; 
+    const_reference at(size_type n) const; 
+    reference at(size_type n); 
 
-    reference front();
-    const_reference front() const;
-    reference back();
-    const_reference back() const;
+    reference front(); 
+    const_reference front() const; 
+    reference back(); 
+    const_reference back() const; 
 
-    T* data() noexcept;
-    const T* data() const noexcept;
+    T* data(); 
+    const T* data() const; 
 };
 
-template <class T, size_t N>
-  bool operator==(const array<T,N>& x, const array<T,N>& y);
-template <class T, size_t N>
-  bool operator!=(const array<T,N>& x, const array<T,N>& y);
-template <class T, size_t N>
-  bool operator<(const array<T,N>& x, const array<T,N>& y);
-template <class T, size_t N>
-  bool operator>(const array<T,N>& x, const array<T,N>& y);
-template <class T, size_t N>
-  bool operator<=(const array<T,N>& x, const array<T,N>& y);
-template <class T, size_t N>
-  bool operator>=(const array<T,N>& x, const array<T,N>& y);
+template <class T, size_t N> 
+  bool operator==(const array<T,N>& x, const array<T,N>& y); 
+template <class T, size_t N> 
+  bool operator!=(const array<T,N>& x, const array<T,N>& y); 
+template <class T, size_t N> 
+  bool operator<(const array<T,N>& x, const array<T,N>& y); 
+template <class T, size_t N> 
+  bool operator>(const array<T,N>& x, const array<T,N>& y); 
+template <class T, size_t N> 
+  bool operator<=(const array<T,N>& x, const array<T,N>& y); 
+template <class T, size_t N> 
+  bool operator>=(const array<T,N>& x, const array<T,N>& y); 
 
-template <class T, size_t N >
-  void swap(array<T,N>& x, array<T,N>& y) noexcept(noexcept(x.swap(y)));
+template <class T, size_t N > 
+  void swap(array<T,N>& x, array<T,N>& y); 
 
-template <class T> class tuple_size;
-template <int I, class T> class tuple_element;
+template <class T> class tuple_size; 
+template <int I, class T> class tuple_element; 
 template <class T, size_t N> struct tuple_size<array<T, N>>;
-template <int I, class T, size_t N> struct tuple_element<I, array<T, N>>;
-template <int I, class T, size_t N> T& get(array<T, N>&) noexcept;
-template <int I, class T, size_t N> const T& get(const array<T, N>&) noexcept;
-template <int I, class T, size_t N> T&& get(array<T, N>&&) noexcept;
+template <int I, class T, size_t N> struct tuple_element<I, array<T, N>>; 
+template <int I, class T, size_t N> T& get(array<T, N>&); 
+template <int I, class T, size_t N> const T& get(const array<T, N>&); 
 
 }  // std
 
@@ -115,86 +114,66 @@ template <int I, class T, size_t N> T&& get(array<T, N>&&) noexcept;
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, size_t _Size>
-struct _LIBCPP_VISIBLE array
+template <class _Tp, size_t _Size> 
+struct array
 {
     // types:
     typedef array __self;
-    typedef _Tp                                   value_type;
-    typedef value_type&                           reference;
-    typedef const value_type&                     const_reference;
+    typedef _Tp                                   value_type; 
+    typedef value_type&                           reference; 
+    typedef const value_type&                     const_reference; 
     typedef value_type*                           iterator;
     typedef const value_type*                     const_iterator;
     typedef value_type*                           pointer;
     typedef const value_type*                     const_pointer;
-    typedef size_t                                size_type;
-    typedef ptrdiff_t                             difference_type;
-    typedef std::reverse_iterator<iterator>       reverse_iterator;
-    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+    typedef size_t                                size_type; 
+    typedef ptrdiff_t                             difference_type; 
+    typedef std::reverse_iterator<iterator>       reverse_iterator; 
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 
 
     value_type __elems_[_Size > 0 ? _Size : 1];
 
-    // No explicit construct/copy/destroy for aggregate type
-    _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u)
-        {_STD::fill_n(__elems_, _Size, __u);}
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
-        {_STD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
+    // No explicit construct/copy/destroy for aggregate type 
+    _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u) {_STD::fill_n(__elems_, _Size, __u);}
+    _LIBCPP_INLINE_VISIBILITY void swap(array& __a) {_STD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
 
-    // iterators:
-    _LIBCPP_INLINE_VISIBILITY
-    iterator begin() _NOEXCEPT {return iterator(__elems_);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return const_iterator(__elems_);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator end() _NOEXCEPT {return iterator(__elems_ + _Size);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end() const _NOEXCEPT {return const_iterator(__elems_ + _Size);}
+    // iterators: 
+    _LIBCPP_INLINE_VISIBILITY iterator begin()             {return iterator(__elems_);}
+    _LIBCPP_INLINE_VISIBILITY const_iterator begin() const {return const_iterator(__elems_);}
+    _LIBCPP_INLINE_VISIBILITY iterator end()               {return iterator(__elems_ + _Size);}
+    _LIBCPP_INLINE_VISIBILITY const_iterator end() const   {return const_iterator(__elems_ + _Size);}
 
-    _LIBCPP_INLINE_VISIBILITY
-    reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-    reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());}
+    _LIBCPP_INLINE_VISIBILITY reverse_iterator rbegin()             {return reverse_iterator(end());}
+    _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rbegin() const {return const_reverse_iterator(end());}
+    _LIBCPP_INLINE_VISIBILITY reverse_iterator rend()               {return reverse_iterator(begin());}
+    _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rend() const   {return const_reverse_iterator(begin());}
 
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crend() const _NOEXCEPT {return rend();}
+    _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const          {return begin();}
+    _LIBCPP_INLINE_VISIBILITY const_iterator cend() const            {return end();}
+    _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crbegin() const {return rbegin();}
+    _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crend() const   {return rend();}
 
-    // capacity:
-    _LIBCPP_INLINE_VISIBILITY
-    /*constexpr*/ size_type size() const _NOEXCEPT {return _Size;}
-    _LIBCPP_INLINE_VISIBILITY
-    /*constexpr*/ size_type max_size() const _NOEXCEPT {return _Size;}
-    _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT {return _Size == 0;}
+    // capacity: 
+    _LIBCPP_INLINE_VISIBILITY /*constexpr*/ size_type size() const      {return _Size;}
+    _LIBCPP_INLINE_VISIBILITY /*constexpr*/ size_type max_size() const  {return _Size;}
+    _LIBCPP_INLINE_VISIBILITY bool empty() const                    {return _Size == 0;}
 
-    // element access:
+    // element access: 
     _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n)             {return __elems_[__n];}
     _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const {return __elems_[__n];}
-    reference at(size_type __n);
-    const_reference at(size_type __n) const;
+    reference at(size_type __n); 
+    const_reference at(size_type __n) const; 
 
     _LIBCPP_INLINE_VISIBILITY reference front()             {return __elems_[0];}
     _LIBCPP_INLINE_VISIBILITY const_reference front() const {return __elems_[0];}
     _LIBCPP_INLINE_VISIBILITY reference back()              {return __elems_[_Size > 0 ? _Size-1 : 0];}
     _LIBCPP_INLINE_VISIBILITY const_reference back() const  {return __elems_[_Size > 0 ? _Size-1 : 0];}
 
-    _LIBCPP_INLINE_VISIBILITY
-    value_type* data() _NOEXCEPT {return __elems_;}
-    _LIBCPP_INLINE_VISIBILITY
-    const value_type* data() const _NOEXCEPT {return __elems_;}
+    _LIBCPP_INLINE_VISIBILITY value_type* data()             {return __elems_;}
+    _LIBCPP_INLINE_VISIBILITY const value_type* data() const {return __elems_;} 
 };
 
-template <class _Tp, size_t _Size>
+template <class _Tp, size_t _Size> 
 typename array<_Tp, _Size>::reference
 array<_Tp, _Size>::at(size_type __n)
 {
@@ -207,7 +186,7 @@ array<_Tp, _Size>::at(size_type __n)
     return __elems_[__n];
 }
 
-template <class _Tp, size_t _Size>
+template <class _Tp, size_t _Size> 
 typename array<_Tp, _Size>::const_reference
 array<_Tp, _Size>::at(size_type __n) const
 {
@@ -220,7 +199,7 @@ array<_Tp, _Size>::at(size_type __n) const
     return __elems_[__n];
 }
 
-template <class _Tp, size_t _Size>
+template <class _Tp, size_t _Size> 
 _LIBCPP_INLINE_VISIBILITY inline
 bool
 operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
@@ -228,7 +207,7 @@ operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
     return _STD::equal(__x.__elems_, __x.__elems_ + _Size, __y.__elems_);
 }
 
-template <class _Tp, size_t _Size>
+template <class _Tp, size_t _Size> 
 _LIBCPP_INLINE_VISIBILITY inline
 bool
 operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
@@ -236,7 +215,7 @@ operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
     return !(__x == __y);
 }
 
-template <class _Tp, size_t _Size>
+template <class _Tp, size_t _Size> 
 _LIBCPP_INLINE_VISIBILITY inline
 bool
 operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
@@ -244,7 +223,7 @@ operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
     return _STD::lexicographical_compare(__x.__elems_, __x.__elems_ + _Size, __y.__elems_, __y.__elems_ + _Size);
 }
 
-template <class _Tp, size_t _Size>
+template <class _Tp, size_t _Size> 
 _LIBCPP_INLINE_VISIBILITY inline
 bool
 operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
@@ -252,7 +231,7 @@ operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
     return __y < __x;
 }
 
-template <class _Tp, size_t _Size>
+template <class _Tp, size_t _Size> 
 _LIBCPP_INLINE_VISIBILITY inline
 bool
 operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
@@ -260,7 +239,7 @@ operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
     return !(__y < __x);
 }
 
-template <class _Tp, size_t _Size>
+template <class _Tp, size_t _Size> 
 _LIBCPP_INLINE_VISIBILITY inline
 bool
 operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
@@ -268,36 +247,29 @@ operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
     return !(__x < __y);
 }
 
-template <class _Tp, size_t _Size>
+template <class _Tp, size_t _Size> 
 _LIBCPP_INLINE_VISIBILITY inline
-typename enable_if
-<
-    __is_swappable<_Tp>::value,
-    void
->::type
+void
 swap(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
-                                  _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
 {
     __x.swap(__y);
 }
 
 template <class _Tp, size_t _Size>
-class _LIBCPP_VISIBLE tuple_size<array<_Tp, _Size> >
-    : public integral_constant<size_t, _Size> {};
+  class tuple_size<array<_Tp, _Size> > : public integral_constant<size_t, _Size> {};
 
 template <class _Tp, size_t _Size>
-class _LIBCPP_VISIBLE tuple_size<const array<_Tp, _Size> >
-    : public integral_constant<size_t, _Size> {};
+  class tuple_size<const array<_Tp, _Size> > : public integral_constant<size_t, _Size> {};
 
 template <size_t _Ip, class _Tp, size_t _Size>
-class _LIBCPP_VISIBLE tuple_element<_Ip, array<_Tp, _Size> >
+class tuple_element<_Ip, array<_Tp, _Size> >
 {
 public:
     typedef _Tp type;
 };
 
 template <size_t _Ip, class _Tp, size_t _Size>
-class _LIBCPP_VISIBLE tuple_element<_Ip, const array<_Tp, _Size> >
+class tuple_element<_Ip, const array<_Tp, _Size> >
 {
 public:
     typedef const _Tp type;
@@ -306,7 +278,7 @@ public:
 template <size_t _Ip, class _Tp, size_t _Size>
 _LIBCPP_INLINE_VISIBILITY inline
 _Tp&
-get(array<_Tp, _Size>& __a) _NOEXCEPT
+get(array<_Tp, _Size>& __a)
 {
     return __a[_Ip];
 }
@@ -314,23 +286,11 @@ get(array<_Tp, _Size>& __a) _NOEXCEPT
 template <size_t _Ip, class _Tp, size_t _Size>
 _LIBCPP_INLINE_VISIBILITY inline
 const _Tp&
-get(const array<_Tp, _Size>& __a) _NOEXCEPT
+get(const array<_Tp, _Size>& __a)
 {
     return __a[_Ip];
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-template <size_t _Ip, class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY inline
-_Tp&&
-get(array<_Tp, _Size>&& __a) _NOEXCEPT
-{
-    return _STD::move(__a[_Ip]);
-}
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_ARRAY

include/bitset

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -27,23 +27,20 @@ public:
     class reference
     {
         friend class bitset;
-        reference() noexcept;
+        reference();
     public:
-        ~reference() noexcept;
-        reference& operator=(bool x) noexcept;           // for b[i] = x;
-        reference& operator=(const reference&) noexcept; // for b[i] = b[j];
-        bool operator~() const noexcept;                 // flips the bit
-        operator bool() const noexcept;                  // for x = b[i];
-        reference& flip() noexcept;                      // for b[i].flip();
+        ~reference();
+        reference& operator=(bool x);           // for b[i] = x;
+        reference& operator=(const reference&); // for b[i] = b[j];
+        bool operator~() const;                 // flips the bit
+        operator bool() const;                  // for x = b[i];
+        reference& flip();                      // for b[i].flip();
     };
 
     // 23.3.5.1 constructors:
-    constexpr bitset() noexcept;
-    constexpr bitset(unsigned long long val) noexcept;
-    template <class charT>
-        explicit bitset(const charT* str,
-                        typename basic_string<charT>::size_type n = basic_string<charT>::npos,
-                        charT zero = charT('0'), charT one = charT('1'));
+    constexpr bitset();
+    constexpr bitset(unsigned long long val);
+    explicit bitset( const char* str );
     template<class charT, class traits, class Allocator>
         explicit bitset(const basic_string<charT,traits,Allocator>& str,
                         typename basic_string<charT,traits,Allocator>::size_type pos = 0,
@@ -52,17 +49,17 @@ public:
                         charT zero = charT('0'), charT one = charT('1'));
 
     // 23.3.5.2 bitset operations:
-    bitset& operator&=(const bitset& rhs) noexcept;
-    bitset& operator|=(const bitset& rhs) noexcept;
-    bitset& operator^=(const bitset& rhs) noexcept;
-    bitset& operator<<=(size_t pos) noexcept;
-    bitset& operator>>=(size_t pos) noexcept;
-    bitset& set() noexcept;
+    bitset& operator&=(const bitset& rhs);
+    bitset& operator|=(const bitset& rhs);
+    bitset& operator^=(const bitset& rhs);
+    bitset& operator<<=(size_t pos);
+    bitset& operator>>=(size_t pos);
+    bitset& set();
     bitset& set(size_t pos, bool val = true);
-    bitset& reset() noexcept;
+    bitset& reset();
     bitset& reset(size_t pos);
-    bitset operator~() const noexcept;
-    bitset& flip() noexcept;
+    bitset operator~() const;
+    bitset& flip();
     bitset& flip(size_t pos);
 
     // element access:
@@ -77,27 +74,27 @@ public:
     template <class charT>
         basic_string<charT, char_traits<charT>, allocator<charT> > to_string(charT zero = charT('0'), charT one = charT('1')) const;
     basic_string<char, char_traits<char>, allocator<char> > to_string(char zero = '0', char one = '1') const;
-    size_t count() const noexcept;
-    constexpr size_t size() const noexcept;
-    bool operator==(const bitset& rhs) const noexcept;
-    bool operator!=(const bitset& rhs) const noexcept;
+    size_t count() const;
+    constexpr size_t size() const;
+    bool operator==(const bitset& rhs) const;
+    bool operator!=(const bitset& rhs) const;
     bool test(size_t pos) const;
-    bool all() const noexcept;
-    bool any() const noexcept;
-    bool none() const noexcept;
-    bitset operator<<(size_t pos) const noexcept;
-    bitset operator>>(size_t pos) const noexcept;
+    bool all() const;
+    bool any() const;
+    bool none() const;
+    bitset operator<<(size_t pos) const;
+    bitset operator>>(size_t pos) const;
 };
 
 // 23.3.5.3 bitset operators:
 template <size_t N>
-bitset<N> operator&(const bitset<N>&, const bitset<N>&) noexcept;
+bitset<N> operator&(const bitset<N>&, const bitset<N>&);
 
 template <size_t N>
-bitset<N> operator|(const bitset<N>&, const bitset<N>&) noexcept;
+bitset<N> operator|(const bitset<N>&, const bitset<N>&);
 
 template <size_t N>
-bitset<N> operator^(const bitset<N>&, const bitset<N>&) noexcept;
+bitset<N> operator^(const bitset<N>&, const bitset<N>&);
 
 template <class charT, class traits, size_t N>
 basic_istream<charT, traits>&
@@ -155,34 +152,34 @@ protected:
     typedef __bit_iterator<__bitset, false>            iterator;
     typedef __bit_iterator<__bitset, true>             const_iterator;
 
-    __bitset() _NOEXCEPT;
-    explicit __bitset(unsigned long long __v) _NOEXCEPT;
+    __bitset();
+    explicit __bitset(unsigned long long __v);
 
-    _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos)
         {return reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t __pos) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t __pos) const
         {return const_reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos)
         {return iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const
         {return const_iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
 
-    void operator&=(const __bitset& __v) _NOEXCEPT;
-    void operator|=(const __bitset& __v) _NOEXCEPT;
-    void operator^=(const __bitset& __v) _NOEXCEPT;
+    void operator&=(const __bitset& __v);
+    void operator|=(const __bitset& __v);
+    void operator^=(const __bitset& __v);
 
-    void flip() _NOEXCEPT;
+    void flip();
     _LIBCPP_INLINE_VISIBILITY unsigned long to_ulong() const
         {return to_ulong(integral_constant<bool, _Size < sizeof(unsigned long) * CHAR_BIT>());}
     _LIBCPP_INLINE_VISIBILITY unsigned long long to_ullong() const
         {return to_ullong(integral_constant<bool, _Size < sizeof(unsigned long long) * CHAR_BIT>());}
 
-    bool all() const _NOEXCEPT;
-    bool any() const _NOEXCEPT;
-    size_t __hash_code() const _NOEXCEPT;
+    bool all() const;
+    bool any() const;
+    size_t __hash_code() const;
 private:
-    void __init(unsigned long long __v, false_type) _NOEXCEPT;
-    void __init(unsigned long long __v, true_type) _NOEXCEPT;
+    void __init(unsigned long long __v, false_type);
+    void __init(unsigned long long __v, true_type);
     unsigned long to_ulong(false_type) const;
     unsigned long to_ulong(true_type) const;
     unsigned long long to_ullong(false_type) const;
@@ -193,7 +190,7 @@ private:
 
 template <size_t _N_words, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
-__bitset<_N_words, _Size>::__bitset() _NOEXCEPT
+__bitset<_N_words, _Size>::__bitset()
 {
     _STD::fill_n(__first_, _N_words, __storage_type(0));
 }
@@ -221,7 +218,7 @@ __bitset<_N_words, _Size>::__init(unsigned long long __v, true_type)
 
 template <size_t _N_words, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
-__bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
+__bitset<_N_words, _Size>::__bitset(unsigned long long __v)
 {
     __init(__v, integral_constant<bool, sizeof(unsigned long long) == sizeof(__storage_type)>());
 }
@@ -229,7 +226,7 @@ __bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
 template <size_t _N_words, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<_N_words, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
+__bitset<_N_words, _Size>::operator&=(const __bitset& __v)
 {
     for (size_type __i = 0; __i < _N_words; ++__i)
         __first_[__i] &= __v.__first_[__i];
@@ -238,7 +235,7 @@ __bitset<_N_words, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
 template <size_t _N_words, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<_N_words, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
+__bitset<_N_words, _Size>::operator|=(const __bitset& __v)
 {
     for (size_type __i = 0; __i < _N_words; ++__i)
         __first_[__i] |= __v.__first_[__i];
@@ -247,7 +244,7 @@ __bitset<_N_words, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
 template <size_t _N_words, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<_N_words, _Size>::operator^=(const __bitset& __v) _NOEXCEPT
+__bitset<_N_words, _Size>::operator^=(const __bitset& __v)
 {
     for (size_type __i = 0; __i < _N_words; ++__i)
         __first_[__i] ^= __v.__first_[__i];
@@ -255,7 +252,7 @@ __bitset<_N_words, _Size>::operator^=(const __bitset& __v) _NOEXCEPT
 
 template <size_t _N_words, size_t _Size>
 void
-__bitset<_N_words, _Size>::flip() _NOEXCEPT
+__bitset<_N_words, _Size>::flip()
 {
     // do middle whole words
     size_type __n = _Size;
@@ -338,7 +335,7 @@ __bitset<_N_words, _Size>::to_ullong(true_type, true_type) const
 
 template <size_t _N_words, size_t _Size>
 bool
-__bitset<_N_words, _Size>::all() const _NOEXCEPT
+__bitset<_N_words, _Size>::all() const
 {
     // do middle whole words
     size_type __n = _Size;
@@ -358,7 +355,7 @@ __bitset<_N_words, _Size>::all() const _NOEXCEPT
 
 template <size_t _N_words, size_t _Size>
 bool
-__bitset<_N_words, _Size>::any() const _NOEXCEPT
+__bitset<_N_words, _Size>::any() const
 {
     // do middle whole words
     size_type __n = _Size;
@@ -379,7 +376,7 @@ __bitset<_N_words, _Size>::any() const _NOEXCEPT
 template <size_t _N_words, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 size_t
-__bitset<_N_words, _Size>::__hash_code() const _NOEXCEPT
+__bitset<_N_words, _Size>::__hash_code() const
 {
     size_t __h = 0;
     for (size_type __i = 0; __i < _N_words; ++__i)
@@ -413,43 +410,43 @@ protected:
     typedef __bit_iterator<__bitset, false>            iterator;
     typedef __bit_iterator<__bitset, true>             const_iterator;
 
-    __bitset() _NOEXCEPT;
-    explicit __bitset(unsigned long long __v) _NOEXCEPT;
+    __bitset();
+    explicit __bitset(unsigned long long __v);
 
-    _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos)
         {return reference(&__first_, __storage_type(1) << __pos);}
-    _LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t __pos) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t __pos) const
         {return const_reference(&__first_, __storage_type(1) << __pos);}
-    _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos)
         {return iterator(&__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const
         {return const_iterator(&__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
 
-    void operator&=(const __bitset& __v) _NOEXCEPT;
-    void operator|=(const __bitset& __v) _NOEXCEPT;
-    void operator^=(const __bitset& __v) _NOEXCEPT;
+    void operator&=(const __bitset& __v);
+    void operator|=(const __bitset& __v);
+    void operator^=(const __bitset& __v);
 
-    void flip() _NOEXCEPT;
+    void flip();
 
     unsigned long to_ulong() const;
     unsigned long long to_ullong() const;
 
-    bool all() const _NOEXCEPT;
-    bool any() const _NOEXCEPT;
+    bool all() const;
+    bool any() const;
 
-    size_t __hash_code() const _NOEXCEPT;
+    size_t __hash_code() const;
 };
 
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
-__bitset<1, _Size>::__bitset() _NOEXCEPT
+__bitset<1, _Size>::__bitset()
     : __first_(0)
 {
 }
 
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
-__bitset<1, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
+__bitset<1, _Size>::__bitset(unsigned long long __v)
     : __first_(static_cast<__storage_type>(__v))
 {
 }
@@ -457,7 +454,7 @@ __bitset<1, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<1, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
+__bitset<1, _Size>::operator&=(const __bitset& __v)
 {
     __first_ &= __v.__first_;
 }
@@ -465,7 +462,7 @@ __bitset<1, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<1, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
+__bitset<1, _Size>::operator|=(const __bitset& __v)
 {
     __first_ |= __v.__first_;
 }
@@ -473,7 +470,7 @@ __bitset<1, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<1, _Size>::operator^=(const __bitset& __v) _NOEXCEPT
+__bitset<1, _Size>::operator^=(const __bitset& __v)
 {
     __first_ ^= __v.__first_;
 }
@@ -481,7 +478,7 @@ __bitset<1, _Size>::operator^=(const __bitset& __v) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<1, _Size>::flip() _NOEXCEPT
+__bitset<1, _Size>::flip()
 {
     __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
     __first_ = ~__first_;
@@ -507,7 +504,7 @@ __bitset<1, _Size>::to_ullong() const
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-__bitset<1, _Size>::all() const _NOEXCEPT
+__bitset<1, _Size>::all() const
 {
     __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
     return !(~__first_ & __m);
@@ -516,7 +513,7 @@ __bitset<1, _Size>::all() const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-__bitset<1, _Size>::any() const _NOEXCEPT
+__bitset<1, _Size>::any() const
 {
     __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
     return __first_ & __m;
@@ -525,7 +522,7 @@ __bitset<1, _Size>::any() const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 size_t
-__bitset<1, _Size>::__hash_code() const _NOEXCEPT
+__bitset<1, _Size>::__hash_code() const
 {
     return __first_;
 }
@@ -554,40 +551,40 @@ protected:
     typedef __bit_iterator<__bitset, false>            iterator;
     typedef __bit_iterator<__bitset, true>             const_iterator;
 
-    __bitset() _NOEXCEPT;
-    explicit __bitset(unsigned long long) _NOEXCEPT;
+    __bitset();
+    explicit __bitset(unsigned long long);
 
-    _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t)
         {return reference(0, 1);}
-    _LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t) const
         {return const_reference(0, 1);}
-    _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos)
         {return iterator(0, 0);}
-    _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const
         {return const_iterator(0, 0);}
 
-    _LIBCPP_INLINE_VISIBILITY void operator&=(const __bitset&) _NOEXCEPT {}
-    _LIBCPP_INLINE_VISIBILITY void operator|=(const __bitset&) _NOEXCEPT {}
-    _LIBCPP_INLINE_VISIBILITY void operator^=(const __bitset&) _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY void operator&=(const __bitset&) {}
+    _LIBCPP_INLINE_VISIBILITY void operator|=(const __bitset&) {}
+    _LIBCPP_INLINE_VISIBILITY void operator^=(const __bitset&) {}
 
-    _LIBCPP_INLINE_VISIBILITY void flip() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY void flip() {}
 
     _LIBCPP_INLINE_VISIBILITY unsigned long to_ulong() const {return 0;}
     _LIBCPP_INLINE_VISIBILITY unsigned long long to_ullong() const {return 0;}
 
-    _LIBCPP_INLINE_VISIBILITY bool all() const _NOEXCEPT {return true;}
-    _LIBCPP_INLINE_VISIBILITY bool any() const _NOEXCEPT {return false;}
+    _LIBCPP_INLINE_VISIBILITY bool all() const {return true;}
+    _LIBCPP_INLINE_VISIBILITY bool any() const {return false;}
 
-    _LIBCPP_INLINE_VISIBILITY size_t __hash_code() const _NOEXCEPT {return 0;}
+    _LIBCPP_INLINE_VISIBILITY size_t __hash_code() const {return 0;}
 };
 
 inline _LIBCPP_INLINE_VISIBILITY
-__bitset<0, 0>::__bitset() _NOEXCEPT
+__bitset<0, 0>::__bitset()
 {
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
-__bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT
+__bitset<0, 0>::__bitset(unsigned long long)
 {
 }
 
@@ -595,88 +592,81 @@ template <size_t _Size> class bitset;
 template <size_t _Size> struct hash<bitset<_Size> >;
 
 template <size_t _Size>
-class _LIBCPP_VISIBLE bitset
+class bitset
     : private __bitset<_Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1, _Size>
 {
     static const unsigned __n_words = _Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1;
     typedef __bitset<__n_words, _Size> base;
 
-public:
+public: 
     typedef typename base::reference       reference;
     typedef typename base::const_reference const_reference;
 
-    // 23.3.5.1 constructors:
-    /*constexpr*/ _LIBCPP_INLINE_VISIBILITY bitset() _NOEXCEPT {}
-    /*constexpr*/ _LIBCPP_INLINE_VISIBILITY bitset(unsigned long long __v) _NOEXCEPT : base(__v) {}
-    template<class _CharT>
-        explicit bitset(const _CharT* __str,
-                        typename basic_string<_CharT>::size_type __n = basic_string<_CharT>::npos,
-                        _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));
-    template<class _CharT, class _Traits, class _Allocator>
-        explicit bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
-                        typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos = 0,
-                        typename basic_string<_CharT,_Traits,_Allocator>::size_type __n =
+    // 23.3.5.1 constructors: 
+    /*constexpr*/ _LIBCPP_INLINE_VISIBILITY bitset() {}
+    /*constexpr*/ _LIBCPP_INLINE_VISIBILITY bitset(unsigned long long __v) : base(__v) {}
+    explicit bitset(const char* __str);
+    template<class _CharT, class _Traits, class _Allocator> 
+        explicit bitset(const basic_string<_CharT,_Traits,_Allocator>& __str, 
+                        typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos = 0, 
+                        typename basic_string<_CharT,_Traits,_Allocator>::size_type __n = 
                                 (basic_string<_CharT,_Traits,_Allocator>::npos),
-                        _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));
+                        _CharT __zero = _CharT('0'), _CharT __one = _CharT('1')); 
 
-    // 23.3.5.2 bitset operations:
-    bitset& operator&=(const bitset& __rhs) _NOEXCEPT;
-    bitset& operator|=(const bitset& __rhs) _NOEXCEPT;
-    bitset& operator^=(const bitset& __rhs) _NOEXCEPT;
-    bitset& operator<<=(size_t __pos) _NOEXCEPT;
-    bitset& operator>>=(size_t __pos) _NOEXCEPT;
-    bitset& set() _NOEXCEPT;
-    bitset& set(size_t __pos, bool __val = true);
-    bitset& reset() _NOEXCEPT;
-    bitset& reset(size_t __pos);
-    bitset  operator~() const _NOEXCEPT;
-    bitset& flip() _NOEXCEPT;
-    bitset& flip(size_t __pos);
+    // 23.3.5.2 bitset operations: 
+    bitset& operator&=(const bitset& __rhs);
+    bitset& operator|=(const bitset& __rhs); 
+    bitset& operator^=(const bitset& __rhs); 
+    bitset& operator<<=(size_t __pos); 
+    bitset& operator>>=(size_t __pos); 
+    bitset& set(); 
+    bitset& set(size_t __pos, bool __val = true); 
+    bitset& reset(); 
+    bitset& reset(size_t __pos); 
+    bitset  operator~() const; 
+    bitset& flip(); 
+    bitset& flip(size_t __pos); 
 
-    // element access:
+    // element access: 
     _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_t __p) const {return base::__make_ref(__p);}
     _LIBCPP_INLINE_VISIBILITY       reference operator[](size_t __p)       {return base::__make_ref(__p);}
-    unsigned long to_ulong() const;
-    unsigned long long to_ullong() const;
-    template <class _CharT, class _Traits, class _Allocator>
+    unsigned long to_ulong() const; 
+    unsigned long long to_ullong() const; 
+    template <class _CharT, class _Traits, class _Allocator> 
         basic_string<_CharT, _Traits, _Allocator> to_string(_CharT __zero = _CharT('0'),
-                                                            _CharT __one = _CharT('1')) const;
-    template <class _CharT, class _Traits>
+                                                            _CharT __one = _CharT('1')) const; 
+    template <class _CharT, class _Traits> 
         basic_string<_CharT, _Traits, allocator<_CharT> > to_string(_CharT __zero = _CharT('0'),
-                                                                    _CharT __one = _CharT('1')) const;
-    template <class _CharT>
+                                                                    _CharT __one = _CharT('1')) const; 
+    template <class _CharT> 
         basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> > to_string(_CharT __zero = _CharT('0'),
-                                                                                _CharT __one = _CharT('1')) const;
+                                                                                _CharT __one = _CharT('1')) const; 
     basic_string<char, char_traits<char>, allocator<char> > to_string(char __zero = '0',
-                                                                      char __one = '1') const;
-    size_t count() const _NOEXCEPT;
-    /*constexpr*/ _LIBCPP_INLINE_VISIBILITY size_t size() const _NOEXCEPT {return _Size;}
-    bool operator==(const bitset& __rhs) const _NOEXCEPT;
-    bool operator!=(const bitset& __rhs) const _NOEXCEPT;
-    bool test(size_t __pos) const;
-    bool all() const _NOEXCEPT;
-    bool any() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY bool none() const _NOEXCEPT {return !any();}
-    bitset operator<<(size_t __pos) const _NOEXCEPT;
-    bitset operator>>(size_t __pos) const _NOEXCEPT;
+                                                                      char __one = '1') const; 
+    size_t count() const;
+    /*constexpr*/ _LIBCPP_INLINE_VISIBILITY size_t size() const {return _Size;}
+    bool operator==(const bitset& __rhs) const; 
+    bool operator!=(const bitset& __rhs) const; 
+    bool test(size_t __pos) const; 
+    bool all() const; 
+    bool any() const; 
+    _LIBCPP_INLINE_VISIBILITY bool none() const {return !any();}
+    bitset operator<<(size_t __pos) const; 
+    bitset operator>>(size_t __pos) const; 
 
 private:
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t __hash_code() const _NOEXCEPT {return base::__hash_code();}
+    size_t __hash_code() const {return base::__hash_code();}
 
     friend struct hash<bitset>;
 };
 
 template <size_t _Size>
-template<class _CharT>
-bitset<_Size>::bitset(const _CharT* __str,
-                      typename basic_string<_CharT>::size_type __n,
-                      _CharT __zero, _CharT __one)
+bitset<_Size>::bitset(const char* __str)
 {
-    size_t __rlen = _STD::min(__n, char_traits<_CharT>::length(__str));
+    size_t __rlen = strlen(__str);
     for (size_t __i = 0; __i < __rlen; ++__i)
-        if (__str[__i] != __zero && __str[__i] != __one)
+        if (__str[__i] != '0' && __str[__i] != '1')
 #ifndef _LIBCPP_NO_EXCEPTIONS
             throw invalid_argument("bitset string ctor has invalid argument");
 #else
@@ -686,19 +676,23 @@ bitset<_Size>::bitset(const _CharT* __str,
     size_t __i = 0;
     for (; __i < _M; ++__i)
     {
-        _CharT __c = __str[_M - 1 - __i];
-        if (__c == __zero)
+        switch (__str[_M - 1 - __i])
+        {
+        case '0':
             (*this)[__i] = false;
-        else
+            break;
+        case '1':
             (*this)[__i] = true;
+            break;
+        }
     }
     _STD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
 }
 
 template <size_t _Size>
-template<class _CharT, class _Traits, class _Allocator>
-bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
-       typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos,
+template<class _CharT, class _Traits, class _Allocator> 
+bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str, 
+       typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos, 
        typename basic_string<_CharT,_Traits,_Allocator>::size_type __n,
        _CharT __zero, _CharT __one)
 {
@@ -732,7 +726,7 @@ bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
-bitset<_Size>::operator&=(const bitset& __rhs) _NOEXCEPT
+bitset<_Size>::operator&=(const bitset& __rhs)
 {
     base::operator&=(__rhs);
     return *this;
@@ -741,7 +735,7 @@ bitset<_Size>::operator&=(const bitset& __rhs) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
-bitset<_Size>::operator|=(const bitset& __rhs) _NOEXCEPT
+bitset<_Size>::operator|=(const bitset& __rhs)
 {
     base::operator|=(__rhs);
     return *this;
@@ -750,7 +744,7 @@ bitset<_Size>::operator|=(const bitset& __rhs) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
-bitset<_Size>::operator^=(const bitset& __rhs) _NOEXCEPT
+bitset<_Size>::operator^=(const bitset& __rhs)
 {
     base::operator^=(__rhs);
     return *this;
@@ -758,7 +752,7 @@ bitset<_Size>::operator^=(const bitset& __rhs) _NOEXCEPT
 
 template <size_t _Size>
 bitset<_Size>&
-bitset<_Size>::operator<<=(size_t __pos) _NOEXCEPT
+bitset<_Size>::operator<<=(size_t __pos)
 {
     __pos = _STD::min(__pos, _Size);
     _STD::copy_backward(base::__make_iter(0), base::__make_iter(_Size - __pos), base::__make_iter(_Size));
@@ -768,7 +762,7 @@ bitset<_Size>::operator<<=(size_t __pos) _NOEXCEPT
 
 template <size_t _Size>
 bitset<_Size>&
-bitset<_Size>::operator>>=(size_t __pos) _NOEXCEPT
+bitset<_Size>::operator>>=(size_t __pos)
 {
     __pos = _STD::min(__pos, _Size);
     _STD::copy(base::__make_iter(__pos), base::__make_iter(_Size), base::__make_iter(0));
@@ -779,7 +773,7 @@ bitset<_Size>::operator>>=(size_t __pos) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
-bitset<_Size>::set() _NOEXCEPT
+bitset<_Size>::set()
 {
     _STD::fill_n(base::__make_iter(0), _Size, true);
     return *this;
@@ -802,7 +796,7 @@ bitset<_Size>::set(size_t __pos, bool __val)
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
-bitset<_Size>::reset() _NOEXCEPT
+bitset<_Size>::reset()
 {
     _STD::fill_n(base::__make_iter(0), _Size, false);
     return *this;
@@ -825,7 +819,7 @@ bitset<_Size>::reset(size_t __pos)
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>
-bitset<_Size>::operator~() const _NOEXCEPT
+bitset<_Size>::operator~() const
 {
     bitset __x(*this);
     __x.flip();
@@ -835,7 +829,7 @@ bitset<_Size>::operator~() const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
-bitset<_Size>::flip() _NOEXCEPT
+bitset<_Size>::flip()
 {
     base::flip();
     return *this;
@@ -873,7 +867,7 @@ bitset<_Size>::to_ullong() const
 }
 
 template <size_t _Size>
-template <class _CharT, class _Traits, class _Allocator>
+template <class _CharT, class _Traits, class _Allocator> 
 basic_string<_CharT, _Traits, _Allocator>
 bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
 {
@@ -887,7 +881,7 @@ bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
 }
 
 template <size_t _Size>
-template <class _CharT, class _Traits>
+template <class _CharT, class _Traits> 
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, allocator<_CharT> >
 bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
@@ -896,7 +890,7 @@ bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
 }
 
 template <size_t _Size>
-template <class _CharT>
+template <class _CharT> 
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
 bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
@@ -915,7 +909,7 @@ bitset<_Size>::to_string(char __zero, char __one) const
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 size_t
-bitset<_Size>::count() const _NOEXCEPT
+bitset<_Size>::count() const
 {
     return static_cast<size_t>(_STD::count(base::__make_iter(0), base::__make_iter(_Size), true));
 }
@@ -923,7 +917,7 @@ bitset<_Size>::count() const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-bitset<_Size>::operator==(const bitset& __rhs) const _NOEXCEPT
+bitset<_Size>::operator==(const bitset& __rhs) const
 {
     return _STD::equal(base::__make_iter(0), base::__make_iter(_Size), __rhs.__make_iter(0));
 }
@@ -931,7 +925,7 @@ bitset<_Size>::operator==(const bitset& __rhs) const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-bitset<_Size>::operator!=(const bitset& __rhs) const _NOEXCEPT
+bitset<_Size>::operator!=(const bitset& __rhs) const
 {
     return !(*this == __rhs);
 }
@@ -952,7 +946,7 @@ bitset<_Size>::test(size_t __pos) const
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-bitset<_Size>::all() const _NOEXCEPT
+bitset<_Size>::all() const
 {
     return base::all();
 }
@@ -960,7 +954,7 @@ bitset<_Size>::all() const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-bitset<_Size>::any() const _NOEXCEPT
+bitset<_Size>::any() const
 {
     return base::any();
 }
@@ -968,7 +962,7 @@ bitset<_Size>::any() const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>
-bitset<_Size>::operator<<(size_t __pos) const _NOEXCEPT
+bitset<_Size>::operator<<(size_t __pos) const
 {
     bitset __r = *this;
     __r <<= __pos;
@@ -978,7 +972,7 @@ bitset<_Size>::operator<<(size_t __pos) const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>
-bitset<_Size>::operator>>(size_t __pos) const _NOEXCEPT
+bitset<_Size>::operator>>(size_t __pos) const
 {
     bitset __r = *this;
     __r >>= __pos;
@@ -988,7 +982,7 @@ bitset<_Size>::operator>>(size_t __pos) const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>
-operator&(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
+operator&(const bitset<_Size>& __x, const bitset<_Size>& __y)
 {
     bitset<_Size> __r = __x;
     __r &= __y;
@@ -998,7 +992,7 @@ operator&(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>
-operator|(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
+operator|(const bitset<_Size>& __x, const bitset<_Size>& __y)
 {
     bitset<_Size> __r = __x;
     __r |= __y;
@@ -1008,7 +1002,7 @@ operator|(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>
-operator^(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
+operator^(const bitset<_Size>& __x, const bitset<_Size>& __y)
 {
     bitset<_Size> __r = __x;
     __r ^= __y;
@@ -1016,11 +1010,10 @@ operator^(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
 }
 
 template <size_t _Size>
-struct _LIBCPP_VISIBLE hash<bitset<_Size> >
+struct hash<bitset<_Size> >
     : public unary_function<bitset<_Size>, size_t>
 {
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const bitset<_Size>& __bs) const _NOEXCEPT
+    size_t operator()(const bitset<_Size>& __bs) const
         {return __bs.__hash_code();}
 };
 

include/cassert

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/ccomplex

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/cctype

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/cerrno

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -30,46 +30,28 @@ Macros:
 
 #if !defined(EOWNERDEAD) || !defined(ENOTRECOVERABLE)
 
-#ifdef ELAST
-
 const int __elast1 = ELAST+1;
 const int __elast2 = ELAST+2;
-
-#else
-
-const int __elast1 = 104;
-const int __elast2 = 105;
-
-#endif
+#undef ELAST
 
 #ifdef ENOTRECOVERABLE
 
 #define EOWNERDEAD __elast1
-
-#ifdef ELAST
-#undef ELAST
 #define ELAST EOWNERDEAD
-#endif
 
 #elif defined(EOWNERDEAD)
 
 #define ENOTRECOVERABLE __elast1
-#ifdef ELAST
-#undef ELAST
 #define ELAST ENOTRECOVERABLE
-#endif
 
-#else  // defined(EOWNERDEAD)
+#else
 
 #define EOWNERDEAD __elast1
 #define ENOTRECOVERABLE __elast2
-#ifdef ELAST
-#undef ELAST
 #define ELAST ENOTRECOVERABLE
+
 #endif
 
-#endif  // defined(EOWNERDEAD)
-
-#endif  // !defined(EOWNERDEAD) || !defined(ENOTRECOVERABLE)
+#endif
 
 #endif  // _LIBCPP_CERRNO

include/cfenv

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/cfloat

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/chrono

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -223,26 +223,26 @@ public:
     typedef duration::rep                    rep;
     typedef duration::period                 period;
     typedef chrono::time_point<system_clock> time_point;
-    static const bool is_steady =            false;
+    static const bool is_monotonic =          false;
 
-    static time_point now() noexcept;
-    static time_t     to_time_t  (const time_point& __t) noexcept;
-    static time_point from_time_t(time_t __t) noexcept;
+    static time_point now();
+    static time_t     to_time_t  (const time_point& __t);
+    static time_point from_time_t(time_t __t);
 };
 
-class steady_clock
+class monotonic_clock
 {
 public:
     typedef nanoseconds                                   duration;
     typedef duration::rep                                 rep;
     typedef duration::period                              period;
-    typedef chrono::time_point<steady_clock, duration>    time_point;
-    static const bool is_steady =                         true;
+    typedef chrono::time_point<monotonic_clock, duration> time_point;
+    static const bool is_monotonic =                       true;
 
-    static time_point now() noexcept;
+    static time_point now();
 };
 
-typedef steady_clock high_resolution_clock;
+typedef monotonic_clock high_resolution_clock;
 
 }  // chrono
 
@@ -262,7 +262,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace chrono
 {
 
-template <class _Rep, class _Period = ratio<1> > class _LIBCPP_VISIBLE duration;
+template <class _Rep, class _Period = ratio<1> > class duration;
 
 template <class _Tp>
 struct __is_duration : false_type {};
@@ -282,8 +282,7 @@ struct __is_duration<const volatile duration<_Rep, _Period> > : true_type  {};
 } // chrono
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-struct _LIBCPP_VISIBLE common_type<chrono::duration<_Rep1, _Period1>,
-                                   chrono::duration<_Rep2, _Period2> >
+struct common_type<chrono::duration<_Rep1, _Period1>, chrono::duration<_Rep2, _Period2> >
 {
     typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                              typename __ratio_gcd<_Period1, _Period2>::type> type;
@@ -358,11 +357,10 @@ duration_cast(const duration<_Rep, _Period>& __fd)
     return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
 }
 
-template <class _Rep>
-struct _LIBCPP_VISIBLE treat_as_floating_point : is_floating_point<_Rep> {};
+template <class _Rep> struct treat_as_floating_point : is_floating_point<_Rep> {};
 
 template <class _Rep>
-struct _LIBCPP_VISIBLE duration_values
+struct duration_values
 {
 public:
     _LIBCPP_INLINE_VISIBILITY static _Rep zero() {return _Rep(0);}
@@ -373,7 +371,7 @@ public:
 // duration
 
 template <class _Rep, class _Period>
-class _LIBCPP_VISIBLE duration
+class duration
 {
     static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
     static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
@@ -669,7 +667,7 @@ operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2
 //////////////////////////////////////////////////////////
 
 template <class _Clock, class _Duration = typename _Clock::duration>
-class _LIBCPP_VISIBLE time_point
+class time_point
 {
     static_assert(__is_duration<_Duration>::value,
                   "Second template parameter of time_point must be a std::chrono::duration");
@@ -713,8 +711,7 @@ public:
 } // chrono
 
 template <class _Clock, class _Duration1, class _Duration2>
-struct _LIBCPP_VISIBLE common_type<chrono::time_point<_Clock, _Duration1>,
-                                   chrono::time_point<_Clock, _Duration2> >
+struct common_type<chrono::time_point<_Clock, _Duration1>, chrono::time_point<_Clock, _Duration2> >
 {
     typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;
 };
@@ -836,33 +833,33 @@ operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock,
 /////////////////////// clocks ///////////////////////////
 //////////////////////////////////////////////////////////
 
-class _LIBCPP_VISIBLE system_clock
+class system_clock
 {
 public:
     typedef microseconds                     duration;
     typedef duration::rep                    rep;
     typedef duration::period                 period;
     typedef chrono::time_point<system_clock> time_point;
-    static const bool is_steady =            false;
+    static const bool is_monotonic =          false;
 
-    static time_point now() _NOEXCEPT;
-    static time_t     to_time_t  (const time_point& __t) _NOEXCEPT;
-    static time_point from_time_t(time_t __t) _NOEXCEPT;
+    static time_point now();
+    static time_t     to_time_t  (const time_point& __t);
+    static time_point from_time_t(time_t __t);
 };
 
-class _LIBCPP_VISIBLE steady_clock
+class monotonic_clock
 {
 public:
     typedef nanoseconds                                   duration;
     typedef duration::rep                                 rep;
     typedef duration::period                              period;
-    typedef chrono::time_point<steady_clock, duration>    time_point;
-    static const bool is_steady =                         true;
+    typedef chrono::time_point<monotonic_clock, duration> time_point;
+    static const bool is_monotonic =                       true;
 
-    static time_point now() _NOEXCEPT;
+    static time_point now();
 };
 
-typedef steady_clock high_resolution_clock;
+typedef monotonic_clock high_resolution_clock;
 
 } // chrono
 

include/ciso646

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/climits

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/clocale

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/codecvt

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -177,7 +177,7 @@ protected:
 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
-class _LIBCPP_VISIBLE codecvt_utf8
+class codecvt_utf8
     : public __codecvt_utf8<_Elem>
 {
 public:
@@ -185,7 +185,6 @@ public:
     explicit codecvt_utf8(size_t __refs = 0)
         : __codecvt_utf8<_Elem>(__refs, _Maxcode, _Mode) {}
 
-    _LIBCPP_ALWAYS_INLINE
     ~codecvt_utf8() {}
 };
 
@@ -405,7 +404,7 @@ protected:
 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
-class _LIBCPP_VISIBLE codecvt_utf16
+class codecvt_utf16
     : public __codecvt_utf16<_Elem, _Mode & little_endian>
 {
 public:
@@ -413,7 +412,6 @@ public:
     explicit codecvt_utf16(size_t __refs = 0)
         : __codecvt_utf16<_Elem, _Mode & little_endian>(__refs, _Maxcode, _Mode) {}
 
-    _LIBCPP_ALWAYS_INLINE
     ~codecvt_utf16() {}
 };
 
@@ -528,7 +526,7 @@ protected:
 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
-class _LIBCPP_VISIBLE codecvt_utf8_utf16
+class codecvt_utf8_utf16
     : public __codecvt_utf8_utf16<_Elem>
 {
 public:
@@ -536,7 +534,6 @@ public:
     explicit codecvt_utf8_utf16(size_t __refs = 0)
         : __codecvt_utf8_utf16<_Elem>(__refs, _Maxcode, _Mode) {}
 
-    _LIBCPP_ALWAYS_INLINE
     ~codecvt_utf8_utf16() {}
 };
 

include/complex

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -49,89 +49,89 @@ public:
 
 template<>
 class complex<float>
-{
-public:
-    typedef float value_type;
+{ 
+public: 
+    typedef float value_type; 
 
-    constexpr complex(float re = 0.0f, float im = 0.0f);
-    explicit constexpr complex(const complex<double>&);
-    explicit constexpr complex(const complex<long double>&);
+    constexpr complex(float re = 0.0f, float im = 0.0f); 
+    explicit constexpr complex(const complex<double>&); 
+    explicit constexpr complex(const complex<long double>&); 
 
-    constexpr float real() const;
+    constexpr float real() const; 
     void real(float);
-    constexpr float imag() const;
+    constexpr float imag() const; 
     void imag(float);
 
-    complex<float>& operator= (float);
-    complex<float>& operator+=(float);
-    complex<float>& operator-=(float);
-    complex<float>& operator*=(float);
-    complex<float>& operator/=(float);
+    complex<float>& operator= (float); 
+    complex<float>& operator+=(float); 
+    complex<float>& operator-=(float); 
+    complex<float>& operator*=(float); 
+    complex<float>& operator/=(float); 
 
-    complex<float>& operator=(const complex<float>&);
-    template<class X> complex<float>& operator= (const complex<X>&);
-    template<class X> complex<float>& operator+=(const complex<X>&);
-    template<class X> complex<float>& operator-=(const complex<X>&);
-    template<class X> complex<float>& operator*=(const complex<X>&);
-    template<class X> complex<float>& operator/=(const complex<X>&);
+    complex<float>& operator=(const complex<float>&); 
+    template<class X> complex<float>& operator= (const complex<X>&); 
+    template<class X> complex<float>& operator+=(const complex<X>&); 
+    template<class X> complex<float>& operator-=(const complex<X>&); 
+    template<class X> complex<float>& operator*=(const complex<X>&); 
+    template<class X> complex<float>& operator/=(const complex<X>&); 
 };
 
 template<>
 class complex<double>
-{
-public:
-    typedef double value_type;
+{ 
+public: 
+    typedef double value_type; 
 
-    constexpr complex(double re = 0.0, double im = 0.0);
-    constexpr complex(const complex<float>&);
-    explicit constexpr complex(const complex<long double>&);
+    constexpr complex(double re = 0.0, double im = 0.0); 
+    constexpr complex(const complex<float>&); 
+    explicit constexpr complex(const complex<long double>&); 
 
-    constexpr double real() const;
+    constexpr double real() const; 
     void real(double);
-    constexpr double imag() const;
+    constexpr double imag() const; 
     void imag(double);
 
-    complex<double>& operator= (double);
-    complex<double>& operator+=(double);
-    complex<double>& operator-=(double);
-    complex<double>& operator*=(double);
-    complex<double>& operator/=(double);
-    complex<double>& operator=(const complex<double>&);
+    complex<double>& operator= (double); 
+    complex<double>& operator+=(double); 
+    complex<double>& operator-=(double); 
+    complex<double>& operator*=(double); 
+    complex<double>& operator/=(double); 
+    complex<double>& operator=(const complex<double>&); 
 
-    template<class X> complex<double>& operator= (const complex<X>&);
-    template<class X> complex<double>& operator+=(const complex<X>&);
-    template<class X> complex<double>& operator-=(const complex<X>&);
-    template<class X> complex<double>& operator*=(const complex<X>&);
-    template<class X> complex<double>& operator/=(const complex<X>&);
-};
+    template<class X> complex<double>& operator= (const complex<X>&); 
+    template<class X> complex<double>& operator+=(const complex<X>&); 
+    template<class X> complex<double>& operator-=(const complex<X>&); 
+    template<class X> complex<double>& operator*=(const complex<X>&); 
+    template<class X> complex<double>& operator/=(const complex<X>&); 
+}; 
 
 template<>
 class complex<long double>
-{
-public:
-    typedef long double value_type;
+{ 
+public: 
+    typedef long double value_type; 
 
-    constexpr complex(long double re = 0.0L, long double im = 0.0L);
-    constexpr complex(const complex<float>&);
-    constexpr complex(const complex<double>&);
+    constexpr complex(long double re = 0.0L, long double im = 0.0L); 
+    constexpr complex(const complex<float>&); 
+    constexpr complex(const complex<double>&); 
 
-    constexpr long double real() const;
+    constexpr long double real() const; 
     void real(long double);
-    constexpr long double imag() const;
+    constexpr long double imag() const; 
     void imag(long double);
 
-    complex<long double>& operator=(const complex<long double>&);
-    complex<long double>& operator= (long double);
-    complex<long double>& operator+=(long double);
-    complex<long double>& operator-=(long double);
-    complex<long double>& operator*=(long double);
-    complex<long double>& operator/=(long double);
+    complex<long double>& operator=(const complex<long double>&); 
+    complex<long double>& operator= (long double); 
+    complex<long double>& operator+=(long double); 
+    complex<long double>& operator-=(long double); 
+    complex<long double>& operator*=(long double); 
+    complex<long double>& operator/=(long double); 
 
-    template<class X> complex<long double>& operator= (const complex<X>&);
-    template<class X> complex<long double>& operator+=(const complex<X>&);
-    template<class X> complex<long double>& operator-=(const complex<X>&);
-    template<class X> complex<long double>& operator*=(const complex<X>&);
-    template<class X> complex<long double>& operator/=(const complex<X>&);
+    template<class X> complex<long double>& operator= (const complex<X>&); 
+    template<class X> complex<long double>& operator+=(const complex<X>&); 
+    template<class X> complex<long double>& operator-=(const complex<X>&); 
+    template<class X> complex<long double>& operator*=(const complex<X>&); 
+    template<class X> complex<long double>& operator/=(const complex<X>&); 
 };
 
 // 26.3.6 operators:
@@ -191,17 +191,17 @@ template<class T>              T norm(const complex<T>&);
 template<Integral T>      double norm(T);
                           float  norm(float);
 
-template<class T>      complex<T>           conj(const complex<T>&);
-                       complex<long double> conj(long double);
-                       complex<double>      conj(double);
-template<Integral T>   complex<double>      conj(T);
-                       complex<float>       conj(float);
+template<class T>      complex<T>  conj(const complex<T>&);
+                       long double conj(long double);
+                       double      conj(double);
+template<Integral T>   double      conj(T);
+                       float       conj(float);
 
-template<class T>    complex<T>           proj(const complex<T>&);
-                     complex<long double> proj(long double);
-                     complex<double>      proj(double);
-template<Integral T> complex<double>      proj(T);
-                     complex<float>       proj(float);
+template<class T>    complex<T>  proj(const complex<T>&);
+                     long double proj(long double);
+                     double      proj(double);
+template<Integral T> double      proj(T);
+                     float       proj(float);
 
 template<class T> complex<T> polar(const T&, const T& = 0);
 
@@ -253,13 +253,13 @@ template<class T, class charT, class traits>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Tp> class _LIBCPP_VISIBLE complex;
+template<class _Tp> class complex;
 
 template<class _Tp> complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
 template<class _Tp> complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
 
 template<class _Tp>
-class _LIBCPP_VISIBLE complex
+class complex
 {
 public:
     typedef _Tp value_type;
@@ -316,16 +316,16 @@ public:
         }
 };
 
-template<> class _LIBCPP_VISIBLE complex<double>;
-template<> class _LIBCPP_VISIBLE complex<long double>;
+template<> class complex<double>;
+template<> class complex<long double>;
 
 template<>
-class _LIBCPP_VISIBLE complex<float>
-{
+class complex<float>
+{ 
     float __re_;
     float __im_;
-public:
-    typedef float value_type;
+public: 
+    typedef float value_type; 
 
     /*constexpr*/ _LIBCPP_INLINE_VISIBILITY complex(float __re = 0.0f, float __im = 0.0f)
         : __re_(__re), __im_(__im) {}
@@ -375,12 +375,12 @@ public:
 };
 
 template<>
-class _LIBCPP_VISIBLE complex<double>
-{
+class complex<double>
+{ 
     double __re_;
     double __im_;
-public:
-    typedef double value_type;
+public: 
+    typedef double value_type; 
 
     /*constexpr*/ _LIBCPP_INLINE_VISIBILITY complex(double __re = 0.0, double __im = 0.0)
         : __re_(__re), __im_(__im) {}
@@ -427,15 +427,15 @@ public:
             *this = *this / __c;
             return *this;
         }
-};
+}; 
 
 template<>
-class _LIBCPP_VISIBLE complex<long double>
-{
+class complex<long double>
+{ 
     long double __re_;
     long double __im_;
-public:
-    typedef long double value_type;
+public: 
+    typedef long double value_type; 
 
     /*constexpr*/ _LIBCPP_INLINE_VISIBILITY complex(long double __re = 0.0L, long double __im = 0.0L)
         : __re_(__re), __im_(__im) {}
@@ -781,6 +781,20 @@ operator!=(const _Tp& __x, const complex<_Tp>& __y)
     return !(__x == __y);
 }
 
+/*
+    Move to <istream>
+
+template<class T, class charT, class traits>
+basic_istream<charT, traits>&
+operator>>(basic_istream<charT, traits>&, complex<T>&);
+
+    Move to <ostream>
+
+template<class T, class charT, class traits>
+basic_ostream<charT, traits>&
+operator<<(basic_ostream<charT, traits>&, const complex<T>&);
+*/
+
 // 26.3.7 values:
 
 // real
@@ -980,17 +994,17 @@ conj(const complex<_Tp>& __c)
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
-complex<long double>
+long double
 conj(long double __re)
 {
-    return complex<long double>(__re);
+    return __re;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
-complex<double>
+double
 conj(double __re)
 {
-    return complex<double>(__re);
+    return __re;
 }
 
 template<class _Tp>
@@ -998,18 +1012,18 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value,
-    complex<double>
+    double
 >::type
 conj(_Tp __re)
 {
-    return complex<double>(__re);
+    return __re;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
-complex<float>
+float
 conj(float __re)
 {
-    return complex<float>(__re);
+    return __re;
 }
 
 // proj
@@ -1026,21 +1040,21 @@ proj(const complex<_Tp>& __c)
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
-complex<long double>
+long double
 proj(long double __re)
 {
     if (isinf(__re))
         __re = abs(__re);
-    return complex<long double>(__re);
+    return __re;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
-complex<double>
+double
 proj(double __re)
 {
     if (isinf(__re))
         __re = abs(__re);
-    return complex<double>(__re);
+    return __re;
 }
 
 template<class _Tp>
@@ -1048,20 +1062,20 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     is_integral<_Tp>::value,
-    complex<double>
+    double
 >::type
 proj(_Tp __re)
 {
-    return complex<double>(__re);
+    return __re;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
-complex<float>
+float
 proj(float __re)
 {
     if (isinf(__re))
         __re = abs(__re);
-    return complex<float>(__re);
+    return __re;
 }
 
 // polar

include/complex.h

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -18,16 +18,8 @@
 
 */
 
-#ifdef __cplusplus
-
 #include <ccomplex>
 
-#else  // __cplusplus
-
-#include_next <complex.h>
-
-#endif  // __cplusplus
-
 #pragma GCC system_header
 
 #endif  // _LIBCPP_COMPLEX_H

include/condition_variable

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -61,8 +61,6 @@ public:
     native_handle_type native_handle();
 };
 
-void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
-
 class condition_variable_any
 {
 public:
@@ -115,7 +113,7 @@ public:
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_VISIBLE condition_variable_any
+class condition_variable_any
 {
     condition_variable __cv_;
     shared_ptr<mutex>  __mut_;
@@ -153,11 +151,11 @@ public:
                  _Predicate __pred);
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 condition_variable_any::condition_variable_any()
     : __mut_(make_shared<mutex>()) {}
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 condition_variable_any::notify_one()
 {
@@ -165,7 +163,7 @@ condition_variable_any::notify_one()
     __cv_.notify_one();
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 condition_variable_any::notify_all()
 {
@@ -192,7 +190,7 @@ condition_variable_any::wait(_Lock& __lock)
 }  // __mut_.unlock(), __lock.lock()
 
 template <class _Lock, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 condition_variable_any::wait(_Lock& __lock, _Predicate __pred)
 {
@@ -214,7 +212,7 @@ condition_variable_any::wait_until(_Lock& __lock,
 }  // __mut_.unlock(), __lock.lock()
 
 template <class _Lock, class _Clock, class _Duration, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 condition_variable_any::wait_until(_Lock& __lock,
                                    const chrono::time_point<_Clock, _Duration>& __t,
@@ -227,28 +225,25 @@ condition_variable_any::wait_until(_Lock& __lock,
 }
 
 template <class _Lock, class _Rep, class _Period>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 cv_status
 condition_variable_any::wait_for(_Lock& __lock,
                                  const chrono::duration<_Rep, _Period>& __d)
 {
-    return wait_until(__lock, chrono::steady_clock::now() + __d);
+    return wait_until(__lock, chrono::monotonic_clock::now() + __d);
 }
 
 template <class _Lock, class _Rep, class _Period, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 condition_variable_any::wait_for(_Lock& __lock,
                                  const chrono::duration<_Rep, _Period>& __d,
                                  _Predicate __pred)
 {
-    return wait_until(__lock, chrono::steady_clock::now() + __d,
+    return wait_until(__lock, chrono::monotonic_clock::now() + __d,
                       _STD::move(__pred));
 }
 
-_LIBCPP_VISIBLE
-void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CONDITION_VARIABLE

include/csetjmp

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/csignal

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -25,7 +25,7 @@ Macros:
     SIGINT
     SIGSEGV
     SIGTERM
-
+ 
 namespace std
 {
 

include/cstdarg

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -20,7 +20,7 @@ Macros:
     void va_copy(va_list dest, va_list src);  // C99
     void va_end(va_list ap);
     void va_start(va_list ap, parmN);
-
+ 
 namespace std
 {
 

include/cstdbool

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/cstddef

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -18,7 +18,7 @@ Macros:
 
     offsetof(type,member-designator)
     NULL
-
+ 
 namespace std
 {
 
@@ -39,7 +39,7 @@ Types:
 #define __need_NULL
 #define __need_ptrdiff_t
 #define __need_size_t
-#endif  // __GLIBC__
+#endif
 
 #include <stddef.h>
 
@@ -54,7 +54,7 @@ typedef long double max_align_t;
 
 #ifdef _LIBCPP_HAS_NO_NULLPTR
 
-struct _LIBCPP_VISIBLE nullptr_t
+struct nullptr_t
 {
     void* _;
 
@@ -65,11 +65,11 @@ struct _LIBCPP_VISIBLE nullptr_t
     _LIBCPP_ALWAYS_INLINE operator int __nat::*() const {return 0;}
 
     template <class _Tp>
-        _LIBCPP_ALWAYS_INLINE
+        _LIBCPP_ALWAYS_INLINE 
         operator _Tp* () const {return 0;}
 
     template <class _Tp, class _Up>
-        _LIBCPP_ALWAYS_INLINE
+        _LIBCPP_ALWAYS_INLINE 
         operator _Tp _Up::* () const {return 0;}
 
     friend _LIBCPP_ALWAYS_INLINE bool operator==(nullptr_t, nullptr_t) {return true;}
@@ -84,17 +84,12 @@ inline _LIBCPP_ALWAYS_INLINE nullptr_t __get_nullptr_t() {return nullptr_t(0);}
 
 #define nullptr _STD::__get_nullptr_t()
 
-#endif  // _LIBCPP_HAS_NO_NULLPTR
+#else
+
+typedef decltype(nullptr) nullptr_t;
+
+#endif
 
 _LIBCPP_END_NAMESPACE_STD
 
-#ifndef _LIBCPP_HAS_NO_NULLPTR
-
-namespace std
-{
-    typedef decltype(nullptr) nullptr_t;
-}
-
-#endif  // _LIBCPP_HAS_NO_NULLPTR
-
 #endif  // _LIBCPP_CSTDDEF

include/cstdint

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/cstdio

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/cstdlib

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -21,7 +21,7 @@ Macros:
     MB_CUR_MAX
     NULL
     RAND_MAX
-
+ 
 namespace std
 {
 
@@ -66,7 +66,7 @@ long       labs(     long j);
 long long llabs(long long j);                                             // C99
 div_t     div(      int numer,       int denom);
 ldiv_t    div(     long numer,      long denom);
-lldiv_t   div(long long numer, long long denom);                          // C++0X
+lldiv_t   div(long long numer, long long denom);                          // C++0X              
 ldiv_t   ldiv(     long numer,      long denom);
 lldiv_t lldiv(long long numer, long long denom);                          // C99
 int mblen(const char* s, size_t n);

include/cstring

@@ -17,7 +17,7 @@
 Macros:
 
     NULL
-
+ 
 namespace std
 {
 
@@ -77,27 +77,24 @@ using ::strncmp;
 using ::strcoll;
 using ::strxfrm;
 
-using ::memchr;
+inline _LIBCPP_INLINE_VISIBILITY const void* memchr(const void* __s, int __c, size_t __n) {return ::memchr(__s, __c, __n);}
+inline _LIBCPP_INLINE_VISIBILITY       void* memchr(      void* __s, int __c, size_t __n) {return ::memchr(__s, __c, __n);}
 
-using ::strchr;
+inline _LIBCPP_INLINE_VISIBILITY const char* strchr(const char* __s, int __c) {return ::strchr(__s, __c);}
+inline _LIBCPP_INLINE_VISIBILITY       char* strchr(      char* __s, int __c) {return ::strchr(__s, __c);}
 
 using ::strcspn;
 
-using ::strpbrk;
+inline _LIBCPP_INLINE_VISIBILITY const char* strpbrk(const char* __s1, const char* __s2) {return ::strpbrk(__s1, __s2);}
+inline _LIBCPP_INLINE_VISIBILITY       char* strpbrk(      char* __s1, const char* __s2) {return ::strpbrk(__s1, __s2);}
 
-using ::strrchr;
+inline _LIBCPP_INLINE_VISIBILITY const char* strrchr(const char* __s, int __c) {return ::strrchr(__s, __c);}
+inline _LIBCPP_INLINE_VISIBILITY       char* strrchr(      char* __s, int __c) {return ::strrchr(__s, __c);}
 
 using ::strspn;
 
-using ::strstr;
-
-#ifndef __GLIBC__ // GNU libc and its derivates already have the correct prototype in <string.h> #ifdef __cplusplus
-inline _LIBCPP_INLINE_VISIBILITY       char* strchr(      char* __s, int __c) {return ::strchr(__s, __c);}
-inline _LIBCPP_INLINE_VISIBILITY       char* strpbrk(      char* __s1, const char* __s2) {return ::strpbrk(__s1, __s2);}
-inline _LIBCPP_INLINE_VISIBILITY       char* strrchr(      char* __s, int __c) {return ::strrchr(__s, __c);}
-inline _LIBCPP_INLINE_VISIBILITY       void* memchr(      void* __s, int __c, size_t __n) {return ::memchr(__s, __c, __n);}
+inline _LIBCPP_INLINE_VISIBILITY const char* strstr(const char* __s1, const char* __s2) {return ::strstr(__s1, __s2);}
 inline _LIBCPP_INLINE_VISIBILITY       char* strstr(      char* __s1, const char* __s2) {return ::strstr(__s1, __s2);}
-#endif
 
 using ::strtok;
 using ::memset;

include/ctgmath

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/ctime

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -18,7 +18,7 @@ Macros:
 
     NULL
     CLOCKS_PER_SEC
-
+ 
 namespace std
 {
 

include/cwchar

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -20,7 +20,7 @@ Macros:
     WCHAR_MAX
     WCHAR_MIN
     WEOF
-
+ 
 namespace std
 {
 
@@ -49,7 +49,7 @@ wint_t fputwc(wchar_t c, FILE* stream);
 int fputws(const wchar_t* restrict s, FILE* restrict stream);
 int fwide(FILE* stream, int mode);
 wint_t getwc(FILE* stream);
-wint_t getwchar();
+wint_t getwchar(); 
 wint_t putwc(wchar_t c, FILE* stream);
 wint_t putwchar(wchar_t c);
 wint_t ungetwc(wint_t c, FILE* stream);
@@ -92,10 +92,10 @@ wint_t btowc(int c);
 int wctob(wint_t c);
 int mbsinit(const mbstate_t* ps);
 size_t mbrlen(const char* restrict s, size_t n, mbstate_t* restrict ps);
-size_t mbrtowc(wchar_t* restrict pwc, const char* restrict s, size_t n, mbstate_t* restrict ps);
+size_t mbrtowc(wchar_t* restrict pwc, const char* restrict s, size_t n, mbstate_t* restrict ps); 
 size_t wcrtomb(char* restrict s, wchar_t wc, mbstate_t* restrict ps);
 size_t mbsrtowcs(wchar_t* restrict dst, const char** restrict src, size_t len,
-                 mbstate_t* restrict ps);
+                 mbstate_t* restrict ps); 
 size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
                  mbstate_t* restrict ps);
 

include/cwctype

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -17,7 +17,7 @@
 Macros:
 
     WEOF
-
+ 
 namespace std
 {
 
@@ -66,7 +66,7 @@ using ::wctype_t;
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswalnum(wint_t __wc) {return iswalnum(__wc);}
 #undef iswalnum
 inline _LIBCPP_INLINE_VISIBILITY int iswalnum(wint_t __wc) {return __libcpp_iswalnum(__wc);}
-#else  // iswalnum
+#else
 using ::iswalnum;
 #endif
 
@@ -74,7 +74,7 @@ using ::iswalnum;
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswalpha(wint_t __wc) {return iswalpha(__wc);}
 #undef iswalpha
 inline _LIBCPP_INLINE_VISIBILITY int iswalpha(wint_t __wc) {return __libcpp_iswalpha(__wc);}
-#else  // iswalpha
+#else
 using ::iswalpha;
 #endif
 
@@ -82,7 +82,7 @@ using ::iswalpha;
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswblank(wint_t __wc) {return iswblank(__wc);}
 #undef iswblank
 inline _LIBCPP_INLINE_VISIBILITY int iswblank(wint_t __wc) {return __libcpp_iswblank(__wc);}
-#else  // iswblank
+#else
 using ::iswblank;
 #endif
 
@@ -90,7 +90,7 @@ using ::iswblank;
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswcntrl(wint_t __wc) {return iswcntrl(__wc);}
 #undef iswcntrl
 inline _LIBCPP_INLINE_VISIBILITY int iswcntrl(wint_t __wc) {return __libcpp_iswcntrl(__wc);}
-#else  // iswcntrl
+#else
 using ::iswcntrl;
 #endif
 
@@ -98,7 +98,7 @@ using ::iswcntrl;
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswdigit(wint_t __wc) {return iswdigit(__wc);}
 #undef iswdigit
 inline _LIBCPP_INLINE_VISIBILITY int iswdigit(wint_t __wc) {return __libcpp_iswdigit(__wc);}
-#else  // iswdigit
+#else
 using ::iswdigit;
 #endif
 
@@ -106,7 +106,7 @@ using ::iswdigit;
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswgraph(wint_t __wc) {return iswgraph(__wc);}
 #undef iswgraph
 inline _LIBCPP_INLINE_VISIBILITY int iswgraph(wint_t __wc) {return __libcpp_iswgraph(__wc);}
-#else  // iswgraph
+#else
 using ::iswgraph;
 #endif
 
@@ -114,7 +114,7 @@ using ::iswgraph;
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswlower(wint_t __wc) {return iswlower(__wc);}
 #undef iswlower
 inline _LIBCPP_INLINE_VISIBILITY int iswlower(wint_t __wc) {return __libcpp_iswlower(__wc);}
-#else  // iswlower
+#else
 using ::iswlower;
 #endif
 
@@ -122,7 +122,7 @@ using ::iswlower;
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswprint(wint_t __wc) {return iswprint(__wc);}
 #undef iswprint
 inline _LIBCPP_INLINE_VISIBILITY int iswprint(wint_t __wc) {return __libcpp_iswprint(__wc);}
-#else  // iswprint
+#else
 using ::iswprint;
 #endif
 
@@ -130,7 +130,7 @@ using ::iswprint;
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswpunct(wint_t __wc) {return iswpunct(__wc);}
 #undef iswpunct
 inline _LIBCPP_INLINE_VISIBILITY int iswpunct(wint_t __wc) {return __libcpp_iswpunct(__wc);}
-#else  // iswpunct
+#else
 using ::iswpunct;
 #endif
 
@@ -138,7 +138,7 @@ using ::iswpunct;
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswspace(wint_t __wc) {return iswspace(__wc);}
 #undef iswspace
 inline _LIBCPP_INLINE_VISIBILITY int iswspace(wint_t __wc) {return __libcpp_iswspace(__wc);}
-#else  // iswspace
+#else
 using ::iswspace;
 #endif
 
@@ -146,7 +146,7 @@ using ::iswspace;
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswupper(wint_t __wc) {return iswupper(__wc);}
 #undef iswupper
 inline _LIBCPP_INLINE_VISIBILITY int iswupper(wint_t __wc) {return __libcpp_iswupper(__wc);}
-#else  // iswupper
+#else
 using ::iswupper;
 #endif
 
@@ -154,7 +154,7 @@ using ::iswupper;
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswxdigit(wint_t __wc) {return iswxdigit(__wc);}
 #undef iswxdigit
 inline _LIBCPP_INLINE_VISIBILITY int iswxdigit(wint_t __wc) {return __libcpp_iswxdigit(__wc);}
-#else  // iswxdigit
+#else
 using ::iswxdigit;
 #endif
 
@@ -162,7 +162,7 @@ using ::iswxdigit;
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_iswctype(wint_t __w, wctype_t __d) {return iswctype(__w, __d);}
 #undef iswctype
 inline _LIBCPP_INLINE_VISIBILITY int iswctype(wint_t __w, wctype_t __d) {return __libcpp_iswctype(__w, __d);}
-#else  // iswctype
+#else
 using ::iswctype;
 #endif
 
@@ -170,7 +170,7 @@ using ::iswctype;
 inline _LIBCPP_INLINE_VISIBILITY wctype_t __libcpp_wctype(const char* __p) {return wctype(__p);}
 #undef wctype
 inline _LIBCPP_INLINE_VISIBILITY wctype_t wctype(const char* __p) {return __libcpp_wctype(__p);}
-#else  // wctype
+#else
 using ::wctype;
 #endif
 
@@ -178,7 +178,7 @@ using ::wctype;
 inline _LIBCPP_INLINE_VISIBILITY wint_t __libcpp_towlower(wint_t __wc) {return towlower(__wc);}
 #undef towlower
 inline _LIBCPP_INLINE_VISIBILITY wint_t towlower(wint_t __wc) {return __libcpp_towlower(__wc);}
-#else  // towlower
+#else
 using ::towlower;
 #endif
 
@@ -186,7 +186,7 @@ using ::towlower;
 inline _LIBCPP_INLINE_VISIBILITY wint_t __libcpp_towupper(wint_t __wc) {return towupper(__wc);}
 #undef towupper
 inline _LIBCPP_INLINE_VISIBILITY wint_t towupper(wint_t __wc) {return __libcpp_towupper(__wc);}
-#else  // towupper
+#else
 using ::towupper;
 #endif
 
@@ -194,7 +194,7 @@ using ::towupper;
 inline _LIBCPP_INLINE_VISIBILITY wint_t __libcpp_towctrans(wint_t __wc, wctype_t __d) {return towctrans(__wc, __d);}
 #undef towctrans
 inline _LIBCPP_INLINE_VISIBILITY wint_t towctrans(wint_t __wc, wctype_t __d) {return __libcpp_towctrans(__wc, __d);}
-#else  // towctrans
+#else
 using ::towctrans;
 #endif
 
@@ -202,7 +202,7 @@ using ::towctrans;
 inline _LIBCPP_INLINE_VISIBILITY wctrans_t __libcpp_wctrans(const char* __p) {return wctrans(__p);}
 #undef wctrans
 inline _LIBCPP_INLINE_VISIBILITY wctrans_t wctrans(const char* __p) {return __libcpp_wctrans(__p);}
-#else  // wctrans
+#else
 using ::wctrans;
 #endif
 

include/exception

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -20,56 +20,54 @@ namespace std
 class exception
 {
 public:
-    exception() noexcept;
-    exception(const exception&) noexcept;
-    exception& operator=(const exception&) noexcept;
-    virtual ~exception() noexcept;
-    virtual const char* what() const noexcept;
+    exception() throw();
+    exception(const exception&) throw();
+    exception& operator=(const exception&) throw();
+    virtual ~exception() throw();
+    virtual const char* what() const throw();
 };
 
 class bad_exception
     : public exception
 {
 public:
-    bad_exception() noexcept;
-    bad_exception(const bad_exception&) noexcept;
-    bad_exception& operator=(const bad_exception&) noexcept;
-    virtual ~bad_exception() noexcept;
-    virtual const char* what() const noexcept;
+    bad_exception() throw();
+    bad_exception(const bad_exception&) throw();
+    bad_exception& operator=(const bad_exception&) throw();
+    virtual ~bad_exception() throw();
+    virtual const char* what() const throw();
 };
 
 typedef void (*unexpected_handler)();
-unexpected_handler set_unexpected(unexpected_handler  f ) noexcept;
-unexpected_handler get_unexpected() noexcept;
-[[noreturn]] void unexpected();
+unexpected_handler set_unexpected(unexpected_handler  f ) throw();
+void unexpected [[noreturn]] ();
 
 typedef void (*terminate_handler)();
-terminate_handler set_terminate(terminate_handler  f ) noexcept;
-terminate_handler get_terminate() noexcept;
-[[noreturn]] void terminate() noexcept;
+terminate_handler set_terminate(terminate_handler  f ) throw();
+void terminate [[noreturn]] ();
 
-bool uncaught_exception() noexcept;
+bool uncaught_exception() throw();
 
 typedef unspecified exception_ptr;
 
-exception_ptr current_exception() noexcept;
+exception_ptr current_exception();
 void rethrow_exception [[noreturn]] (exception_ptr p);
-template<class E> exception_ptr make_exception_ptr(E e) noexcept;
+template<class E> exception_ptr make_exception_ptr(E e);
 
 class nested_exception
 {
 public:
-    nested_exception() noexcept;
-    nested_exception(const nested_exception&) noexcept = default;
-    nested_exception& operator=(const nested_exception&) noexcept = default;
+    nested_exception() throw();
+    nested_exception(const nested_exception&) throw() = default;
+    nested_exception& operator=(const nested_exception&) throw() = default;
     virtual ~nested_exception() = default;
 
     // access functions
-    [[noreturn]] void rethrow_nested() const;
-    exception_ptr nested_ptr() const noexcept;
+    void rethrow_nested [[noreturn]] () const;
+    exception_ptr nested_ptr() const;
 };
 
-template <class T> [[noreturn]] void throw_with_nested(T&& t);
+template <class T> void throw_with_nested [[noreturn]] (T&& t);
 template <class E> void rethrow_if_nested(const E& e);
 
 }  // std
@@ -88,67 +86,61 @@ namespace std  // purposefully not using versioning namespace
 class _LIBCPP_EXCEPTION_ABI exception
 {
 public:
-    _LIBCPP_INLINE_VISIBILITY exception() _NOEXCEPT {}
-    virtual ~exception() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY exception() throw() {}
+    virtual ~exception() throw();
+    virtual const char* what() const throw();
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_exception
     : public exception
 {
 public:
-    _LIBCPP_INLINE_VISIBILITY bad_exception() _NOEXCEPT {}
-    virtual ~bad_exception() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY bad_exception() throw() {}
+    virtual ~bad_exception() throw();
+    virtual const char* what() const throw();
 };
 
 typedef void (*unexpected_handler)();
-_LIBCPP_VISIBLE unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;
-_LIBCPP_VISIBLE unexpected_handler get_unexpected() _NOEXCEPT;
-_ATTRIBUTE(noreturn) _LIBCPP_VISIBLE void unexpected();
+_LIBCPP_VISIBLE unexpected_handler set_unexpected(unexpected_handler) throw();
+_LIBCPP_VISIBLE void unexpected();
 
 typedef void (*terminate_handler)();
-_LIBCPP_VISIBLE terminate_handler set_terminate(terminate_handler) _NOEXCEPT;
-_LIBCPP_VISIBLE terminate_handler get_terminate() _NOEXCEPT;
-_ATTRIBUTE(noreturn) _LIBCPP_VISIBLE void terminate() _NOEXCEPT;
+_LIBCPP_VISIBLE terminate_handler set_terminate(terminate_handler) throw();
+_LIBCPP_VISIBLE void terminate() __attribute__((__noreturn__));
 
-_LIBCPP_VISIBLE bool uncaught_exception() _NOEXCEPT;
+_LIBCPP_VISIBLE bool uncaught_exception() throw();
 
 class exception_ptr;
 
-exception_ptr current_exception() _NOEXCEPT;
-_ATTRIBUTE(noreturn) void rethrow_exception(exception_ptr);
+exception_ptr current_exception();
+void rethrow_exception(exception_ptr);  // noreturn
 
-class _LIBCPP_VISIBLE exception_ptr
+class exception_ptr
 {
     void* __ptr_;
 public:
-    _LIBCPP_INLINE_VISIBILITY exception_ptr() _NOEXCEPT : __ptr_() {}
-    _LIBCPP_INLINE_VISIBILITY exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}
-    exception_ptr(const exception_ptr&) _NOEXCEPT;
-    exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
-    ~exception_ptr() _NOEXCEPT;
+    exception_ptr()  : __ptr_() {}
+    exception_ptr(nullptr_t) : __ptr_() {}
+    exception_ptr(const exception_ptr&);
+    exception_ptr& operator=(const exception_ptr&);
+    ~exception_ptr();
 
-    _LIBCPP_INLINE_VISIBILITY
     // explicit
-        operator bool() const _NOEXCEPT {return __ptr_ != nullptr;}
+        operator bool() const {return __ptr_ != nullptr;}
 
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
+    friend bool operator==(const exception_ptr& __x, const exception_ptr& __y)
         {return __x.__ptr_ == __y.__ptr_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
+    friend bool operator!=(const exception_ptr& __x, const exception_ptr& __y)
         {return !(__x == __y);}
 
-    friend exception_ptr current_exception() _NOEXCEPT;
-    _ATTRIBUTE(noreturn) friend void rethrow_exception(exception_ptr);
+    friend exception_ptr current_exception();
+    friend void rethrow_exception(exception_ptr);  // noreturn
 };
 
 template<class _E>
 exception_ptr
-make_exception_ptr(_E __e) _NOEXCEPT
+make_exception_ptr(_E __e)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
         throw __e;
@@ -157,7 +149,6 @@ make_exception_ptr(_E __e) _NOEXCEPT
     {
         return current_exception();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 // nested_exception
@@ -166,14 +157,14 @@ class _LIBCPP_EXCEPTION_ABI nested_exception
 {
     exception_ptr __ptr_;
 public:
-    nested_exception() _NOEXCEPT;
-//     nested_exception(const nested_exception&) noexcept = default;
-//     nested_exception& operator=(const nested_exception&) noexcept = default;
-    virtual ~nested_exception() _NOEXCEPT;
+    nested_exception();
+//     nested_exception(const nested_exception&) throw() = default;
+//     nested_exception& operator=(const nested_exception&) throw() = default;
+    virtual ~nested_exception();
 
     // access functions
-    _ATTRIBUTE(noreturn) void rethrow_nested() const;
-    _LIBCPP_INLINE_VISIBILITY exception_ptr nested_ptr() const _NOEXCEPT {return __ptr_;}
+    void rethrow_nested /*[[noreturn]]*/ () const;
+    exception_ptr nested_ptr() const {return __ptr_;}
 };
 
 template <class _Tp>
@@ -181,49 +172,43 @@ struct __nested
     : public _Tp,
       public nested_exception
 {
-    _LIBCPP_INLINE_VISIBILITY explicit __nested(const _Tp& __t) : _Tp(__t) {}
+    explicit __nested(const _Tp& __t) : _Tp(__t) {}
 };
 
 template <class _Tp>
-_ATTRIBUTE(noreturn)
-void
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-throw_with_nested(_Tp&& __t, typename enable_if<
+void 
+#ifdef _LIBCPP_MOVE
+throw_with_nested /*[[noreturn]]*/ (_Tp&& __t, typename enable_if<
                   is_class<typename remove_reference<_Tp>::type>::value &&
                   !is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value
                                     >::type* = 0)
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#else
 throw_with_nested (_Tp& __t, typename enable_if<
                   is_class<_Tp>::value && !is_base_of<nested_exception, _Tp>::value
                                     >::type* = 0)
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-{
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw __nested<typename remove_reference<_Tp>::type>(_STD::forward<_Tp>(__t));
 #endif
+{
+    throw __nested<typename remove_reference<_Tp>::type>(_STD::forward<_Tp>(__t));
 }
 
 template <class _Tp>
-_ATTRIBUTE(noreturn)
-void
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-throw_with_nested(_Tp&& __t, typename enable_if<
+void 
+#ifdef _LIBCPP_MOVE
+throw_with_nested /*[[noreturn]]*/ (_Tp&& __t, typename enable_if<
                   !is_class<typename remove_reference<_Tp>::type>::value ||
                   is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value
                                     >::type* = 0)
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#else
 throw_with_nested (_Tp& __t, typename enable_if<
                   !is_class<_Tp>::value || is_base_of<nested_exception, _Tp>::value
                                     >::type* = 0)
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-{
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw _STD::forward<_Tp>(__t);
 #endif
+{
+    throw _STD::forward<_Tp>(__t);
 }
 
 template <class _E>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 rethrow_if_nested(const _E& __e, typename enable_if<
                                    is_polymorphic<_E>::value
@@ -235,7 +220,7 @@ rethrow_if_nested(const _E& __e, typename enable_if<
 }
 
 template <class _E>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 rethrow_if_nested(const _E& __e, typename enable_if<
                                    !is_polymorphic<_E>::value

include/ext/hash_map

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -217,13 +217,11 @@ class __hash_map_hasher
     : private _Hash
 {
 public:
-    _LIBCPP_INLINE_VISIBILITY __hash_map_hasher() : _Hash() {}
-    _LIBCPP_INLINE_VISIBILITY __hash_map_hasher(const _Hash& __h) : _Hash(__h) {}
-    _LIBCPP_INLINE_VISIBILITY const _Hash& hash_function() const {return *this;}
-    _LIBCPP_INLINE_VISIBILITY
+    __hash_map_hasher() : _Hash() {}
+    __hash_map_hasher(const _Hash& __h) : _Hash(__h) {}
+    const _Hash& hash_function() const {return *this;}
     size_t operator()(const _Tp& __x) const
         {return static_cast<const _Hash&>(*this)(__x.first);}
-    _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const typename _Tp::first_type& __x) const
         {return static_cast<const _Hash&>(*this)(__x);}
 };
@@ -233,13 +231,11 @@ class __hash_map_hasher<_Tp, _Hash, false>
 {
     _Hash __hash_;
 public:
-    _LIBCPP_INLINE_VISIBILITY __hash_map_hasher() : __hash_() {}
-    _LIBCPP_INLINE_VISIBILITY __hash_map_hasher(const _Hash& __h) : __hash_(__h) {}
-    _LIBCPP_INLINE_VISIBILITY const _Hash& hash_function() const {return __hash_;}
-    _LIBCPP_INLINE_VISIBILITY
+    __hash_map_hasher() : __hash_() {}
+    __hash_map_hasher(const _Hash& __h) : __hash_(__h) {}
+    const _Hash& hash_function() const {return __hash_;}
     size_t operator()(const _Tp& __x) const
         {return __hash_(__x.first);}
-    _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const typename _Tp::first_type& __x) const
         {return __hash_(__x);}
 };
@@ -249,20 +245,16 @@ class __hash_map_equal
     : private _Pred
 {
 public:
-    _LIBCPP_INLINE_VISIBILITY __hash_map_equal() : _Pred() {}
-    _LIBCPP_INLINE_VISIBILITY __hash_map_equal(const _Pred& __p) : _Pred(__p) {}
-    _LIBCPP_INLINE_VISIBILITY const _Pred& key_eq() const {return *this;}
-    _LIBCPP_INLINE_VISIBILITY
+    __hash_map_equal() : _Pred() {}
+    __hash_map_equal(const _Pred& __p) : _Pred(__p) {}
+    const _Pred& key_eq() const {return *this;}
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return static_cast<const _Pred&>(*this)(__x.first, __y.first);}
-    _LIBCPP_INLINE_VISIBILITY
     bool operator()(const typename _Tp::first_type& __x, const _Tp& __y) const
         {return static_cast<const _Pred&>(*this)(__x, __y.first);}
-    _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const typename _Tp::first_type& __y) const
         {return static_cast<const _Pred&>(*this)(__x.first, __y);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const typename _Tp::first_type& __x,
+    bool operator()(const typename _Tp::first_type& __x, 
                     const typename _Tp::first_type& __y) const
         {return static_cast<const _Pred&>(*this)(__x, __y);}
 };
@@ -272,19 +264,15 @@ class __hash_map_equal<_Tp, _Pred, false>
 {
     _Pred __pred_;
 public:
-    _LIBCPP_INLINE_VISIBILITY __hash_map_equal() : __pred_() {}
-    _LIBCPP_INLINE_VISIBILITY __hash_map_equal(const _Pred& __p) : __pred_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY const _Pred& key_eq() const {return __pred_;}
-    _LIBCPP_INLINE_VISIBILITY
+    __hash_map_equal() : __pred_() {}
+    __hash_map_equal(const _Pred& __p) : __pred_(__p) {}
+    const _Pred& key_eq() const {return __pred_;}
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __pred_(__x.first, __y.first);}
-    _LIBCPP_INLINE_VISIBILITY
     bool operator()(const typename _Tp::first_type& __x, const _Tp& __y) const
         {return __pred_(__x, __y.first);}
-    _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const typename _Tp::first_type& __y) const
         {return __pred_(__x.first, __y);}
-    _LIBCPP_INLINE_VISIBILITY
     bool operator()(const typename _Tp::first_type& __x,
                     const typename _Tp::first_type& __y) const
         {return __pred_(__x, __y);}
@@ -310,15 +298,13 @@ public:
     bool __first_constructed;
     bool __second_constructed;
 
-    _LIBCPP_INLINE_VISIBILITY
     explicit __hash_map_node_destructor(allocator_type& __na)
         : __na_(__na),
           __first_constructed(false),
           __second_constructed(false)
         {}
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     __hash_map_node_destructor(__hash_node_destructor<allocator_type>&& __x)
         : __na_(__x.__na_),
           __first_constructed(__x.__value_constructed),
@@ -326,8 +312,7 @@ public:
         {
             __x.__value_constructed = false;
         }
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#else
     __hash_map_node_destructor(const __hash_node_destructor<allocator_type>& __x)
         : __na_(__x.__na_),
           __first_constructed(__x.__value_constructed),
@@ -335,22 +320,21 @@ public:
         {
             const_cast<bool&>(__x.__value_constructed) = false;
         }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY
     void operator()(pointer __p)
     {
         if (__second_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
+            __alloc_traits::destroy(__na_, addressof(__p->__value_.second));
         if (__first_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
+            __alloc_traits::destroy(__na_, addressof(__p->__value_.first));
         if (__p)
             __alloc_traits::deallocate(__na_, __p, 1);
     }
 };
 
 template <class _HashIterator>
-class _LIBCPP_VISIBLE __hash_map_iterator
+class __hash_map_iterator
 {
     _HashIterator __i_;
 
@@ -370,15 +354,14 @@ public:
 #endif
                                                                  pointer;
 
-    _LIBCPP_INLINE_VISIBILITY __hash_map_iterator() {}
+    __hash_map_iterator() {}
 
-    _LIBCPP_INLINE_VISIBILITY __hash_map_iterator(_HashIterator __i) : __i_(__i) {}
+    __hash_map_iterator(_HashIterator __i) : __i_(__i) {}
 
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return *operator->();}
-    _LIBCPP_INLINE_VISIBILITY pointer operator->() const {return (pointer)__i_.operator->();}
+    reference operator*() const {return *operator->();}
+    pointer operator->() const {return (pointer)__i_.operator->();}
 
-    _LIBCPP_INLINE_VISIBILITY __hash_map_iterator& operator++() {++__i_; return *this;}
-    _LIBCPP_INLINE_VISIBILITY
+    __hash_map_iterator& operator++() {++__i_; return *this;}
     __hash_map_iterator operator++(int)
     {
         __hash_map_iterator __t(*this);
@@ -386,22 +369,20 @@ public:
         return __t;
     }
 
-    friend _LIBCPP_INLINE_VISIBILITY 
-    bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
+    friend bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
         {return __x.__i_ == __y.__i_;}
-    friend _LIBCPP_INLINE_VISIBILITY 
-    bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
+    friend bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class, class> friend class _LIBCPP_VISIBLE hash_map;
-    template <class, class, class, class, class> friend class _LIBCPP_VISIBLE hash_multimap;
-    template <class> friend class _LIBCPP_VISIBLE __hash_const_iterator;
-    template <class> friend class _LIBCPP_VISIBLE __hash_const_local_iterator;
-    template <class> friend class _LIBCPP_VISIBLE __hash_map_const_iterator;
+    template <class, class, class, class, class> friend class hash_map;
+    template <class, class, class, class, class> friend class hash_multimap;
+    template <class> friend class __hash_const_iterator;
+    template <class> friend class __hash_const_local_iterator;
+    template <class> friend class __hash_map_const_iterator;
 };
 
 template <class _HashIterator>
-class _LIBCPP_VISIBLE __hash_map_const_iterator
+class __hash_map_const_iterator
 {
     _HashIterator __i_;
 
@@ -421,23 +402,17 @@ public:
 #endif
                                                                  pointer;
 
-    _LIBCPP_INLINE_VISIBILITY __hash_map_const_iterator() {}
+    __hash_map_const_iterator() {}
 
-    _LIBCPP_INLINE_VISIBILITY
     __hash_map_const_iterator(_HashIterator __i) : __i_(__i) {}
-    _LIBCPP_INLINE_VISIBILITY
     __hash_map_const_iterator(
             __hash_map_iterator<typename _HashIterator::__non_const_iterator> __i)
                 : __i_(__i.__i_) {}
 
-    _LIBCPP_INLINE_VISIBILITY
     reference operator*() const {return *operator->();}
-    _LIBCPP_INLINE_VISIBILITY
     pointer operator->() const {return (pointer)__i_.operator->();}
 
-    _LIBCPP_INLINE_VISIBILITY
     __hash_map_const_iterator& operator++() {++__i_; return *this;}
-    _LIBCPP_INLINE_VISIBILITY
     __hash_map_const_iterator operator++(int)
     {
         __hash_map_const_iterator __t(*this);
@@ -445,22 +420,20 @@ public:
         return __t;
     }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
+    friend bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
         {return __x.__i_ == __y.__i_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
+    friend bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class, class> friend class _LIBCPP_VISIBLE hash_map;
-    template <class, class, class, class, class> friend class _LIBCPP_VISIBLE hash_multimap;
-    template <class> friend class _LIBCPP_VISIBLE __hash_const_iterator;
-    template <class> friend class _LIBCPP_VISIBLE __hash_const_local_iterator;
+    template <class, class, class, class, class> friend class hash_map;
+    template <class, class, class, class, class> friend class hash_multimap;
+    template <class> friend class __hash_const_iterator;
+    template <class> friend class __hash_const_local_iterator;
 };
 
 template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
           class _Alloc = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_VISIBLE hash_map
+class hash_map
 {
 public:
     // types
@@ -507,7 +480,7 @@ public:
     typedef __hash_map_iterator<typename __table::iterator>       iterator;
     typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
 
-    _LIBCPP_INLINE_VISIBILITY hash_map() {__table_.rehash(193);}
+    hash_map() {__table_.rehash(193);}
     explicit hash_map(size_type __n, const hasher& __hf = hasher(),
                            const key_equal& __eql = key_equal());
     hash_map(size_type __n, const hasher& __hf,
@@ -526,77 +499,52 @@ public:
                       const allocator_type& __a);
     hash_map(const hash_map& __u);
 
-    _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
     bool      empty() const {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
     size_type size() const  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const {return __table_.max_size();}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator       begin()        {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
     iterator       end()          {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator begin()  const {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator end()    const {return __table_.end();}
 
-    _LIBCPP_INLINE_VISIBILITY
     pair<iterator, bool> insert(const value_type& __x)
         {return __table_.__insert_unique(__x);}
     template <class _InputIterator>
         void insert(_InputIterator __first, _InputIterator __last);
 
-    _LIBCPP_INLINE_VISIBILITY
     void erase(const_iterator __p) {__table_.erase(__p.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     void erase(const_iterator __first, const_iterator __last)
         {__table_.erase(__first.__i_, __last.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
     void clear() {__table_.clear();}
 
-    _LIBCPP_INLINE_VISIBILITY
     void swap(hash_map& __u) {__table_.swap(__u.__table_);}
 
-    _LIBCPP_INLINE_VISIBILITY
     hasher hash_funct() const
         {return __table_.hash_function().hash_function();}
-    _LIBCPP_INLINE_VISIBILITY
     key_equal key_eq() const
         {return __table_.key_eq().key_eq();}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator       find(const key_type& __k)       {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator find(const key_type& __k) const {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<iterator, iterator>             equal_range(const key_type& __k)
         {return __table_.__equal_range_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
         {return __table_.__equal_range_unique(__k);}
 
     mapped_type& operator[](const key_type& __k);
 
-    _LIBCPP_INLINE_VISIBILITY
     size_type bucket_count() const {return __table_.bucket_count();}
-    _LIBCPP_INLINE_VISIBILITY
     size_type max_bucket_count() const {return __table_.max_bucket_count();}
 
-    _LIBCPP_INLINE_VISIBILITY
     size_type elems_in_bucket(size_type __n) const
         {return __table_.bucket_size(__n);}
 
-    _LIBCPP_INLINE_VISIBILITY
     void resize(size_type __n) {__table_.rehash(__n);}
 
 private:
@@ -666,16 +614,16 @@ hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type& __k)
 {
     __node_allocator& __na = __table_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
+    __node_traits::construct(__na, addressof(__h->__value_.first), __k);
     __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
+    __node_traits::construct(__na, addressof(__h->__value_.second));
     __h.get_deleter().__second_constructed = true;
     return _STD::move(__h);
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                        _InputIterator __last)
@@ -698,7 +646,7 @@ hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
      hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
@@ -726,7 +674,7 @@ operator==(const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator!=(const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
            const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
@@ -736,7 +684,7 @@ operator!=(const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 
 template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
           class _Alloc = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_VISIBLE hash_multimap
+class hash_multimap
 {
 public:
     // types
@@ -781,7 +729,6 @@ public:
     typedef __hash_map_iterator<typename __table::iterator>       iterator;
     typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
 
-    _LIBCPP_INLINE_VISIBILITY
     hash_multimap() {__table_.rehash(193);}
     explicit hash_multimap(size_type __n, const hasher& __hf = hasher(),
                                 const key_equal& __eql = key_equal());
@@ -801,74 +748,49 @@ public:
                       const allocator_type& __a);
     hash_multimap(const hash_multimap& __u);
 
-    _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
     bool      empty() const {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
     size_type size() const  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const {return __table_.max_size();}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator       begin()        {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
     iterator       end()          {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator begin()  const {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator end()    const {return __table_.end();}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
     template <class _InputIterator>
         void insert(_InputIterator __first, _InputIterator __last);
 
-    _LIBCPP_INLINE_VISIBILITY
     void erase(const_iterator __p) {__table_.erase(__p.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     void erase(const_iterator __first, const_iterator __last)
         {__table_.erase(__first.__i_, __last.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
     void clear() {__table_.clear();}
 
-    _LIBCPP_INLINE_VISIBILITY
     void swap(hash_multimap& __u) {__table_.swap(__u.__table_);}
 
-    _LIBCPP_INLINE_VISIBILITY
     hasher hash_funct() const
         {return __table_.hash_function().hash_function();}
-    _LIBCPP_INLINE_VISIBILITY
     key_equal key_eq() const
         {return __table_.key_eq().key_eq();}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator       find(const key_type& __k)       {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator find(const key_type& __k) const {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<iterator, iterator>             equal_range(const key_type& __k)
         {return __table_.__equal_range_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
         {return __table_.__equal_range_multi(__k);}
 
-    _LIBCPP_INLINE_VISIBILITY
     size_type bucket_count() const {return __table_.bucket_count();}
-    _LIBCPP_INLINE_VISIBILITY
     size_type max_bucket_count() const {return __table_.max_bucket_count();}
 
-    _LIBCPP_INLINE_VISIBILITY
     size_type elems_in_bucket(size_type __n) const
         {return __table_.bucket_size(__n);}
 
-    _LIBCPP_INLINE_VISIBILITY
     void resize(size_type __n) {__table_.rehash(__n);}
 };
 
@@ -931,7 +853,7 @@ hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                             _InputIterator __last)
@@ -941,7 +863,7 @@ hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
      hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
@@ -973,7 +895,7 @@ operator==(const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator!=(const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
            const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)

include/ext/hash_set

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -205,7 +205,7 @@ using namespace std;
 
 template <class _Value, class _Hash = std::hash<_Value>, class _Pred = equal_to<_Value>,
           class _Alloc = allocator<_Value> >
-class _LIBCPP_VISIBLE hash_set
+class hash_set
 {
 public:
     // types
@@ -231,7 +231,6 @@ public:
     typedef typename __table::const_iterator       iterator;
     typedef typename __table::const_iterator       const_iterator;
 
-    _LIBCPP_INLINE_VISIBILITY
     hash_set() {__table_.rehash(193);}
     explicit hash_set(size_type __n, const hasher& __hf = hasher(),
                            const key_equal& __eql = key_equal());
@@ -249,72 +248,47 @@ public:
                       const allocator_type& __a);
     hash_set(const hash_set& __u);
 
-    _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
     bool      empty() const {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
     size_type size() const  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const {return __table_.max_size();}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator       begin()        {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
     iterator       end()          {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator begin()  const {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator end()    const {return __table_.end();}
 
-    _LIBCPP_INLINE_VISIBILITY
     pair<iterator, bool> insert(const value_type& __x)
         {return __table_.__insert_unique(__x);}
     template <class _InputIterator>
         void insert(_InputIterator __first, _InputIterator __last);
 
-    _LIBCPP_INLINE_VISIBILITY
     void erase(const_iterator __p) {__table_.erase(__p);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     void erase(const_iterator __first, const_iterator __last)
         {__table_.erase(__first, __last);}
-    _LIBCPP_INLINE_VISIBILITY
     void clear() {__table_.clear();}
 
-    _LIBCPP_INLINE_VISIBILITY
     void swap(hash_set& __u) {__table_.swap(__u.__table_);}
 
-    _LIBCPP_INLINE_VISIBILITY
     hasher hash_funct() const {return __table_.hash_function();}
-    _LIBCPP_INLINE_VISIBILITY
     key_equal key_eq() const {return __table_.key_eq();}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator       find(const key_type& __k)       {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator find(const key_type& __k) const {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<iterator, iterator>             equal_range(const key_type& __k)
         {return __table_.__equal_range_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
         {return __table_.__equal_range_unique(__k);}
 
-    _LIBCPP_INLINE_VISIBILITY
     size_type bucket_count() const {return __table_.bucket_count();}
-    _LIBCPP_INLINE_VISIBILITY
     size_type max_bucket_count() const {return __table_.max_bucket_count();}
 
-    _LIBCPP_INLINE_VISIBILITY
     size_type elems_in_bucket(size_type __n) const {return __table_.bucket_size(__n);}
 
-    _LIBCPP_INLINE_VISIBILITY
     void resize(size_type __n) {__table_.rehash(__n);}
 };
 
@@ -376,7 +350,7 @@ hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 hash_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                     _InputIterator __last)
@@ -386,7 +360,7 @@ hash_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(hash_set<_Value, _Hash, _Pred, _Alloc>& __x,
      hash_set<_Value, _Hash, _Pred, _Alloc>& __y)
@@ -414,7 +388,7 @@ operator==(const hash_set<_Value, _Hash, _Pred, _Alloc>& __x,
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator!=(const hash_set<_Value, _Hash, _Pred, _Alloc>& __x,
            const hash_set<_Value, _Hash, _Pred, _Alloc>& __y)
@@ -424,7 +398,7 @@ operator!=(const hash_set<_Value, _Hash, _Pred, _Alloc>& __x,
 
 template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
           class _Alloc = allocator<_Value> >
-class _LIBCPP_VISIBLE hash_multiset
+class hash_multiset
 {
 public:
     // types
@@ -450,7 +424,6 @@ public:
     typedef typename __table::const_iterator       iterator;
     typedef typename __table::const_iterator       const_iterator;
 
-    _LIBCPP_INLINE_VISIBILITY
     hash_multiset() {__table_.rehash(193);}
     explicit hash_multiset(size_type __n, const hasher& __hf = hasher(),
                                 const key_equal& __eql = key_equal());
@@ -468,71 +441,46 @@ public:
                       const key_equal& __eql, const allocator_type& __a);
     hash_multiset(const hash_multiset& __u);
 
-    _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
     bool      empty() const {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
     size_type size() const  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const {return __table_.max_size();}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator       begin()        {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
     iterator       end()          {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator begin()  const {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator end()    const {return __table_.end();}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
     template <class _InputIterator>
         void insert(_InputIterator __first, _InputIterator __last);
 
-    _LIBCPP_INLINE_VISIBILITY
     void erase(const_iterator __p) {__table_.erase(__p);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     void erase(const_iterator __first, const_iterator __last)
         {__table_.erase(__first, __last);}
-    _LIBCPP_INLINE_VISIBILITY
     void clear() {__table_.clear();}
 
-    _LIBCPP_INLINE_VISIBILITY
     void swap(hash_multiset& __u) {__table_.swap(__u.__table_);}
 
-    _LIBCPP_INLINE_VISIBILITY
     hasher hash_funct() const {return __table_.hash_function();}
-    _LIBCPP_INLINE_VISIBILITY
     key_equal key_eq() const {return __table_.key_eq();}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator       find(const key_type& __k)       {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator find(const key_type& __k) const {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<iterator, iterator>             equal_range(const key_type& __k)
         {return __table_.__equal_range_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
         {return __table_.__equal_range_multi(__k);}
 
-    _LIBCPP_INLINE_VISIBILITY
     size_type bucket_count() const {return __table_.bucket_count();}
-    _LIBCPP_INLINE_VISIBILITY
     size_type max_bucket_count() const {return __table_.max_bucket_count();}
 
-    _LIBCPP_INLINE_VISIBILITY
     size_type elems_in_bucket(size_type __n) const {return __table_.bucket_size(__n);}
 
-    _LIBCPP_INLINE_VISIBILITY
     void resize(size_type __n) {__table_.rehash(__n);}
 };
 
@@ -595,7 +543,7 @@ hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 hash_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                          _InputIterator __last)
@@ -605,7 +553,7 @@ hash_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
      hash_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
@@ -637,7 +585,7 @@ operator==(const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator!=(const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
            const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __y)

include/fstream

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -122,7 +122,7 @@ public:
     void close();
 };
 
-template <class charT, class traits>
+template <class charT, class traits> 
   void
   swap(basic_ofstream<charT, traits>& x, basic_ofstream<charT, traits>& y);
 
@@ -176,7 +176,7 @@ typedef basic_fstream<wchar_t> wfstream;
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_VISIBLE basic_filebuf
+class basic_filebuf
     : public basic_streambuf<_CharT, _Traits>
 {
 public:
@@ -189,13 +189,13 @@ public:
 
     // 27.9.1.2 Constructors/destructor:
     basic_filebuf();
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_filebuf(basic_filebuf&& __rhs);
 #endif
     virtual ~basic_filebuf();
 
     // 27.9.1.3 Assign/swap:
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_filebuf& operator=(basic_filebuf&& __rhs);
 #endif
     void swap(basic_filebuf& __rhs);
@@ -260,7 +260,7 @@ basic_filebuf<_CharT, _Traits>::basic_filebuf()
     setbuf(0, 4096);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _CharT, class _Traits>
 basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs)
@@ -333,7 +333,7 @@ basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs)
     swap(__rhs);
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _CharT, class _Traits>
 basic_filebuf<_CharT, _Traits>::~basic_filebuf()
@@ -341,14 +341,14 @@ basic_filebuf<_CharT, _Traits>::~basic_filebuf()
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         close();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     if (__owns_eb_)
         delete [] __extbuf_;
     if (__owns_ib_)
@@ -579,7 +579,7 @@ basic_filebuf<_CharT, _Traits>::underflow()
                 this->setg(this->eback(),
                            this->eback() + __unget_sz,
                            this->eback() + __unget_sz + __nmemb);
-                __c = traits_type::to_int_type(*this->gptr());
+                __c = *this->gptr();
             }
         }
         else
@@ -587,7 +587,7 @@ basic_filebuf<_CharT, _Traits>::underflow()
             memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
             __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
             __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
-            size_t __nmemb = _STD::min(static_cast<size_t>(this->egptr() - this->eback() - __unget_sz),
+            size_t __nmemb = min(static_cast<size_t>(this->egptr() - this->eback() - __unget_sz),
                                  static_cast<size_t>(__extbufend_ - __extbufnext_));
             codecvt_base::result __r;
             state_type __svs = __st_;
@@ -602,18 +602,18 @@ basic_filebuf<_CharT, _Traits>::underflow()
                 if (__r == codecvt_base::noconv)
                 {
                     this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, (char_type*)__extbufend_);
-                    __c = traits_type::to_int_type(*this->gptr());
+                    __c = *this->gptr();
                 }
                 else if (__inext != this->eback() + __unget_sz)
                 {
                     this->setg(this->eback(), this->eback() + __unget_sz, __inext);
-                    __c = traits_type::to_int_type(*this->gptr());
+                    __c = *this->gptr();
                 }
             }
         }
     }
     else
-        __c = traits_type::to_int_type(*this->gptr());
+        __c = *this->gptr();
     if (this->eback() == &__1buf)
         this->setg(0, 0, 0);
     return __c;
@@ -789,7 +789,7 @@ basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way,
 
 template <class _CharT, class _Traits>
 typename basic_filebuf<_CharT, _Traits>::pos_type
-basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode)
+basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode __wch)
 {
     if (__file_ == 0 || sync())
         return pos_type(off_type(-1));
@@ -957,7 +957,7 @@ basic_filebuf<_CharT, _Traits>::__write_mode()
 // basic_ifstream
 
 template <class _CharT, class _Traits>
-class _LIBCPP_VISIBLE basic_ifstream
+class basic_ifstream
     : public basic_istream<_CharT, _Traits>
 {
 public:
@@ -970,11 +970,11 @@ public:
     basic_ifstream();
     explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in);
     explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_ifstream(basic_ifstream&& __rhs);
 #endif
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_ifstream& operator=(basic_ifstream&& __rhs);
 #endif
     void swap(basic_ifstream& __rhs);
@@ -1014,7 +1014,7 @@ basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::ope
         this->setstate(ios_base::failbit);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1035,7 +1035,7 @@ basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1102,7 +1102,7 @@ basic_ifstream<_CharT, _Traits>::close()
 // basic_ofstream
 
 template <class _CharT, class _Traits>
-class _LIBCPP_VISIBLE basic_ofstream
+class basic_ofstream
     : public basic_ostream<_CharT, _Traits>
 {
 public:
@@ -1115,11 +1115,11 @@ public:
     basic_ofstream();
     explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out);
     explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_ofstream(basic_ofstream&& __rhs);
 #endif
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_ofstream& operator=(basic_ofstream&& __rhs);
 #endif
     void swap(basic_ofstream& __rhs);
@@ -1159,7 +1159,7 @@ basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::ope
         this->setstate(ios_base::failbit);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1180,7 +1180,7 @@ basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs)
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1247,7 +1247,7 @@ basic_ofstream<_CharT, _Traits>::close()
 // basic_fstream
 
 template <class _CharT, class _Traits>
-class _LIBCPP_VISIBLE basic_fstream
+class basic_fstream
     : public basic_iostream<_CharT, _Traits>
 {
 public:
@@ -1260,11 +1260,11 @@ public:
     basic_fstream();
     explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
     explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_fstream(basic_fstream&& __rhs);
 #endif
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_fstream& operator=(basic_fstream&& __rhs);
 #endif
     void swap(basic_fstream& __rhs);
@@ -1304,7 +1304,7 @@ basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openm
         this->setstate(ios_base::failbit);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1325,7 +1325,7 @@ basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs)
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY

include/initializer_list

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -29,15 +29,15 @@ public:
     typedef const E* iterator;
     typedef const E* const_iterator;
 
-    initializer_list() noexcept;
+    initializer_list();
 
-    size_t   size()  const noexcept;
-    const E* begin() const noexcept;
-    const E* end()   const noexcept;
+    size_t   size()  const;
+    const E* begin() const;
+    const E* end()   const;
 };
 
-template<class E> const E* begin(initializer_list<E> il) noexcept;
-template<class E> const E* end(initializer_list<E> il) noexcept;
+template<class E> const E* begin(initializer_list<E> il);
+template<class E> const E* end(initializer_list<E> il);
 
 }  // std
 
@@ -52,13 +52,13 @@ namespace std  // purposefully not versioned
 {
 
 template<class _E>
-class _LIBCPP_VISIBLE initializer_list
+class initializer_list
 {
     const _E* __begin_;
     size_t    __size_;
 
     _LIBCPP_ALWAYS_INLINE
-    initializer_list(const _E* __b, size_t __s) _NOEXCEPT
+    initializer_list(const _E* __b, size_t __s)
         : __begin_(__b),
           __size_(__s)
         {}
@@ -71,17 +71,17 @@ public:
     typedef const _E* iterator;
     typedef const _E* const_iterator;
 
-    _LIBCPP_ALWAYS_INLINE initializer_list() _NOEXCEPT : __begin_(nullptr), __size_(0) {}
+    _LIBCPP_ALWAYS_INLINE initializer_list() : __begin_(nullptr), __size_(0) {}
 
-    _LIBCPP_ALWAYS_INLINE size_t    size()  const _NOEXCEPT {return __size_;}
-    _LIBCPP_ALWAYS_INLINE const _E* begin() const _NOEXCEPT {return __begin_;}
-    _LIBCPP_ALWAYS_INLINE const _E* end()   const _NOEXCEPT {return __begin_ + __size_;}
+    _LIBCPP_ALWAYS_INLINE size_t    size()  const {return __size_;}
+    _LIBCPP_ALWAYS_INLINE const _E* begin() const {return __begin_;}
+    _LIBCPP_ALWAYS_INLINE const _E* end()   const {return __begin_ + __size_;}
 };
 
 template<class _E>
 inline _LIBCPP_INLINE_VISIBILITY
 const _E*
-begin(initializer_list<_E> __il) _NOEXCEPT
+begin(initializer_list<_E> __il)
 {
     return __il.begin();
 }
@@ -89,7 +89,7 @@ begin(initializer_list<_E> __il) _NOEXCEPT
 template<class _E>
 inline _LIBCPP_INLINE_VISIBILITY
 const _E*
-end(initializer_list<_E> __il) _NOEXCEPT
+end(initializer_list<_E> __il)
 {
     return __il.end();
 }

include/iomanip

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -43,12 +43,10 @@ class __iom_t1
 {
     ios_base::fmtflags __mask_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
     explicit __iom_t1(ios_base::fmtflags __m) : __mask_(__m) {}
 
     template <class _CharT, class _Traits>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     basic_istream<_CharT, _Traits>&
     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t1& __x)
     {
@@ -58,7 +56,6 @@ public:
 
     template <class _CharT, class _Traits>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     basic_ostream<_CharT, _Traits>&
     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t1& __x)
     {
@@ -80,12 +77,10 @@ class __iom_t2
 {
     ios_base::fmtflags __mask_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
     explicit __iom_t2(ios_base::fmtflags __m) : __mask_(__m) {}
 
     template <class _CharT, class _Traits>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     basic_istream<_CharT, _Traits>&
     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t2& __x)
     {
@@ -95,7 +90,6 @@ public:
 
     template <class _CharT, class _Traits>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     basic_ostream<_CharT, _Traits>&
     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t2& __x)
     {
@@ -117,12 +111,10 @@ class __iom_t3
 {
     int __base_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
     explicit __iom_t3(int __b) : __base_(__b) {}
 
     template <class _CharT, class _Traits>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     basic_istream<_CharT, _Traits>&
     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t3& __x)
     {
@@ -135,7 +127,6 @@ public:
 
     template <class _CharT, class _Traits>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     basic_ostream<_CharT, _Traits>&
     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t3& __x)
     {
@@ -161,12 +152,10 @@ class __iom_t4
 {
     _CharT __fill_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
     explicit __iom_t4(_CharT __c) : __fill_(__c) {}
 
     template <class _Traits>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     basic_ostream<_CharT, _Traits>&
     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t4& __x)
     {
@@ -189,12 +178,10 @@ class __iom_t5
 {
     int __n_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
     explicit __iom_t5(int __n) : __n_(__n) {}
 
     template <class _CharT, class _Traits>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     basic_istream<_CharT, _Traits>&
     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t5& __x)
     {
@@ -204,7 +191,6 @@ public:
 
     template <class _CharT, class _Traits>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     basic_ostream<_CharT, _Traits>&
     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t5& __x)
     {
@@ -226,12 +212,10 @@ class __iom_t6
 {
     int __n_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
     explicit __iom_t6(int __n) : __n_(__n) {}
 
     template <class _CharT, class _Traits>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     basic_istream<_CharT, _Traits>&
     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t6& __x)
     {
@@ -241,7 +225,6 @@ public:
 
     template <class _CharT, class _Traits>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     basic_ostream<_CharT, _Traits>&
     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t6& __x)
     {
@@ -271,7 +254,6 @@ class __iom_t7
     _MoneyT& __mon_;
     bool __intl_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
     __iom_t7(_MoneyT& __mon, bool __intl)
         : __mon_(__mon), __intl_(__intl) {}
 
@@ -288,7 +270,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_istream<_CharT, _Traits>::sentry __s(__is);
         if (__s)
         {
@@ -305,7 +287,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x)
     {
         __is.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __is;
 }
 
@@ -331,7 +313,6 @@ class __iom_t8
     const _MoneyT& __mon_;
     bool __intl_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
     __iom_t8(const _MoneyT& __mon, bool __intl)
         : __mon_(__mon), __intl_(__intl) {}
 
@@ -348,7 +329,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
         if (__s)
         {
@@ -364,7 +345,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __os;
 }
 
@@ -390,7 +371,6 @@ class __iom_t9
     tm* __tm_;
     const _CharT* __fmt_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
     __iom_t9(tm* __tm, const _CharT* __fmt)
         : __tm_(__tm), __fmt_(__fmt) {}
 
@@ -407,7 +387,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_istream<_CharT, _Traits>::sentry __s(__is);
         if (__s)
         {
@@ -425,7 +405,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x)
     {
         __is.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __is;
 }
 
@@ -451,7 +431,6 @@ class __iom_t10
     const tm* __tm_;
     const _CharT* __fmt_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
     __iom_t10(const tm* __tm, const _CharT* __fmt)
         : __tm_(__tm), __fmt_(__fmt) {}
 
@@ -468,7 +447,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
         if (__s)
         {
@@ -485,7 +464,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __os;
 }
 

include/ios

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -222,7 +222,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 typedef ptrdiff_t streamsize;
 
-class _LIBCPP_VISIBLE ios_base
+class ios_base
 {
 public:
     class failure;
@@ -272,16 +272,16 @@ public:
     class Init;
 
     // 27.5.2.2 fmtflags state:
-    _LIBCPP_INLINE_VISIBILITY fmtflags flags() const;
-    _LIBCPP_INLINE_VISIBILITY fmtflags flags(fmtflags __fmtfl);
-    _LIBCPP_INLINE_VISIBILITY fmtflags setf(fmtflags __fmtfl);
-    _LIBCPP_INLINE_VISIBILITY fmtflags setf(fmtflags __fmtfl, fmtflags __mask);
-    _LIBCPP_INLINE_VISIBILITY void unsetf(fmtflags __mask);
+    fmtflags flags() const;
+    fmtflags flags(fmtflags __fmtfl);
+    fmtflags setf(fmtflags __fmtfl);
+    fmtflags setf(fmtflags __fmtfl, fmtflags __mask);
+    void unsetf(fmtflags __mask);
 
-    _LIBCPP_INLINE_VISIBILITY streamsize precision() const;
-    _LIBCPP_INLINE_VISIBILITY streamsize precision(streamsize __prec);
-    _LIBCPP_INLINE_VISIBILITY streamsize width() const;
-    _LIBCPP_INLINE_VISIBILITY streamsize width(streamsize __wide);
+    streamsize precision() const;
+    streamsize precision(streamsize __prec);
+    streamsize width() const;
+    streamsize width(streamsize __wide);
 
     // 27.5.2.3 locales:
     locale imbue(const locale& __loc);
@@ -307,23 +307,22 @@ private:
 public:
     static bool sync_with_stdio(bool __sync = true);
 
-    _LIBCPP_INLINE_VISIBILITY iostate rdstate() const;
+    iostate rdstate() const;
     void clear(iostate __state = goodbit);
-    _LIBCPP_INLINE_VISIBILITY void setstate(iostate __state);
+    void setstate(iostate __state);
+    
+    bool good() const; 
+    bool eof() const; 
+    bool fail() const; 
+    bool bad() const; 
 
-    _LIBCPP_INLINE_VISIBILITY bool good() const;
-    _LIBCPP_INLINE_VISIBILITY bool eof() const;
-    _LIBCPP_INLINE_VISIBILITY bool fail() const;
-    _LIBCPP_INLINE_VISIBILITY bool bad() const;
-
-    _LIBCPP_INLINE_VISIBILITY iostate exceptions() const;
-    _LIBCPP_INLINE_VISIBILITY void exceptions(iostate __except);
+    iostate exceptions() const; 
+    void exceptions(iostate __except);
 
     void __set_badbit_and_consider_rethrow();
     void __set_failbit_and_consider_rethrow();
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
     ios_base() {// purposefully does no initialization
                }
 
@@ -371,7 +370,7 @@ private:
 };
 
 //enum class io_errc
-struct _LIBCPP_VISIBLE io_errc
+struct io_errc
 {
 enum _ {
     stream = 1
@@ -382,12 +381,9 @@ enum _ {
     _LIBCPP_ALWAYS_INLINE operator int() const {return __v_;}
 };
 
-template <>
-struct _LIBCPP_VISIBLE is_error_code_enum<io_errc> : public true_type { };
-template <>
-struct _LIBCPP_VISIBLE is_error_code_enum<io_errc::_> : public true_type { };
+template <> struct is_error_code_enum<io_errc> : public true_type { };
+template <> struct is_error_code_enum<io_errc::_> : public true_type { };
 
-_LIBCPP_VISIBLE
 const error_category& iostream_category();
 
 inline _LIBCPP_INLINE_VISIBILITY
@@ -404,16 +400,16 @@ make_error_condition(io_errc __e)
     return error_condition(static_cast<int>(__e), iostream_category());
 }
 
-class _LIBCPP_EXCEPTION_ABI ios_base::failure
+class ios_base::failure
     : public system_error
-{
-public:
+{ 
+public: 
     explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);
-    explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
+    explicit failure(const char* __msg, const error_code& __ec = io_errc::stream); 
     virtual ~failure() throw();
 };
 
-class _LIBCPP_VISIBLE ios_base::Init
+class ios_base::Init
 {
 public:
     Init();
@@ -560,7 +556,7 @@ ios_base::exceptions(iostate __except)
 }
 
 template <class _CharT, class _Traits>
-class _LIBCPP_VISIBLE basic_ios
+class basic_ios
     : public ios_base
 {
 public:
@@ -587,52 +583,36 @@ public:
     _LIBCPP_ALWAYS_INLINE void exceptions(iostate __except) {ios_base::exceptions(__except);}
 
     // 27.5.4.1 Constructor/destructor:
-    _LIBCPP_INLINE_VISIBILITY
     explicit basic_ios(basic_streambuf<char_type,traits_type>* __sb);
     virtual ~basic_ios();
 
     // 27.5.4.2 Members:
-    _LIBCPP_INLINE_VISIBILITY 
     basic_ostream<char_type, traits_type>* tie() const;
-    _LIBCPP_INLINE_VISIBILITY 
     basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr);
 
-    _LIBCPP_INLINE_VISIBILITY 
     basic_streambuf<char_type, traits_type>* rdbuf() const;
-    _LIBCPP_INLINE_VISIBILITY 
     basic_streambuf<char_type, traits_type>* rdbuf(basic_streambuf<char_type, traits_type>* __sb);
 
     basic_ios& copyfmt(const basic_ios& __rhs);
 
-    _LIBCPP_INLINE_VISIBILITY 
     char_type fill() const;
-    _LIBCPP_INLINE_VISIBILITY 
     char_type fill(char_type __ch);
 
-    _LIBCPP_INLINE_VISIBILITY 
     locale imbue(const locale& __loc);
 
-    _LIBCPP_INLINE_VISIBILITY 
     char narrow(char_type __c, char __dfault) const;
-    _LIBCPP_INLINE_VISIBILITY 
     char_type widen(char __c) const;
 
 protected:
-    _LIBCPP_ALWAYS_INLINE
     basic_ios() {// purposefully does no initialization
                 }
-    _LIBCPP_INLINE_VISIBILITY 
     void init(basic_streambuf<char_type, traits_type>* __sb);
 
-    _LIBCPP_INLINE_VISIBILITY 
     void move(basic_ios& __rhs);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_ALWAYS_INLINE
+#ifdef _LIBCPP_MOVE
     void move(basic_ios&& __rhs) {move(__rhs);}
 #endif
-    _LIBCPP_INLINE_VISIBILITY 
     void swap(basic_ios& __rhs);
-    _LIBCPP_INLINE_VISIBILITY 
     void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb);
 private:
     basic_ostream<char_type, traits_type>* __tie_;

include/iosfwd

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -20,7 +20,6 @@ namespace std
 template<class charT> struct char_traits;
 template<class T>     class allocator;
 
-class ios_base;
 template <class charT, class traits = char_traits<charT> > class basic_ios;
 
 template <class charT, class traits = char_traits<charT> > class basic_streambuf;
@@ -93,49 +92,32 @@ typedef fpos<char_traits<wchar_t>::state_type> wstreampos;
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class ios_base;
+template<class _CharT>  struct char_traits;
+template<class _Tp>     class allocator;
 
-template<class _CharT>  struct _LIBCPP_VISIBLE char_traits;
-template<class _Tp>     class _LIBCPP_VISIBLE allocator;
+template <class _CharT, class _Traits = char_traits<_CharT> > class basic_ios;
 
-template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_VISIBLE basic_ios;
+template <class _CharT, class _Traits = char_traits<_CharT> > class basic_streambuf;
+template <class _CharT, class _Traits = char_traits<_CharT> > class basic_istream;
+template <class _CharT, class _Traits = char_traits<_CharT> > class basic_ostream;
+template <class _CharT, class _Traits = char_traits<_CharT> > class basic_iostream;
 
-template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_VISIBLE basic_streambuf;
-template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_VISIBLE basic_istream;
-template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_VISIBLE basic_ostream;
-template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_VISIBLE basic_iostream;
+template <class _CharT, class _Traits = char_traits<_CharT>,  class _Allocator = allocator<_CharT> >
+    class basic_stringbuf;
+template <class _CharT, class _Traits = char_traits<_CharT>,  class _Allocator = allocator<_CharT> >
+    class basic_istringstream;
+template <class _CharT, class _Traits = char_traits<_CharT>,  class _Allocator = allocator<_CharT> >
+    class basic_ostringstream;
+template <class _CharT, class _Traits = char_traits<_CharT>,  class _Allocator = allocator<_CharT> >
+    class basic_stringstream;
 
-template <class _CharT, class _Traits = char_traits<_CharT>,
-          class _Allocator = allocator<_CharT> >
-    class _LIBCPP_VISIBLE basic_stringbuf;
-template <class _CharT, class _Traits = char_traits<_CharT>,
-          class _Allocator = allocator<_CharT> >
-    class _LIBCPP_VISIBLE basic_istringstream;
-template <class _CharT, class _Traits = char_traits<_CharT>,
-          class _Allocator = allocator<_CharT> >
-    class _LIBCPP_VISIBLE basic_ostringstream;
-template <class _CharT, class _Traits = char_traits<_CharT>,
-          class _Allocator = allocator<_CharT> >
-    class _LIBCPP_VISIBLE basic_stringstream;
+template <class _CharT, class _Traits = char_traits<_CharT> > class basic_filebuf;
+template <class _CharT, class _Traits = char_traits<_CharT> > class basic_ifstream;
+template <class _CharT, class _Traits = char_traits<_CharT> > class basic_ofstream;
+template <class _CharT, class _Traits = char_traits<_CharT> > class basic_fstream;
 
-template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_VISIBLE basic_filebuf;
-template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_VISIBLE basic_ifstream;
-template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_VISIBLE basic_ofstream;
-template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_VISIBLE basic_fstream;
-
-template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_VISIBLE istreambuf_iterator;
-template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_VISIBLE ostreambuf_iterator;
+template <class _CharT, class _Traits = char_traits<_CharT> > class istreambuf_iterator;
+template <class _CharT, class _Traits = char_traits<_CharT> > class ostreambuf_iterator;
 
 typedef basic_ios<char>              ios;
 typedef basic_ios<wchar_t>           wios;
@@ -170,20 +152,19 @@ typedef basic_ifstream<wchar_t>      wifstream;
 typedef basic_ofstream<wchar_t>      wofstream;
 typedef basic_fstream<wchar_t>       wfstream;
 
-template <class _State>             class _LIBCPP_VISIBLE fpos;
+template <class _State>             class fpos;
 typedef fpos<mbstate_t>    streampos;
 typedef fpos<mbstate_t>    wstreampos;
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 typedef fpos<mbstate_t>    u16streampos;
 typedef fpos<mbstate_t>    u32streampos;
-#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+#endif
 
 typedef long long streamoff;        // for char_traits in <string>
 
 template <class _CharT,             // for <stdexcept>
           class _Traits = char_traits<_CharT>,
-          class _Allocator = allocator<_CharT> >
-    class _LIBCPP_VISIBLE basic_string;
+          class _Allocator = allocator<_CharT> > class basic_string;
 typedef basic_string<char, char_traits<char>, allocator<char> > string;
 typedef basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstring;
 

include/iostream

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/istream

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -160,7 +160,7 @@ template <class charT, class traits, class T>
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_VISIBLE basic_istream
+class basic_istream
     : virtual public basic_ios<_CharT, _Traits>
 {
     streamsize __gc_;
@@ -176,12 +176,12 @@ public:
     explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb);
     virtual ~basic_istream();
 protected:
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_istream(basic_istream&& __rhs);
 #endif
 
     // 27.7.1.1.2 Assign/swap:
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_istream& operator=(basic_istream&& __rhs);
 #endif
     void swap(basic_istream& __rhs);
@@ -211,7 +211,6 @@ public:
     basic_istream& operator>>(void*& __p);
 
     // 27.7.1.3 Unformatted input:
-    _LIBCPP_INLINE_VISIBILITY
     streamsize gcount() const {return __gc_;}
     int_type get();
     basic_istream& get(char_type& __c);
@@ -238,7 +237,7 @@ public:
 };
 
 template <class _CharT, class _Traits>
-class _LIBCPP_VISIBLE basic_istream<_CharT, _Traits>::sentry
+class basic_istream<_CharT, _Traits>::sentry
 {
     bool __ok_;
 
@@ -249,7 +248,6 @@ public:
     explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
 //    ~sentry() = default;
 
-    _LIBCPP_INLINE_VISIBILITY
     // explicit
         operator bool() const {return __ok_;}
 };
@@ -289,7 +287,7 @@ basic_istream<_CharT, _Traits>::basic_istream(basic_streambuf<char_type, traits_
     this->init(__sb);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -309,7 +307,7 @@ basic_istream<_CharT, _Traits>::operator=(basic_istream&& __rhs)
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>::~basic_istream()
@@ -332,7 +330,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -348,7 +346,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -359,7 +357,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned int& __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -375,7 +373,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned int& __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -386,7 +384,7 @@ basic_istream<_CharT, _Traits>::operator>>(long& __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -402,7 +400,7 @@ basic_istream<_CharT, _Traits>::operator>>(long& __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -413,7 +411,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned long& __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -429,7 +427,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned long& __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -440,7 +438,7 @@ basic_istream<_CharT, _Traits>::operator>>(long long& __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -456,7 +454,7 @@ basic_istream<_CharT, _Traits>::operator>>(long long& __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -467,7 +465,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned long long& __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -483,7 +481,7 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned long long& __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -494,7 +492,7 @@ basic_istream<_CharT, _Traits>::operator>>(float& __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -510,7 +508,7 @@ basic_istream<_CharT, _Traits>::operator>>(float& __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -521,7 +519,7 @@ basic_istream<_CharT, _Traits>::operator>>(double& __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -537,7 +535,7 @@ basic_istream<_CharT, _Traits>::operator>>(double& __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -548,7 +546,7 @@ basic_istream<_CharT, _Traits>::operator>>(long double& __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -564,7 +562,7 @@ basic_istream<_CharT, _Traits>::operator>>(long double& __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -575,7 +573,7 @@ basic_istream<_CharT, _Traits>::operator>>(bool& __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -591,7 +589,7 @@ basic_istream<_CharT, _Traits>::operator>>(bool& __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -602,7 +600,7 @@ basic_istream<_CharT, _Traits>::operator>>(void*& __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -618,7 +616,7 @@ basic_istream<_CharT, _Traits>::operator>>(void*& __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -629,7 +627,7 @@ basic_istream<_CharT, _Traits>::operator>>(short& __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -658,7 +656,7 @@ basic_istream<_CharT, _Traits>::operator>>(short& __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -669,7 +667,7 @@ basic_istream<_CharT, _Traits>::operator>>(int& __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -698,7 +696,7 @@ basic_istream<_CharT, _Traits>::operator>>(int& __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -736,7 +734,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
         if (__sen)
         {
@@ -770,7 +768,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s)
     {
         __is.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __is;
 }
 
@@ -797,17 +795,10 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
         if (__sen)
         {
-#if 1
-            typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
-            if (_Traits::eq_int_type(__i, _Traits::eof()))
-                __is.setstate(ios_base::eofbit | ios_base::failbit);
-            else
-                __c = _Traits::to_char_type(__i);
-#else
             typedef istreambuf_iterator<_CharT, _Traits> _I;
             _I __i(__is);
             _I __eof;
@@ -819,7 +810,6 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c)
             }
             else
                 __is.setstate(ios_base::eofbit | ios_base::failbit);
-#endif
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
@@ -827,7 +817,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c)
     {
         __is.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __is;
 }
 
@@ -855,7 +845,7 @@ basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_typ
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this, true);
         if (__s)
         {
@@ -865,7 +855,7 @@ basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_typ
 #ifndef _LIBCPP_NO_EXCEPTIONS
                 try
                 {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
                     typedef istreambuf_iterator<char_type, traits_type> _I;
                     typedef ostreambuf_iterator<char_type, traits_type> _O;
                     _I __i(*this);
@@ -890,7 +880,7 @@ basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_typ
                     if (__c == 0)
                         this->__set_failbit_and_consider_rethrow();
                 }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
             }
             else
                 this->setstate(ios_base::failbit);
@@ -902,7 +892,7 @@ basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_typ
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -915,7 +905,7 @@ basic_istream<_CharT, _Traits>::get()
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this, true);
         if (__s)
         {
@@ -942,7 +932,7 @@ basic_istream<_CharT, _Traits>::get()
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __r;
 }
 
@@ -965,7 +955,7 @@ basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this, true);
         if (__sen)
         {
@@ -1000,7 +990,7 @@ basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -1021,7 +1011,7 @@ basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __s
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this, true);
         if (__sen)
         {
@@ -1030,7 +1020,7 @@ basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __s
 #ifndef _LIBCPP_NO_EXCEPTIONS
             try
             {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
                 typedef istreambuf_iterator<char_type, traits_type> _I;
                 typedef ostreambuf_iterator<char_type, traits_type> _O;
                 _I __i(*this);
@@ -1052,7 +1042,7 @@ basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __s
             catch (...)
             {
             }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
             if (__c == 0)
                __err |= ios_base::failbit;
             this->setstate(__err);
@@ -1064,7 +1054,7 @@ basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __s
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -1084,7 +1074,7 @@ basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_typ
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this, true);
         if (__sen)
         {
@@ -1122,7 +1112,7 @@ basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_typ
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -1142,7 +1132,7 @@ basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this, true);
         if (__sen)
         {
@@ -1182,7 +1172,7 @@ basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -1195,7 +1185,7 @@ basic_istream<_CharT, _Traits>::peek()
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this, true);
         if (__sen)
             __r = this->rdbuf()->sgetc();
@@ -1205,7 +1195,7 @@ basic_istream<_CharT, _Traits>::peek()
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __r;
 }
 
@@ -1217,7 +1207,7 @@ basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this, true);
         if (__sen)
         {
@@ -1244,7 +1234,7 @@ basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -1257,7 +1247,7 @@ basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this, true);
         if (__sen)
         {
@@ -1273,7 +1263,7 @@ basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
             case 0:
                 break;
             default:
-                __c = _STD::min(__c, __n);
+                __c = min(__c, __n);
                 for (streamsize __k = 0; __k < __c; ++__k, ++__s, ++__i)
                     *__s = *__i;
             }
@@ -1289,7 +1279,7 @@ basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __c;
 }
 
@@ -1301,7 +1291,7 @@ basic_istream<_CharT, _Traits>::putback(char_type __c)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this, true);
         if (__sen)
         {
@@ -1316,7 +1306,7 @@ basic_istream<_CharT, _Traits>::putback(char_type __c)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -1328,7 +1318,7 @@ basic_istream<_CharT, _Traits>::unget()
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this, true);
         if (__sen)
         {
@@ -1343,7 +1333,7 @@ basic_istream<_CharT, _Traits>::unget()
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -1355,7 +1345,7 @@ basic_istream<_CharT, _Traits>::sync()
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this, true);
         if (__sen)
         {
@@ -1373,7 +1363,7 @@ basic_istream<_CharT, _Traits>::sync()
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __r;
 }
 
@@ -1385,7 +1375,7 @@ basic_istream<_CharT, _Traits>::tellg()
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this, true);
         if (__sen)
             __r = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
@@ -1395,7 +1385,7 @@ basic_istream<_CharT, _Traits>::tellg()
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __r;
 }
 
@@ -1406,7 +1396,7 @@ basic_istream<_CharT, _Traits>::seekg(pos_type __pos)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this, true);
         if (__sen)
             if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1))
@@ -1417,7 +1407,7 @@ basic_istream<_CharT, _Traits>::seekg(pos_type __pos)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -1428,7 +1418,7 @@ basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this, true);
         if (__sen)
             this->rdbuf()->pubseekoff(__off, __dir, ios_base::in);
@@ -1438,7 +1428,7 @@ basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -1449,7 +1439,7 @@ ws(basic_istream<_CharT, _Traits>& __is)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
         if (__sen)
         {
@@ -1469,11 +1459,11 @@ ws(basic_istream<_CharT, _Traits>& __is)
     {
         __is.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __is;
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _CharT, class _Traits, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1484,10 +1474,10 @@ operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
     return __is;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _CharT, class _Traits>
-class _LIBCPP_VISIBLE basic_iostream
+class basic_iostream
     : public basic_istream<_CharT, _Traits>,
       public basic_ostream<_CharT, _Traits>
 {
@@ -1503,12 +1493,12 @@ public:
     explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb);
     virtual ~basic_iostream();
 protected:
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_iostream(basic_iostream&& __rhs);
 #endif
 
     // assign/swap
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_iostream& operator=(basic_iostream&& __rhs);
 #endif
     void swap(basic_iostream& __rhs);
@@ -1522,7 +1512,7 @@ basic_iostream<_CharT, _Traits>::basic_iostream(basic_streambuf<char_type, trait
 {
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1540,7 +1530,7 @@ basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs)
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _CharT, class _Traits>
 basic_iostream<_CharT, _Traits>::~basic_iostream()
@@ -1563,7 +1553,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
         if (__sen)
         {
@@ -1601,19 +1591,19 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
     {
         __is.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __is;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>& 
 getline(basic_istream<_CharT, _Traits>& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
         if (__sen)
         {
@@ -1652,24 +1642,24 @@ getline(basic_istream<_CharT, _Traits>& __is,
     {
         __is.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __is;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
+inline
+basic_istream<_CharT, _Traits>& 
 getline(basic_istream<_CharT, _Traits>& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str)
 {
     return getline(__is, __str, __is.widen('\n'));
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
+inline
+basic_istream<_CharT, _Traits>& 
 getline(basic_istream<_CharT, _Traits>&& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
 {
@@ -1677,15 +1667,15 @@ getline(basic_istream<_CharT, _Traits>&& __is,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
+inline
+basic_istream<_CharT, _Traits>& 
 getline(basic_istream<_CharT, _Traits>&& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str)
 {
     return getline(__is, __str, __is.widen('\n'));
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _CharT, class _Traits, size_t _Size>
 basic_istream<_CharT, _Traits>&
@@ -1694,7 +1684,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
         if (__sen)
         {
@@ -1730,7 +1720,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
     {
         __is.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __is;
 }
 

include/iterator

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -88,7 +88,7 @@ public:
     typedef typename iterator_traits<Iterator>::difference_type difference_type;
     typedef typename iterator_traits<Iterator>::reference       reference;
     typedef typename iterator_traits<Iterator>::pointer         pointer;
-
+    
     reverse_iterator();
     explicit reverse_iterator(Iterator x);
     template <class U> reverse_iterator(const reverse_iterator<U>& u);
@@ -151,7 +151,7 @@ public:
     typedef void                        pointer;
 
     explicit back_insert_iterator(Container& x);
-    back_insert_iterator& operator=(const typename Container::value_type& value);
+    back_insert_iterator& operator=(typename Container::const_reference value);
     back_insert_iterator& operator*();
     back_insert_iterator& operator++();
     back_insert_iterator  operator++(int);
@@ -172,7 +172,7 @@ public:
     typedef void                         pointer;
 
     explicit front_insert_iterator(Container& x);
-    front_insert_iterator& operator=(const typename Container::value_type& value);
+    front_insert_iterator& operator=(typename Container::const_reference value);
     front_insert_iterator& operator*();
     front_insert_iterator& operator++();
     front_insert_iterator  operator++(int);
@@ -194,7 +194,7 @@ public:
     typedef void                   pointer;
 
     insert_iterator(Container& x, typename Container::iterator i);
-    insert_iterator& operator=(const typename Container::value_type& value);
+    insert_iterator& operator=(typename Container::const_reference value);
     insert_iterator& operator*();
     insert_iterator& operator++();
     insert_iterator& operator++(int);
@@ -325,11 +325,11 @@ template <class T, size_t N> T* end(T (&array)[N]);
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct _LIBCPP_VISIBLE input_iterator_tag {};
-struct _LIBCPP_VISIBLE output_iterator_tag {};
-struct _LIBCPP_VISIBLE forward_iterator_tag       : public input_iterator_tag {};
-struct _LIBCPP_VISIBLE bidirectional_iterator_tag : public forward_iterator_tag {};
-struct _LIBCPP_VISIBLE random_access_iterator_tag : public bidirectional_iterator_tag {};
+struct input_iterator_tag {};
+struct output_iterator_tag {};
+struct forward_iterator_tag       : public input_iterator_tag {};
+struct bidirectional_iterator_tag : public forward_iterator_tag {};
+struct random_access_iterator_tag : public bidirectional_iterator_tag {};
 
 template <class _Tp>
 struct __has_iterator_category
@@ -372,11 +372,11 @@ struct __iterator_traits<_Iter, true>
 //    the client expects instead of failing at compile time.
 
 template <class _Iter>
-struct _LIBCPP_VISIBLE iterator_traits
+struct iterator_traits
     : __iterator_traits<_Iter, __has_iterator_category<_Iter>::value> {};
 
 template<class _Tp>
-struct _LIBCPP_VISIBLE iterator_traits<_Tp*>
+struct iterator_traits<_Tp*>
 {
     typedef ptrdiff_t difference_type;
     typedef typename remove_const<_Tp>::type value_type;
@@ -407,7 +407,7 @@ struct __is_random_access_iterator : public __has_iterator_category_convertible_
 
 template<class _Category, class _Tp, class _Distance = ptrdiff_t,
          class _Pointer = _Tp*, class _Reference = _Tp&>
-struct _LIBCPP_VISIBLE iterator
+struct iterator
 {
     typedef _Tp        value_type;
     typedef _Distance  difference_type;
@@ -482,29 +482,29 @@ distance(_InputIter __first, _InputIter __last)
 }
 
 template <class _ForwardIter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _ForwardIter
 next(_ForwardIter __x,
      typename iterator_traits<_ForwardIter>::difference_type __n = 1,
      typename enable_if<__is_forward_iterator<_ForwardIter>::value>::type* = 0)
 {
-    _STD::advance(__x, __n);
+    advance(__x, __n);
     return __x;
 }
 
 template <class _BidiretionalIter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _BidiretionalIter
 prev(_BidiretionalIter __x,
      typename iterator_traits<_BidiretionalIter>::difference_type __n = 1,
      typename enable_if<__is_bidirectional_iterator<_BidiretionalIter>::value>::type* = 0)
 {
-    _STD::advance(__x, -__n);
+    advance(__x, -__n);
     return __x;
 }
 
 template <class _Iter>
-class _LIBCPP_VISIBLE reverse_iterator
+class reverse_iterator
     : public iterator<typename iterator_traits<_Iter>::iterator_category,
                       typename iterator_traits<_Iter>::value_type,
                       typename iterator_traits<_Iter>::difference_type,
@@ -520,7 +520,7 @@ public:
     typedef typename iterator_traits<_Iter>::difference_type difference_type;
     typedef typename iterator_traits<_Iter>::reference       reference;
     typedef typename iterator_traits<_Iter>::pointer         pointer;
-
+    
     _LIBCPP_INLINE_VISIBILITY reverse_iterator() : current() {}
     _LIBCPP_INLINE_VISIBILITY explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {}
     template <class _Up> _LIBCPP_INLINE_VISIBILITY reverse_iterator(const reverse_iterator<_Up>& __u)
@@ -611,7 +611,7 @@ operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_i
 }
 
 template <class _Container>
-class _LIBCPP_VISIBLE back_insert_iterator
+class back_insert_iterator
     : public iterator<output_iterator_tag,
                       void,
                       void,
@@ -624,12 +624,12 @@ public:
     typedef _Container container_type;
 
     _LIBCPP_INLINE_VISIBILITY explicit back_insert_iterator(_Container& __x) : container(&__x) {}
-    _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(const typename _Container::value_type& __value)
+    _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(typename _Container::const_reference __value)
         {container->push_back(__value); return *this;}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(typename _Container::value_type&& __value)
         {container->push_back(_STD::move(__value)); return *this;}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator*()     {return *this;}
     _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator++()    {return *this;}
     _LIBCPP_INLINE_VISIBILITY back_insert_iterator  operator++(int) {return *this;}
@@ -644,7 +644,7 @@ back_inserter(_Container& __x)
 }
 
 template <class _Container>
-class _LIBCPP_VISIBLE front_insert_iterator
+class front_insert_iterator
     : public iterator<output_iterator_tag,
                       void,
                       void,
@@ -657,12 +657,12 @@ public:
     typedef _Container container_type;
 
     _LIBCPP_INLINE_VISIBILITY explicit front_insert_iterator(_Container& __x) : container(&__x) {}
-    _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(const typename _Container::value_type& __value)
+    _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(typename _Container::const_reference __value)
         {container->push_front(__value); return *this;}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(typename _Container::value_type&& __value)
         {container->push_front(_STD::move(__value)); return *this;}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator*()     {return *this;}
     _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator++()    {return *this;}
     _LIBCPP_INLINE_VISIBILITY front_insert_iterator  operator++(int) {return *this;}
@@ -677,7 +677,7 @@ front_inserter(_Container& __x)
 }
 
 template <class _Container>
-class _LIBCPP_VISIBLE insert_iterator
+class insert_iterator
     : public iterator<output_iterator_tag,
                       void,
                       void,
@@ -692,12 +692,12 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY insert_iterator(_Container& __x, typename _Container::iterator __i)
         : container(&__x), iter(__i) {}
-    _LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(const typename _Container::value_type& __value)
+    _LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(typename _Container::const_reference __value)
         {iter = container->insert(iter, __value); ++iter; return *this;}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     _LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(typename _Container::value_type&& __value)
         {iter = container->insert(iter, _STD::move(__value)); ++iter; return *this;}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     _LIBCPP_INLINE_VISIBILITY insert_iterator& operator*()        {return *this;}
     _LIBCPP_INLINE_VISIBILITY insert_iterator& operator++()       {return *this;}
     _LIBCPP_INLINE_VISIBILITY insert_iterator& operator++(int)    {return *this;}
@@ -713,7 +713,7 @@ inserter(_Container& __x, typename _Container::iterator __i)
 
 template <class _Tp, class _CharT = char,
           class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>
-class _LIBCPP_VISIBLE istream_iterator
+class istream_iterator
     : public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&>
 {
 public:
@@ -752,7 +752,7 @@ public:
 };
 
 template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> >
-class _LIBCPP_VISIBLE ostream_iterator
+class ostream_iterator
     : public iterator<output_iterator_tag, void, void, void, void>
 {
 public:
@@ -781,7 +781,7 @@ public:
 };
 
 template<class _CharT, class _Traits>
-class _LIBCPP_VISIBLE istreambuf_iterator
+class istreambuf_iterator
     : public iterator<input_iterator_tag, _CharT,
                       typename _Traits::off_type, _CharT*,
                       _CharT>
@@ -806,7 +806,6 @@ private:
         _LIBCPP_INLINE_VISIBILITY char_type operator*() const {return __keep_;}
     };
 
-    _LIBCPP_INLINE_VISIBILITY
     void __test_for_eof()
     {
         if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof()))
@@ -821,7 +820,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(const __proxy& __p) throw()
         : __sbuf_(__p.__sbuf_) {}
 
-    _LIBCPP_INLINE_VISIBILITY _CharT     operator*() const {return __sbuf_->sgetc();}
+    _LIBCPP_INLINE_VISIBILITY _CharT               operator*() const {return __sbuf_->sgetc();}
     _LIBCPP_INLINE_VISIBILITY char_type* operator->() const {return nullptr;}
     _LIBCPP_INLINE_VISIBILITY istreambuf_iterator& operator++()
         {
@@ -853,7 +852,7 @@ bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a,
                 {return !__a.equal(__b);}
 
 template <class _CharT, class _Traits>
-class _LIBCPP_VISIBLE ostreambuf_iterator
+class ostreambuf_iterator
     : public iterator<output_iterator_tag, void, void, void, void>
 {
 public:
@@ -881,7 +880,7 @@ public:
 };
 
 template <class _Iter>
-class _LIBCPP_VISIBLE move_iterator
+class move_iterator
 {
 private:
     _Iter __i;
@@ -891,24 +890,19 @@ public:
     typedef typename iterator_traits<iterator_type>::value_type value_type;
     typedef typename iterator_traits<iterator_type>::difference_type difference_type;
     typedef typename iterator_traits<iterator_type>::pointer pointer;
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     typedef value_type&& reference;
 #else
     typedef typename iterator_traits<iterator_type>::reference reference;
 #endif
-
+    
     _LIBCPP_INLINE_VISIBILITY move_iterator() : __i() {}
     _LIBCPP_INLINE_VISIBILITY explicit move_iterator(_Iter __x) : __i(__x) {}
     template <class _Up> _LIBCPP_INLINE_VISIBILITY move_iterator(const move_iterator<_Up>& __u)
         : __i(__u.base()) {}
     _LIBCPP_INLINE_VISIBILITY _Iter base() const {return __i;}
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const {
-      return static_cast<reference>(*__i);
-    }
-    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const {
-      typename iterator_traits<iterator_type>::reference __ref = *__i;
-      return &__ref;
-    }
+    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return *__i;}
+    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const {return &(operator*());}
     _LIBCPP_INLINE_VISIBILITY move_iterator& operator++() {++__i; return *this;}
     _LIBCPP_INLINE_VISIBILITY move_iterator  operator++(int)
         {move_iterator __tmp(*this); ++__i; return __tmp;}
@@ -924,9 +918,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY move_iterator& operator-=(difference_type __n)
         {__i -= __n; return *this;}
     _LIBCPP_INLINE_VISIBILITY reference         operator[](difference_type __n) const
-    {
-      return static_cast<reference>(__i[__n]);
-    }
+        {return __i[__n];}
 };
 
 template <class _Iter1, class _Iter2>
@@ -1007,35 +999,35 @@ template <class _Iter> class __wrap_iter;
 
 template <class _Iter1, class _Iter2>
 bool
-operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
 
 template <class _Iter1, class _Iter2>
 bool
-operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
 
 template <class _Iter1, class _Iter2>
 bool
-operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
 
 template <class _Iter1, class _Iter2>
 bool
-operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
 
 template <class _Iter1, class _Iter2>
 bool
-operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
 
 template <class _Iter1, class _Iter2>
 bool
-operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
 
 template <class _Iter1, class _Iter2>
 typename __wrap_iter<_Iter1>::difference_type
-operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
 
 template <class _Iter>
 __wrap_iter<_Iter>
-operator+(typename __wrap_iter<_Iter>::difference_type, const __wrap_iter<_Iter>&) _NOEXCEPT;
+operator+(typename __wrap_iter<_Iter>::difference_type, const __wrap_iter<_Iter>&);
 
 template <class _I, class _O> _O copy(_I, _I, _O);
 template <class _B1, class _B2> _B2 copy_backward(_B1, _B1, _B2);
@@ -1045,7 +1037,7 @@ template <class _B1, class _B2> _B2 move_backward(_B1, _B1, _B2);
 template <class _Tp>
 typename enable_if
 <
-    is_trivially_copy_assignable<_Tp>::value,
+    has_trivial_copy_assign<_Tp>::value,
     _Tp*
 >::type
 __unwrap_iter(__wrap_iter<_Tp*>);
@@ -1063,33 +1055,33 @@ public:
 private:
     iterator_type __i;
 public:
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter() {}
     template <class _Up> _LIBCPP_INLINE_VISIBILITY __wrap_iter(const __wrap_iter<_Up>& __u,
-        typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = 0) _NOEXCEPT
+        typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = 0)
         : __i(__u.base()) {}
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT {return *__i;}
-    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const _NOEXCEPT {return &(operator*());}
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator++() _NOEXCEPT {++__i; return *this;}
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator++(int) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return *__i;}
+    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const {return &(operator*());}
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator++() {++__i; return *this;}
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator++(int)
         {__wrap_iter __tmp(*this); ++__i; return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator--() _NOEXCEPT {--__i; return *this;}
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator--(int) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator--() {--__i; return *this;}
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator--(int)
         {__wrap_iter __tmp(*this); --__i; return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator+ (difference_type __n) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator+ (difference_type __n) const
         {return __wrap_iter(__i + __n);}
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator+=(difference_type __n) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator+=(difference_type __n)
         {__i += __n; return *this;}
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator- (difference_type __n) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator- (difference_type __n) const
         {return __wrap_iter(__i - __n);}
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator-=(difference_type __n) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator-=(difference_type __n)
         {__i -= __n; return *this;}
-    _LIBCPP_INLINE_VISIBILITY reference        operator[](difference_type __n) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY reference        operator[](difference_type __n) const
         {return __i[__n];}
 
-    _LIBCPP_INLINE_VISIBILITY iterator_type base() const _NOEXCEPT {return __i;}
+    _LIBCPP_INLINE_VISIBILITY iterator_type base() const {return __i;}
 
 private:
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter(iterator_type __x) _NOEXCEPT : __i(__x) {}
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter(iterator_type __x) : __i(__x) {}
 
     template <class _Up> friend class __wrap_iter;
     template <class _CharT, class _Traits, class _Alloc> friend class basic_string;
@@ -1098,42 +1090,42 @@ private:
     template <class _Iter1, class _Iter2>
     friend
     bool
-    operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
-
+    operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
+    
     template <class _Iter1, class _Iter2>
     friend
     bool
-    operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
-
+    operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
+    
     template <class _Iter1, class _Iter2>
     friend
     bool
-    operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
-
+    operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
+    
     template <class _Iter1, class _Iter2>
     friend
     bool
-    operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
-
+    operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
+    
     template <class _Iter1, class _Iter2>
     friend
     bool
-    operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
-
+    operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
+    
     template <class _Iter1, class _Iter2>
     friend
     bool
-    operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
-
+    operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
+    
     template <class _Iter1, class _Iter2>
     friend
     typename __wrap_iter<_Iter1>::difference_type
-    operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
-
+    operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);
+    
     template <class _Iter1>
     friend
     __wrap_iter<_Iter1>
-    operator+(typename __wrap_iter<_Iter1>::difference_type, const __wrap_iter<_Iter1>&) _NOEXCEPT;
+    operator+(typename __wrap_iter<_Iter1>::difference_type, const __wrap_iter<_Iter1>&);
 
     template <class _I, class _O> friend _O copy(_I, _I, _O);
     template <class _B1, class _B2> friend _B2 copy_backward(_B1, _B1, _B2);
@@ -1144,7 +1136,7 @@ private:
     friend
     typename enable_if
     <
-        is_trivially_copy_assignable<_Tp>::value,
+        has_trivial_copy_assign<_Tp>::value,
         _Tp*
     >::type
     __unwrap_iter(__wrap_iter<_Tp*>);
@@ -1153,7 +1145,7 @@ private:
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
     return __x.base() == __y.base();
 }
@@ -1161,7 +1153,7 @@ operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEX
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
     return __x.base() < __y.base();
 }
@@ -1169,7 +1161,7 @@ operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXC
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
     return __x.base() != __y.base();
 }
@@ -1177,7 +1169,7 @@ operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEX
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
     return __x.base() > __y.base();
 }
@@ -1185,7 +1177,7 @@ operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXC
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
     return __x.base() >= __y.base();
 }
@@ -1193,7 +1185,7 @@ operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEX
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
     return __x.base() <= __y.base();
 }
@@ -1201,7 +1193,7 @@ operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEX
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __wrap_iter<_Iter1>::difference_type
-operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
     return __x.base() - __y.base();
 }
@@ -1210,7 +1202,7 @@ template <class _Iter>
 inline _LIBCPP_INLINE_VISIBILITY
 __wrap_iter<_Iter>
 operator+(typename __wrap_iter<_Iter>::difference_type __n,
-          const __wrap_iter<_Iter>& __x) _NOEXCEPT
+          const __wrap_iter<_Iter>& __x)
 {
     return __wrap_iter<_Iter>(__x.base() + __n);
 }
@@ -1268,7 +1260,7 @@ private:
     iterator_type __i;
     __debug_iter* __next;
     __container_type* __cont;
-
+    
 public:
     _LIBCPP_INLINE_VISIBILITY __debug_iter() : __next(0), __cont(0) {}
     _LIBCPP_INLINE_VISIBILITY __debug_iter(const __debug_iter& __x)
@@ -1305,7 +1297,7 @@ private:
     void __remove_owner();
     static void __remove_all(__container_type* __c);
     static void swap(__container_type* __x, __container_type* __y);
-
+    
     _LIBCPP_INLINE_VISIBILITY bool __is_deref() const
         {return __is_deref(__is_random_access_iterator<iterator_type>());}
     bool __is_deref(false_type) const;
@@ -1335,37 +1327,37 @@ private:
     friend
     bool
     operator==(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
-
+    
     template <class _Cp, class _Iter1, class _Iter2>
     friend
     bool
     operator<(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
-
+    
     template <class _Cp, class _Iter1, class _Iter2>
     friend
     bool
     operator!=(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
-
+    
     template <class _Cp, class _Iter1, class _Iter2>
     friend
     bool
     operator>(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
-
+    
     template <class _Cp, class _Iter1, class _Iter2>
     friend
     bool
     operator>=(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
-
+    
     template <class _Cp, class _Iter1, class _Iter2>
     friend
     bool
     operator<=(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
-
+    
     template <class _Cp, class _Iter1, class _Iter2>
     friend
     typename __debug_iter<_Cp, _Iter1>::difference_type
     operator-(const __debug_iter<_Cp, _Iter1>&, const __debug_iter<_Cp, _Iter2>&);
-
+    
     template <class _Cp, class _Iter1>
     friend
     __debug_iter<_Cp, _Iter1>
@@ -1384,7 +1376,7 @@ __debug_iter<_Container, _Iter>::operator=(const __debug_iter& __x)
     }
     return *this;
 }
-
+    
 template <class _Container, class _Iter>
 void
 __debug_iter<_Container, _Iter>::__set_owner(const __container_type* __c)
@@ -1623,10 +1615,10 @@ operator+(typename __debug_iter<_Container, _Iter>::difference_type __n,
 
 #endif  // _LIBCPP_DEBUG
 
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
+#ifdef _LIBCPP_MOVE
 
 template <class _C>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 auto
 begin(_C& __c) -> decltype(__c.begin())
 {
@@ -1634,7 +1626,7 @@ begin(_C& __c) -> decltype(__c.begin())
 }
 
 template <class _C>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 auto
 begin(const _C& __c) -> decltype(__c.begin())
 {
@@ -1642,7 +1634,7 @@ begin(const _C& __c) -> decltype(__c.begin())
 }
 
 template <class _C>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 auto
 end(_C& __c) -> decltype(__c.end())
 {
@@ -1650,17 +1642,17 @@ end(_C& __c) -> decltype(__c.end())
 }
 
 template <class _C>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 auto
 end(const _C& __c) -> decltype(__c.end())
 {
     return __c.end();
 }
 
-#else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
+#else
 
 template <class _C>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename _C::iterator
 begin(_C& __c)
 {
@@ -1668,7 +1660,7 @@ begin(_C& __c)
 }
 
 template <class _C>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename _C::const_iterator
 begin(const _C& __c)
 {
@@ -1676,7 +1668,7 @@ begin(const _C& __c)
 }
 
 template <class _C>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename _C::iterator
 end(_C& __c)
 {
@@ -1684,17 +1676,17 @@ end(_C& __c)
 }
 
 template <class _C>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename _C::const_iterator
 end(const _C& __c)
 {
     return __c.end();
 }
 
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
+#endif
 
 template <class _T, size_t _N>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _T*
 begin(_T (&__array)[_N])
 {
@@ -1702,7 +1694,7 @@ begin(_T (&__array)[_N])
 }
 
 template <class _T, size_t _N>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _T*
 end(_T (&__array)[_N])
 {

include/limits

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -22,9 +22,9 @@ class numeric_limits
 {
 public:
     static const bool is_specialized = false;
-    static T min() noexcept;
-    static T max() noexcept;
-    static T lowest() noexcept;
+    static T min() throw();
+    static T max() throw();
+    static T lowest() throw();
 
     static const int  digits = 0;
     static const int  digits10 = 0;
@@ -33,8 +33,8 @@ public:
     static const bool is_integer = false;
     static const bool is_exact = false;
     static const int  radix = 0;
-    static T epsilon() noexcept;
-    static T round_error() noexcept;
+    static T epsilon() throw();
+    static T round_error() throw();
 
     static const int  min_exponent = 0;
     static const int  min_exponent10 = 0;
@@ -46,10 +46,10 @@ public:
     static const bool has_signaling_NaN = false;
     static const float_denorm_style has_denorm = denorm_absent;
     static const bool has_denorm_loss = false;
-    static T infinity() noexcept;
-    static T quiet_NaN() noexcept;
-    static T signaling_NaN() noexcept;
-    static T denorm_min() noexcept;
+    static T infinity() throw();
+    static T quiet_NaN() throw();
+    static T signaling_NaN() throw();
+    static T denorm_min() throw();
 
     static const bool is_iec559 = false;
     static const bool is_bounded = false;
@@ -132,9 +132,9 @@ protected:
     typedef _Tp type;
 
     static const bool is_specialized = false;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return type();}
 
     static const int  digits = 0;
     static const int  digits10 = 0;
@@ -143,8 +143,8 @@ protected:
     static const bool is_integer = false;
     static const bool is_exact = false;
     static const int  radix = 0;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return type();}
 
     static const int  min_exponent = 0;
     static const int  min_exponent10 = 0;
@@ -156,10 +156,10 @@ protected:
     static const bool has_signaling_NaN = false;
     static const float_denorm_style has_denorm = denorm_absent;
     static const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return type();}
 
     static const bool is_iec559 = false;
     static const bool is_bounded = false;
@@ -196,15 +196,15 @@ protected:
     static const int  max_digits10 = 0;
     static const type __min = __libcpp_compute_min<type, digits, is_signed>::value;
     static const type __max = is_signed ? type(type(~0) ^ __min) : type(~0);
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __min;}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __max;}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return min();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __min;}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __max;}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return min();}
 
     static const bool is_integer = true;
     static const bool is_exact = true;
     static const int  radix = 2;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return type(0);}
 
     static const int  min_exponent = 0;
     static const int  min_exponent10 = 0;
@@ -216,10 +216,10 @@ protected:
     static const bool has_signaling_NaN = false;
     static const float_denorm_style has_denorm = denorm_absent;
     static const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return type(0);}
 
     static const bool is_iec559 = false;
     static const bool is_bounded = true;
@@ -248,15 +248,15 @@ protected:
     static const int  max_digits10 = 0;
     static const type __min = false;
     static const type __max = true;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __min;}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __max;}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return min();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __min;}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __max;}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return min();}
 
     static const bool is_integer = true;
     static const bool is_exact = true;
     static const int  radix = 2;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return type(0);}
 
     static const int  min_exponent = 0;
     static const int  min_exponent10 = 0;
@@ -268,10 +268,10 @@ protected:
     static const bool has_signaling_NaN = false;
     static const float_denorm_style has_denorm = denorm_absent;
     static const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return type(0);}
 
     static const bool is_iec559 = false;
     static const bool is_bounded = true;
@@ -294,15 +294,15 @@ protected:
     static const int  digits = __FLT_MANT_DIG__;
     static const int  digits10 = __FLT_DIG__;
     static const int  max_digits10 = 2+(digits * 30103)/100000;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __FLT_MIN__;}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __FLT_MAX__;}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return -max();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __FLT_MIN__;}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __FLT_MAX__;}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return -max();}
 
     static const bool is_integer = false;
     static const bool is_exact = false;
     static const int  radix = __FLT_RADIX__;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __FLT_EPSILON__;}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return 0.5F;}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __FLT_EPSILON__;}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return 0.5F;}
 
     static const int  min_exponent = __FLT_MIN_EXP__;
     static const int  min_exponent10 = __FLT_MIN_10_EXP__;
@@ -314,10 +314,10 @@ protected:
     static const bool has_signaling_NaN = true;
     static const float_denorm_style has_denorm = denorm_present;
     static const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __builtin_huge_valf();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __builtin_nanf("");}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __builtin_nansf("");}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __FLT_DENORM_MIN__;}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __builtin_huge_valf();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __builtin_nanf("");}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __builtin_nansf("");}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __FLT_DENORM_MIN__;}
 
     static const bool is_iec559 = true;
     static const bool is_bounded = true;
@@ -340,15 +340,15 @@ protected:
     static const int  digits = __DBL_MANT_DIG__;
     static const int  digits10 = __DBL_DIG__;
     static const int  max_digits10 = 2+(digits * 30103)/100000;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __DBL_MIN__;}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __DBL_MAX__;}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return -max();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __DBL_MIN__;}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __DBL_MAX__;}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return -max();}
 
     static const bool is_integer = false;
     static const bool is_exact = false;
     static const int  radix = __FLT_RADIX__;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __DBL_EPSILON__;}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return 0.5;}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __DBL_EPSILON__;}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return 0.5;}
 
     static const int  min_exponent = __DBL_MIN_EXP__;
     static const int  min_exponent10 = __DBL_MIN_10_EXP__;
@@ -360,10 +360,10 @@ protected:
     static const bool has_signaling_NaN = true;
     static const float_denorm_style has_denorm = denorm_present;
     static const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __builtin_huge_val();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __builtin_nan("");}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __builtin_nans("");}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __DBL_DENORM_MIN__;}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __builtin_huge_val();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __builtin_nan("");}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __builtin_nans("");}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __DBL_DENORM_MIN__;}
 
     static const bool is_iec559 = true;
     static const bool is_bounded = true;
@@ -386,15 +386,15 @@ protected:
     static const int  digits = __LDBL_MANT_DIG__;
     static const int  digits10 = __LDBL_DIG__;
     static const int  max_digits10 = 2+(digits * 30103)/100000;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __LDBL_MIN__;}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __LDBL_MAX__;}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return -max();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __LDBL_MIN__;}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __LDBL_MAX__;}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return -max();}
 
     static const bool is_integer = false;
     static const bool is_exact = false;
     static const int  radix = __FLT_RADIX__;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __LDBL_EPSILON__;}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return 0.5;}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __LDBL_EPSILON__;}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return 0.5;}
 
     static const int  min_exponent = __LDBL_MIN_EXP__;
     static const int  min_exponent10 = __LDBL_MIN_10_EXP__;
@@ -406,10 +406,10 @@ protected:
     static const bool has_signaling_NaN = true;
     static const float_denorm_style has_denorm = denorm_present;
     static const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __builtin_huge_vall();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __builtin_nanl("");}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __builtin_nansl("");}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __LDBL_DENORM_MIN__;}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __builtin_huge_vall();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __builtin_nanl("");}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __builtin_nansl("");}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __LDBL_DENORM_MIN__;}
 
 #if (defined(__ppc__) || defined(__ppc64__))
     static const bool is_iec559 = false;
@@ -425,16 +425,16 @@ protected:
 };
 
 template <class _Tp>
-class _LIBCPP_VISIBLE numeric_limits
+class numeric_limits
     : private __libcpp_numeric_limits<typename remove_cv<_Tp>::type>
 {
     typedef __libcpp_numeric_limits<typename remove_cv<_Tp>::type> __base;
     typedef typename __base::type type;
 public:
     static const bool is_specialized = __base::is_specialized;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __base::min();}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __base::max();}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return __base::lowest();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __base::min();}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __base::max();}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return __base::lowest();}
 
     static const int  digits = __base::digits;
     static const int  digits10 = __base::digits10;
@@ -443,8 +443,8 @@ public:
     static const bool is_integer = __base::is_integer;
     static const bool is_exact = __base::is_exact;
     static const int  radix = __base::radix;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __base::epsilon();}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return __base::round_error();}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __base::epsilon();}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return __base::round_error();}
 
     static const int  min_exponent = __base::min_exponent;
     static const int  min_exponent10 = __base::min_exponent10;
@@ -456,10 +456,10 @@ public:
     static const bool has_signaling_NaN = __base::has_signaling_NaN;
     static const float_denorm_style has_denorm = __base::has_denorm;
     static const bool has_denorm_loss = __base::has_denorm_loss;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __base::infinity();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __base::denorm_min();}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __base::infinity();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __base::quiet_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __base::signaling_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __base::denorm_min();}
 
     static const bool is_iec559 = __base::is_iec559;
     static const bool is_bounded = __base::is_bounded;
@@ -471,16 +471,16 @@ public:
 };
 
 template <class _Tp>
-class _LIBCPP_VISIBLE numeric_limits<const _Tp>
+class numeric_limits<const _Tp>
     : private numeric_limits<_Tp>
 {
     typedef numeric_limits<_Tp> __base;
     typedef _Tp type;
 public:
     static const bool is_specialized = __base::is_specialized;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __base::min();}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __base::max();}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return __base::lowest();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __base::min();}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __base::max();}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return __base::lowest();}
 
     static const int  digits = __base::digits;
     static const int  digits10 = __base::digits10;
@@ -489,8 +489,8 @@ public:
     static const bool is_integer = __base::is_integer;
     static const bool is_exact = __base::is_exact;
     static const int  radix = __base::radix;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __base::epsilon();}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return __base::round_error();}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __base::epsilon();}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return __base::round_error();}
 
     static const int  min_exponent = __base::min_exponent;
     static const int  min_exponent10 = __base::min_exponent10;
@@ -502,10 +502,10 @@ public:
     static const bool has_signaling_NaN = __base::has_signaling_NaN;
     static const float_denorm_style has_denorm = __base::has_denorm;
     static const bool has_denorm_loss = __base::has_denorm_loss;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __base::infinity();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __base::denorm_min();}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __base::infinity();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __base::quiet_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __base::signaling_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __base::denorm_min();}
 
     static const bool is_iec559 = __base::is_iec559;
     static const bool is_bounded = __base::is_bounded;
@@ -517,16 +517,16 @@ public:
 };
 
 template <class _Tp>
-class _LIBCPP_VISIBLE numeric_limits<volatile _Tp>
+class numeric_limits<volatile _Tp>
     : private numeric_limits<_Tp>
 {
     typedef numeric_limits<_Tp> __base;
     typedef _Tp type;
 public:
     static const bool is_specialized = __base::is_specialized;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __base::min();}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __base::max();}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return __base::lowest();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __base::min();}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __base::max();}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return __base::lowest();}
 
     static const int  digits = __base::digits;
     static const int  digits10 = __base::digits10;
@@ -535,8 +535,8 @@ public:
     static const bool is_integer = __base::is_integer;
     static const bool is_exact = __base::is_exact;
     static const int  radix = __base::radix;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __base::epsilon();}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return __base::round_error();}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __base::epsilon();}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return __base::round_error();}
 
     static const int  min_exponent = __base::min_exponent;
     static const int  min_exponent10 = __base::min_exponent10;
@@ -548,10 +548,10 @@ public:
     static const bool has_signaling_NaN = __base::has_signaling_NaN;
     static const float_denorm_style has_denorm = __base::has_denorm;
     static const bool has_denorm_loss = __base::has_denorm_loss;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __base::infinity();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __base::denorm_min();}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __base::infinity();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __base::quiet_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __base::signaling_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __base::denorm_min();}
 
     static const bool is_iec559 = __base::is_iec559;
     static const bool is_bounded = __base::is_bounded;
@@ -563,16 +563,16 @@ public:
 };
 
 template <class _Tp>
-class _LIBCPP_VISIBLE numeric_limits<const volatile _Tp>
+class numeric_limits<const volatile _Tp>
     : private numeric_limits<_Tp>
 {
     typedef numeric_limits<_Tp> __base;
     typedef _Tp type;
 public:
     static const bool is_specialized = __base::is_specialized;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __base::min();}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __base::max();}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return __base::lowest();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __base::min();}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __base::max();}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return __base::lowest();}
 
     static const int  digits = __base::digits;
     static const int  digits10 = __base::digits10;
@@ -581,8 +581,8 @@ public:
     static const bool is_integer = __base::is_integer;
     static const bool is_exact = __base::is_exact;
     static const int  radix = __base::radix;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __base::epsilon();}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return __base::round_error();}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __base::epsilon();}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return __base::round_error();}
 
     static const int  min_exponent = __base::min_exponent;
     static const int  min_exponent10 = __base::min_exponent10;
@@ -594,10 +594,10 @@ public:
     static const bool has_signaling_NaN = __base::has_signaling_NaN;
     static const float_denorm_style has_denorm = __base::has_denorm;
     static const bool has_denorm_loss = __base::has_denorm_loss;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __base::infinity();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __base::denorm_min();}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __base::infinity();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __base::quiet_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __base::signaling_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __base::denorm_min();}
 
     static const bool is_iec559 = __base::is_iec559;
     static const bool is_bounded = __base::is_bounded;

include/locale

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -36,8 +36,8 @@ public:
         all = collate | ctype | monetary | numeric | time | messages;
 
     // construct/copy/destroy:
-    locale() noexcept;
-    locale(const locale& other) noexcept;
+    locale() throw();
+    locale(const locale& other) throw();
     explicit locale(const char* std_name);
     explicit locale(const string& std_name);
     locale(const locale& other, const char* std_name, category);
@@ -45,9 +45,9 @@ public:
     template <class Facet> locale(const locale& other, Facet* f);
     locale(const locale& other, const locale& one, category);
 
-    ~locale(); // not virtual
+    ~locale() throw(); // not virtual
 
-    const locale& operator=(const locale& other) noexcept;
+    const locale& operator=(const locale& other) throw();
 
     template <class Facet> locale combine(const locale& other) const;
 
@@ -65,7 +65,7 @@ public:
 };
 
 template <class Facet> const Facet& use_facet(const locale&);
-template <class Facet> bool has_facet(const locale&) noexcept;
+template <class Facet> bool has_facet(const locale&) throw();
 
 // 22.3.3, convenience interfaces:
 template <class charT> bool isspace (charT c, const locale& loc);
@@ -198,7 +198,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if __APPLE__
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 int
 __nolocale_sprintf(char* __restrict __str,
                    const char* __restrict __format, _Tp __v)
@@ -207,7 +207,7 @@ __nolocale_sprintf(char* __restrict __str,
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 int
 __nolocale_snprintf(char* __restrict __str, size_t __size,
                     const char* __restrict __format, _Tp __v)
@@ -216,7 +216,7 @@ __nolocale_snprintf(char* __restrict __str, size_t __size,
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 int
 __nolocale_snprintf(char* __restrict __str, size_t __size,
                     const char* __restrict __format, int __prec, _Tp __v)
@@ -225,7 +225,7 @@ __nolocale_snprintf(char* __restrict __str, size_t __size,
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 int
 __nolocale_asprintf(char** __ret, const char* __restrict __format, _Tp __v)
 {
@@ -233,7 +233,7 @@ __nolocale_asprintf(char** __ret, const char* __restrict __format, _Tp __v)
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 int
 __nolocale_asprintf(char** __ret, const char* __restrict __format, int __prec,
                                                                         _Tp __v)
@@ -242,7 +242,7 @@ __nolocale_asprintf(char** __ret, const char* __restrict __format, int __prec,
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 int
 __nolocale_sscanf(const char* __restrict __str,
                   const char* __restrict __format, _Tp* __v)
@@ -250,26 +250,22 @@ __nolocale_sscanf(const char* __restrict __str,
     return sscanf_l(__str, 0, __format, __v);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 int
 __nolocale_isxdigit(int __c)
 {
     return isxdigit_l(__c, 0);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 int
 __nolocale_isdigit(int __c)
 {
     return isdigit_l(__c, 0);
 }
 
-#else  // __APPLE__
-inline
-#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
-_LIBCPP_INLINE_VISIBILITY
-#endif
-int
+#else  /* !__APPLE__ */
+inline int
 __nolocale_sprintf(char* __restrict __str,
                    const char* __restrict __format, ...)
 {
@@ -279,11 +275,7 @@ __nolocale_sprintf(char* __restrict __str,
     va_end(__ap);
     return __result;
 }
-inline
-#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
-_LIBCPP_INLINE_VISIBILITY
-#endif
-int
+inline int
 __nolocale_snprintf(char* __restrict __str, size_t __size,
                     const char* __restrict __format, ...)
 {
@@ -293,11 +285,7 @@ __nolocale_snprintf(char* __restrict __str, size_t __size,
     va_end(__ap);
     return __result;
 }
-inline
-#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
-_LIBCPP_INLINE_VISIBILITY
-#endif
-int
+inline int
 __nolocale_asprintf(char** __ret,
                     const char* __restrict __format, ...)
 {
@@ -307,11 +295,7 @@ __nolocale_asprintf(char** __ret,
     va_end(__ap);
     return __result;
 }
-inline
-#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
-_LIBCPP_INLINE_VISIBILITY
-#endif
-int
+inline int
 __nolocale_sscanf(const char* __restrict __str,
                   const char* __restrict __format, ...)
 {
@@ -321,20 +305,17 @@ __nolocale_sscanf(const char* __restrict __str,
     va_end(__ap);
     return __result;
 }
-inline _LIBCPP_INLINE_VISIBILITY
-int
+inline int
 __nolocale_isxdigit(int __c)
 {
     return isxdigit(__c);
 }
-
-inline _LIBCPP_INLINE_VISIBILITY
-int
+inline int
 __nolocale_isdigit(int __c)
 {
     return isdigit(__c);
 }
-#endif  // __APPLE__
+#endif  /* __APPLE__ */
 
 // __scan_keyword
 // Scans [__b, __e) until a match is found in the basic_strings range
@@ -475,6 +456,7 @@ struct __num_get_base
 void __check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end,
                       ios_base::iostate& __err);
 
+
 template <class _CharT>
 struct __num_get
     : protected __num_get_base
@@ -522,12 +504,6 @@ __num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*&
                   unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
                   unsigned* __g, unsigned*& __g_end, _CharT* __atoms)
 {
-    if (__a_end == __a && (__ct == __atoms[24] || __ct == __atoms[25]))
-    {
-        *__a_end++ = __ct == __atoms[24] ? '+' : '-';
-        __dc = 0;
-        return 0;
-    }
     if (__ct == __thousands_sep && __grouping.size() != 0)
     {
         if (__g_end-__g < __num_get_buf_sz)
@@ -538,28 +514,22 @@ __num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*&
         return 0;
     }
     ptrdiff_t __f = find(__atoms, __atoms + 26, __ct) - __atoms;
-    if (__f >= 24)
+    if (__f >= 26)
         return -1;
+    if (__a_end-__a < __num_get_buf_sz - 1)
+        *__a_end++ = __src[__f];
     switch (__base)
     {
     case 8:
     case 10:
         if (__f >= __base)
-            return -1;
-        break;
-    case 16:
-        if (__f < 22)
-            break;
-        if (__a_end != __a && __a_end - __a <= 2 && __a_end[-1] == '0')
-        {
-            __dc = 0;
-            *__a_end++ = __src[__f];
             return 0;
-        }
-        return -1;
+        break;
+    default:
+        if (__f >= 22)
+            return 0;
+        break;
     }
-    if (__a_end-__a < __num_get_buf_sz - 1)
-        *__a_end++ = __src[__f];
     ++__dc;
     return 0;
 }
@@ -615,7 +585,7 @@ extern template class __num_get<char>;
 extern template class __num_get<wchar_t>;
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_VISIBLE num_get
+class num_get
     : public locale::facet,
       private __num_get<_CharT>
 {
@@ -707,7 +677,6 @@ public:
     static locale::id id;
 
 protected:
-    _LIBCPP_ALWAYS_INLINE
     ~num_get() {}
 
     virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
@@ -745,27 +714,22 @@ __num_get_signed_integral(const char* __a, const char* __a_end,
 {
     if (__a != __a_end)
     {
-        int __save_errno = errno;
-        errno = 0;
         char *__p2;
         long long __ll = strtoll_l(__a, &__p2, __base, 0);
-        int __current_errno = errno;
-        if (__current_errno == 0)
-            errno = __save_errno;
         if (__p2 != __a_end)
         {
             __err = ios_base::failbit;
             return 0;
         }
-        else if (__current_errno == ERANGE         ||
-                 __ll < numeric_limits<_Tp>::min() ||
-                 numeric_limits<_Tp>::max() < __ll)
+        else if (__ll > numeric_limits<_Tp>::max())
         {
             __err = ios_base::failbit;
-            if (__ll > 0)
-                return numeric_limits<_Tp>::max();
-            else
-                return numeric_limits<_Tp>::min();
+            return numeric_limits<_Tp>::max();
+        }
+        else if (__ll < numeric_limits<_Tp>::min())
+        {
+            __err = ios_base::failbit;
+            return numeric_limits<_Tp>::min();
         }
         return static_cast<_Tp>(__ll);
     }
@@ -780,25 +744,14 @@ __num_get_unsigned_integral(const char* __a, const char* __a_end,
 {
     if (__a != __a_end)
     {
-        if (*__a == '-')
-        {
-            __err = ios_base::failbit;
-            return 0;
-        }
-        int __save_errno = errno;
-        errno = 0;
         char *__p2;
         unsigned long long __ll = strtoull_l(__a, &__p2, __base, 0);
-        int __current_errno = errno;
-        if (__current_errno == 0)
-            errno = __save_errno;
         if (__p2 != __a_end)
         {
             __err = ios_base::failbit;
             return 0;
         }
-        else if (__current_errno == ERANGE ||
-                 numeric_limits<_Tp>::max() < __ll)
+        else if (__ll > numeric_limits<_Tp>::max())
         {
             __err = ios_base::failbit;
             return numeric_limits<_Tp>::max();
@@ -883,7 +836,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     unsigned* __g_end = __g;
     unsigned __dc = 0;
     for (; __b != __e; ++__b)
-        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
+        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, 
                                     __thousands_sep, __grouping, __g, __g_end,
                                     __atoms))
             break;
@@ -918,8 +871,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     unsigned* __g_end = __g;
     unsigned __dc = 0;
     for (; __b != __e; ++__b)
-        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
-                                    __thousands_sep, __grouping, __g, __g_end,
+        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, 
+                                    __thousands_sep, __grouping, __g, __g_end, 
                                     __atoms))
             break;
     if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz)
@@ -953,7 +906,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     unsigned* __g_end = __g;
     unsigned __dc = 0;
     for (; __b != __e; ++__b)
-        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
+        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, 
                                     __thousands_sep, __grouping, __g, __g_end,
                                     __atoms))
             break;
@@ -988,7 +941,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     unsigned* __g_end = __g;
     unsigned __dc = 0;
     for (; __b != __e; ++__b)
-        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
+        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, 
                                     __thousands_sep, __grouping, __g, __g_end,
                                     __atoms))
             break;
@@ -1023,7 +976,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     unsigned* __g_end = __g;
     unsigned __dc = 0;
     for (; __b != __e; ++__b)
-        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
+        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, 
                                     __thousands_sep, __grouping, __g, __g_end,
                                     __atoms))
             break;
@@ -1058,7 +1011,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     unsigned* __g_end = __g;
     unsigned __dc = 0;
     for (; __b != __e; ++__b)
-        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
+        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, 
                                     __thousands_sep, __grouping, __g, __g_end,
                                     __atoms))
             break;
@@ -1086,8 +1039,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     char_type __atoms[32];
     char_type __decimal_point;
     char_type __thousands_sep;
-    string __grouping = this->__stage2_float_prep(__iob, __atoms,
-                                                  __decimal_point,
+    string __grouping = this->__stage2_float_prep(__iob, __atoms, 
+                                                  __decimal_point, 
                                                   __thousands_sep);
     char __a[__num_get_base::__num_get_buf_sz] = {0};
     char* __a_end = __a;
@@ -1097,8 +1050,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     bool __in_units = true;
     char __exp = 'E';
     for (; __b != __e; ++__b)
-        if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
-                                      __decimal_point, __thousands_sep,
+        if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end, 
+                                      __decimal_point, __thousands_sep, 
                                       __grouping, __g, __g_end,
                                       __dc, __atoms))
             break;
@@ -1126,8 +1079,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     char_type __atoms[32];
     char_type __decimal_point;
     char_type __thousands_sep;
-    string __grouping = this->__stage2_float_prep(__iob, __atoms,
-                                                  __decimal_point,
+    string __grouping = this->__stage2_float_prep(__iob, __atoms, 
+                                                  __decimal_point, 
                                                   __thousands_sep);
     char __a[__num_get_base::__num_get_buf_sz] = {0};
     char* __a_end = __a;
@@ -1137,8 +1090,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     bool __in_units = true;
     char __exp = 'E';
     for (; __b != __e; ++__b)
-        if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
-                                      __decimal_point, __thousands_sep,
+        if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end, 
+                                      __decimal_point, __thousands_sep, 
                                       __grouping, __g, __g_end,
                                       __dc, __atoms))
             break;
@@ -1166,7 +1119,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     char_type __atoms[32];
     char_type __decimal_point;
     char_type __thousands_sep;
-    string __grouping = this->__stage2_float_prep(__iob, __atoms,
+    string __grouping = this->__stage2_float_prep(__iob, __atoms, 
                                                   __decimal_point,
                                                   __thousands_sep);
     char __a[__num_get_base::__num_get_buf_sz] = {0};
@@ -1177,8 +1130,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     bool __in_units = true;
     char __exp = 'E';
     for (; __b != __e; ++__b)
-        if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
-                                      __decimal_point, __thousands_sep,
+        if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end, 
+                                      __decimal_point, __thousands_sep, 
                                       __grouping, __g, __g_end,
                                       __dc, __atoms))
             break;
@@ -1215,8 +1168,8 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     unsigned* __g_end = __g;
     unsigned __dc = 0;
     for (; __b != __e; ++__b)
-        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
-                                    __thousands_sep, __grouping,
+        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, 
+                                    __thousands_sep, __grouping, 
                                     __g, __g_end, __atoms))
             break;
     // Stage 3
@@ -1383,7 +1336,7 @@ extern template class __num_put<char>;
 extern template class __num_put<wchar_t>;
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_VISIBLE num_put
+class num_put
     : public locale::facet,
       private __num_put<_CharT>
 {
@@ -1454,7 +1407,6 @@ public:
     static locale::id id;
 
 protected:
-    _LIBCPP_ALWAYS_INLINE
     ~num_put() {}
 
     virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
@@ -1789,14 +1741,14 @@ __get_up_to_n_digits(_InputIterator& __b, _InputIterator __e,
     return __r;
 }
 
-class _LIBCPP_VISIBLE time_base
+class time_base
 {
 public:
     enum dateorder {no_order, dmy, mdy, ymd, ydm};
 };
 
 template <class _CharT>
-class __time_get_c_storage  // purposefully not decorated
+class __time_get_c_storage
 {
 protected:
     typedef basic_string<_CharT> string_type;
@@ -1811,7 +1763,7 @@ protected:
 };
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_VISIBLE time_get
+class time_get
     : public locale::facet,
       public time_base,
       private __time_get_c_storage<_CharT>
@@ -1882,7 +1834,6 @@ public:
     static locale::id id;
 
 protected:
-    _LIBCPP_ALWAYS_INLINE
     ~time_get() {}
 
     virtual dateorder do_date_order() const;
@@ -2346,12 +2297,6 @@ time_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
         __b = get(__b, __e, __iob, __err, __tm, __fmt, __fmt + sizeof(__fmt)/sizeof(__fmt[0]));
         }
         break;
-    case 'F':
-        {
-        const char_type __fmt[] = {'%', 'Y', '-', '%', 'm', '-', '%', 'd'};
-        __b = get(__b, __e, __iob, __err, __tm, __fmt, __fmt + sizeof(__fmt)/sizeof(__fmt[0]));
-        }
-        break;
     case 'H':
         __get_hour(__tm->tm_hour, __b, __e, __err, __ct);
         break;
@@ -2462,7 +2407,7 @@ private:
 };
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_VISIBLE time_get_byname
+class time_get_byname
     : public time_get<_CharT, _InputIterator>,
       private __time_get_storage<_CharT>
 {
@@ -2472,35 +2417,24 @@ public:
     typedef _CharT                  char_type;
     typedef basic_string<char_type> string_type;
 
-    _LIBCPP_INLINE_VISIBILITY
     explicit time_get_byname(const char* __nm, size_t __refs = 0)
         : time_get<_CharT, _InputIterator>(__refs),
           __time_get_storage<_CharT>(__nm) {}
-    _LIBCPP_INLINE_VISIBILITY
     explicit time_get_byname(const string& __nm, size_t __refs = 0)
         : time_get<_CharT, _InputIterator>(__refs),
           __time_get_storage<_CharT>(__nm) {}
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
     ~time_get_byname() {}
 
-    _LIBCPP_INLINE_VISIBILITY
     virtual dateorder do_date_order() const {return this->__do_date_order();}
 private:
-    _LIBCPP_INLINE_VISIBILITY
     virtual const string_type* __weeks() const  {return this->__weeks_;}
-    _LIBCPP_INLINE_VISIBILITY
     virtual const string_type* __months() const {return this->__months_;}
-    _LIBCPP_INLINE_VISIBILITY
     virtual const string_type* __am_pm() const  {return this->__am_pm_;}
-    _LIBCPP_INLINE_VISIBILITY
     virtual const string_type& __c() const      {return this->__c_;}
-    _LIBCPP_INLINE_VISIBILITY
     virtual const string_type& __r() const      {return this->__r_;}
-    _LIBCPP_INLINE_VISIBILITY
     virtual const string_type& __x() const      {return this->__x_;}
-    _LIBCPP_INLINE_VISIBILITY
     virtual const string_type& __X() const      {return this->__X_;}
 };
 
@@ -2522,7 +2456,7 @@ protected:
 };
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_VISIBLE time_put
+class time_put
     : public locale::facet,
       private __time_put
 {
@@ -2547,16 +2481,13 @@ public:
     static locale::id id;
 
 protected:
-    _LIBCPP_ALWAYS_INLINE
     ~time_put() {}
     virtual iter_type do_put(iter_type __s, ios_base&, char_type, const tm* __tm,
                              char __fmt, char __mod) const;
 
-    _LIBCPP_ALWAYS_INLINE
     explicit time_put(const char* __nm, size_t __refs)
         : locale::facet(__refs),
           __time_put(__nm) {}
-    _LIBCPP_ALWAYS_INLINE
     explicit time_put(const string& __nm, size_t __refs)
         : locale::facet(__refs),
           __time_put(__nm) {}
@@ -2614,14 +2545,14 @@ time_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
     char_type* __nb = __nar;
     char_type* __ne = __nb + 100;
     __do_put(__nb, __ne, __tm, __fmt, __mod);
-    return _STD::copy(__nb, __ne, __s);
+    return copy(__nb, __ne, __s);
 }
 
 extern template class time_put<char>;
 extern template class time_put<wchar_t>;
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_VISIBLE time_put_byname
+class time_put_byname
     : public time_put<_CharT, _OutputIterator>
 {
 public:
@@ -2634,7 +2565,6 @@ public:
         : time_put<_CharT, _OutputIterator>(__nm, __refs) {}
 
 protected:
-    _LIBCPP_ALWAYS_INLINE
     ~time_put_byname() {}
 };
 
@@ -2643,7 +2573,7 @@ extern template class time_put_byname<wchar_t>;
 
 // money_base
 
-class _LIBCPP_VISIBLE money_base
+class money_base
 {
 public:
     enum part {none, space, symbol, sign, value};
@@ -2655,7 +2585,7 @@ public:
 // moneypunct
 
 template <class _CharT, bool _International = false>
-class _LIBCPP_VISIBLE moneypunct
+class moneypunct
     : public locale::facet,
       public money_base
 {
@@ -2663,7 +2593,6 @@ public:
     typedef _CharT                  char_type;
     typedef basic_string<char_type> string_type;
 
-    _LIBCPP_ALWAYS_INLINE
     explicit moneypunct(size_t __refs = 0)
         : locale::facet(__refs) {}
 
@@ -2681,7 +2610,6 @@ public:
     static const bool intl = _International;
 
 protected:
-    _LIBCPP_ALWAYS_INLINE
     ~moneypunct() {}
 
     virtual char_type   do_decimal_point() const {return numeric_limits<char_type>::max();}
@@ -2709,8 +2637,7 @@ extern template class moneypunct<wchar_t, true>;
 // moneypunct_byname
 
 template <class _CharT, bool _International = false>
-class _LIBCPP_VISIBLE moneypunct_byname
-    : public moneypunct<_CharT, _International>
+class moneypunct_byname : public moneypunct<_CharT, _International>
 {
 public:
     typedef money_base::pattern  pattern;
@@ -2726,7 +2653,6 @@ public:
         : moneypunct<_CharT, _International>(__refs) {init(__nm.c_str());}
 
 protected:
-    _LIBCPP_ALWAYS_INLINE
     ~moneypunct_byname() {}
 
     virtual char_type   do_decimal_point() const {return __decimal_point_;}
@@ -2821,7 +2747,7 @@ extern template class __money_get<char>;
 extern template class __money_get<wchar_t>;
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_VISIBLE money_get
+class money_get
     : public locale::facet,
       private __money_get<_CharT>
 {
@@ -2852,9 +2778,8 @@ public:
 
 protected:
 
-    _LIBCPP_ALWAYS_INLINE
     ~money_get() {}
-
+    
     virtual iter_type do_get(iter_type __b, iter_type __e, bool __intl,
                              ios_base& __iob, ios_base::iostate& __err,
                              long double& __v) const;
@@ -2942,7 +2867,7 @@ money_get<_CharT, _InputIterator>::__do_get(iter_type& __b, iter_type __e,
                     return false;
                 }
             }
-            // drop through
+            // drop through            
         case money_base::none:
             if (__p != 3)
             {
@@ -3282,7 +3207,7 @@ __money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __m
             break;
         case money_base::symbol:
             if (!__sym.empty() && (__flags & ios_base::showbase))
-                __me = _STD::copy(__sym.begin(), __sym.end(), __me);
+                __me = copy(__sym.begin(), __sym.end(), __me);
             break;
         case money_base::value:
             {
@@ -3341,7 +3266,7 @@ __money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __m
     }
     // print rest of sign, if any
     if (__sn.size() > 1)
-        __me = _STD::copy(__sn.begin()+1, __sn.end(), __me);
+        __me = copy(__sn.begin()+1, __sn.end(), __me);
     // set alignment
     if ((__flags & ios_base::adjustfield) == ios_base::left)
         __mi = __me;
@@ -3353,7 +3278,7 @@ extern template class __money_put<char>;
 extern template class __money_put<wchar_t>;
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_VISIBLE money_put
+class money_put
     : public locale::facet,
       private __money_put<_CharT>
 {
@@ -3383,7 +3308,6 @@ public:
     static locale::id id;
 
 protected:
-    _LIBCPP_ALWAYS_INLINE
     ~money_put() {}
 
     virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob,
@@ -3505,16 +3429,16 @@ extern template class money_put<wchar_t>;
 
 // messages
 
-class _LIBCPP_VISIBLE messages_base
+class messages_base
 {
 public:
-    typedef ptrdiff_t catalog;
+    typedef nl_catd catalog;
 
     _LIBCPP_ALWAYS_INLINE messages_base() {}
 };
 
 template <class _CharT>
-class _LIBCPP_VISIBLE messages
+class messages
     : public locale::facet,
       public messages_base
 {
@@ -3548,7 +3472,6 @@ public:
     static locale::id id;
 
 protected:
-    _LIBCPP_ALWAYS_INLINE
     ~messages() {}
 
     virtual catalog do_open(const basic_string<char>&, const locale&) const;
@@ -3565,10 +3488,7 @@ template <class _CharT>
 typename messages<_CharT>::catalog
 messages<_CharT>::do_open(const basic_string<char>& __nm, const locale&) const
 {
-    catalog __cat = reinterpret_cast<catalog>(catopen(__nm.c_str(), NL_CAT_LOCALE));
-    if (__cat != -1)
-        __cat = static_cast<catalog>((static_cast<size_t>(__cat) >> 1));
-    return __cat;
+    return catopen(__nm.c_str(), NL_CAT_LOCALE);
 }
 
 template <class _CharT>
@@ -3580,10 +3500,7 @@ messages<_CharT>::do_get(catalog __c, int __set, int __msgid,
     __narrow_to_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__ndflt),
                                                        __dflt.c_str(),
                                                        __dflt.c_str() + __dflt.size());
-    if (__c != -1)
-        __c <<= 1;
-    nl_catd __cat = reinterpret_cast<nl_catd>(__c);
-    char* __n = catgets(__cat, __set, __msgid, __ndflt.c_str());
+    char* __n = catgets(__c, __set, __msgid, __ndflt.c_str());
     string_type __w;
     __widen_from_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__w),
                                                         __n, __n + strlen(__n));
@@ -3594,17 +3511,14 @@ template <class _CharT>
 void
 messages<_CharT>::do_close(catalog __c) const
 {
-    if (__c != -1)
-        __c <<= 1;
-    nl_catd __cat = reinterpret_cast<nl_catd>(__c);
-    catclose(__cat);
+    catclose(__c);
 }
 
 extern template class messages<char>;
 extern template class messages<wchar_t>;
 
 template <class _CharT>
-class _LIBCPP_VISIBLE messages_byname
+class messages_byname
     : public messages<_CharT>
 {
 public:
@@ -3620,7 +3534,6 @@ public:
         : messages<_CharT>(__refs) {}
 
 protected:
-    _LIBCPP_ALWAYS_INLINE
     ~messages_byname() {}
 };
 
@@ -3630,7 +3543,7 @@ extern template class messages_byname<wchar_t>;
 template<class _Codecvt, class _Elem = wchar_t,
          class _Wide_alloc = allocator<_Elem>,
          class _Byte_alloc = allocator<char> >
-class _LIBCPP_VISIBLE wstring_convert
+class wstring_convert
 {
 public:
     typedef basic_string<char, char_traits<char>, _Byte_alloc>   byte_string;
@@ -3652,41 +3565,33 @@ public:
     wstring_convert(_Codecvt* __pcvt, state_type __state);
     wstring_convert(const byte_string& __byte_err,
                     const wide_string& __wide_err = wide_string());
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     wstring_convert(wstring_convert&& __wc);
 #endif
     ~wstring_convert();
 
-    _LIBCPP_ALWAYS_INLINE
     wide_string from_bytes(char __byte)
         {return from_bytes(&__byte, &__byte+1);}
-    _LIBCPP_ALWAYS_INLINE
     wide_string from_bytes(const char* __ptr)
         {return from_bytes(__ptr, __ptr + char_traits<char>::length(__ptr));}
-    _LIBCPP_ALWAYS_INLINE
     wide_string from_bytes(const byte_string& __str)
         {return from_bytes(__str.data(), __str.data() + __str.size());}
     wide_string from_bytes(const char* __first, const char* __last);
 
-    _LIBCPP_ALWAYS_INLINE
     byte_string to_bytes(_Elem __wchar)
         {return to_bytes(&__wchar, &__wchar+1);}
-    _LIBCPP_ALWAYS_INLINE
     byte_string to_bytes(const _Elem* __wptr)
         {return to_bytes(__wptr, __wptr + char_traits<_Elem>::length(__wptr));}
-    _LIBCPP_ALWAYS_INLINE
     byte_string to_bytes(const wide_string& __wstr)
         {return to_bytes(__wstr.data(), __wstr.data() + __wstr.size());}
     byte_string to_bytes(const _Elem* __first, const _Elem* __last);
 
-    _LIBCPP_ALWAYS_INLINE
     size_t converted() const {return __cvtcount_;}
-    _LIBCPP_ALWAYS_INLINE
     state_type state() const {return __cvtstate_;}
 };
 
 template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-inline _LIBCPP_ALWAYS_INLINE
+inline
 wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
     wstring_convert(_Codecvt* __pcvt)
         : __cvtptr_(__pcvt), __cvtstate_(), __cvtcount_(0)
@@ -3694,7 +3599,7 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
 }
 
 template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-inline _LIBCPP_ALWAYS_INLINE
+inline
 wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
     wstring_convert(_Codecvt* __pcvt, state_type __state)
         : __cvtptr_(__pcvt), __cvtstate_(__state), __cvtcount_(0)
@@ -3710,10 +3615,10 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
     __cvtptr_ = new _Codecvt;
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-inline _LIBCPP_ALWAYS_INLINE
+inline
 wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
     wstring_convert(wstring_convert&& __wc)
         : __byte_err_string_(_STD::move(__wc.__byte_err_string_)),
@@ -3724,7 +3629,7 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
     __wc.__cvtptr_ = nullptr;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
 wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::~wstring_convert()
@@ -3785,10 +3690,8 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
         if (__r == codecvt_base::ok)
             return __ws;
     }
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__wide_err_string_.empty())
         throw range_error("wstring_convert: from_bytes error");
-#endif  // _LIBCPP_NO_EXCEPTIONS
     return __wide_err_string_;
 }
 
@@ -3873,15 +3776,13 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
                 return __bs;
         }
     }
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__byte_err_string_.empty())
         throw range_error("wstring_convert: to_bytes error");
-#endif  // _LIBCPP_NO_EXCEPTIONS
     return __byte_err_string_;
 }
 
 template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> >
-class _LIBCPP_VISIBLE wbuffer_convert
+class wbuffer_convert
     : public basic_streambuf<_Elem, _Tr>
 {
 public:
@@ -3916,9 +3817,7 @@ public:
                     state_type __state = state_type());
     ~wbuffer_convert();
 
-    _LIBCPP_INLINE_VISIBILITY
     streambuf* rdbuf() const {return __bufptr_;}
-    _LIBCPP_INLINE_VISIBILITY
     streambuf* rdbuf(streambuf* __bytebuf)
     {
         streambuf* __r = __bufptr_;
@@ -3926,7 +3825,6 @@ public:
         return __r;
     }
 
-    _LIBCPP_INLINE_VISIBILITY
     state_type state() const {return __st_;}
 
 protected:
@@ -4010,7 +3908,7 @@ wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow()
             memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
             __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
             __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
-            streamsize __nmemb = _STD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
+            streamsize __nmemb = min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
                                  static_cast<streamsize>(__extbufend_ - __extbufnext_));
             codecvt_base::result __r;
             state_type __svs = __st_;

include/mutex

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -175,15 +175,12 @@ template<class Callable, class ...Args>
 #include <__config>
 #include <__mutex_base>
 #include <functional>
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-#include <tuple>
-#endif
 
 #pragma GCC system_header
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_VISIBLE recursive_mutex
+class recursive_mutex
 {
     pthread_mutex_t __m_;
 
@@ -201,11 +198,10 @@ public:
     void unlock();
 
     typedef pthread_mutex_t* native_handle_type;
-    _LIBCPP_INLINE_VISIBILITY
     native_handle_type native_handle() {return &__m_;}
 };
 
-class _LIBCPP_VISIBLE timed_mutex
+class timed_mutex
 {
     mutex              __m_;
     condition_variable __cv_;
@@ -222,9 +218,8 @@ public:
     void lock();
     bool try_lock();
     template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
-            {return try_lock_until(chrono::steady_clock::now() + __d);}
+            {return try_lock_until(chrono::monotonic_clock::now() + __d);}
     template <class _Clock, class _Duration>
         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
     void unlock();
@@ -247,7 +242,7 @@ timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
     return false;
 }
 
-class _LIBCPP_VISIBLE recursive_timed_mutex
+class recursive_timed_mutex
 {
     mutex              __m_;
     condition_variable __cv_;
@@ -265,9 +260,8 @@ public:
     void lock();
     bool try_lock();
     template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
-            {return try_lock_until(chrono::steady_clock::now() + __d);}
+            {return try_lock_until(chrono::monotonic_clock::now() + __d);}
     template <class _Clock, class _Duration>
         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
     void unlock();
@@ -336,7 +330,7 @@ try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3)
     return __r;
 }
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#endif
 
 template <class _L0, class _L1>
 void
@@ -367,9 +361,9 @@ lock(_L0& __l0, _L1& __l1)
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
-template <class _L0, class _L1, class _L2, class ..._L3>
+template <class _L0, class _L1, class ..._L2>
 void
-__lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
+__lock_first(int __i, _L0& __l0, _L1& __l1, _L2& ...__l2)
 {
     while (true)
     {
@@ -378,7 +372,7 @@ __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
         case 0:
             {
                 unique_lock<_L0> __u0(__l0);
-                __i = try_lock(__l1, __l2, __l3...);
+                __i = try_lock(__l1, __l2...);
                 if (__i == -1)
                 {
                     __u0.release();
@@ -391,35 +385,35 @@ __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
         case 1:
             {
                 unique_lock<_L1> __u1(__l1);
-                __i = try_lock(__l2, __l3..., __l0);
+                __i = try_lock(__l2..., __l0);
                 if (__i == -1)
                 {
                     __u1.release();
                     return;
                 }
             }
-            if (__i == sizeof...(_L3) + 1)
+            if (__i == sizeof...(_L2))
                 __i = 0;
             else
                 __i += 2;
             sched_yield();
             break;
         default:
-            __lock_first(__i - 2, __l2, __l3..., __l0, __l1);
+            __lock_first(__i - 2, __l2..., __l0, __l1);
             return;
         }
     }
 }
 
-template <class _L0, class _L1, class _L2, class ..._L3>
-inline _LIBCPP_INLINE_VISIBILITY
+template <class _L0, class _L1, class ..._L2>
+inline
 void
-lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
+lock(_L0& __l0, _L1& __l1, _L2& ...__l2)
 {
-    __lock_first(0, __l0, __l1, __l2, __l3...);
+    __lock_first(0, __l0, __l1, __l2...);
 }
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#endif
 
 struct once_flag;
 
@@ -428,16 +422,15 @@ struct once_flag;
 template<class _Callable, class... _Args>
   void call_once(once_flag&, _Callable&&, _Args&&...);
 
-#else  // _LIBCPP_HAS_NO_VARIADICS
+#else
 
 template<class _Callable>
   void call_once(once_flag&, _Callable);
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#endif
 
-struct _LIBCPP_VISIBLE once_flag
+struct once_flag
 {
-    _LIBCPP_INLINE_VISIBILITY
     // constexpr
         once_flag() {}
 
@@ -451,68 +444,30 @@ private:
     template<class _Callable, class... _Args>
     friend
     void call_once(once_flag&, _Callable&&, _Args&&...);
-#else  // _LIBCPP_HAS_NO_VARIADICS
+#else
     template<class _Callable>
     friend
     void call_once(once_flag&, _Callable);
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#endif
 };
 
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
 template <class _F>
 class __call_once_param
 {
     _F __f_;
 public:
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     explicit __call_once_param(_F&& __f) : __f_(_STD::move(__f)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
     explicit __call_once_param(const _F& __f) : __f_(__f) {}
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()()
-    {
-        typedef typename __make_tuple_indices<tuple_size<_F>::value, 1>::type _Index;
-        __execute(_Index());
-    }
-
-private:
-    template <size_t ..._Indices>
-    _LIBCPP_INLINE_VISIBILITY
-    void __execute(__tuple_indices<_Indices...>)
-    {
-        __invoke(_STD::move(_STD::get<0>(__f_)), _STD::move(_STD::get<_Indices>(__f_))...);
-    }
-};
-
-#else
-
-template <class _F>
-class __call_once_param
-{
-    _F __f_;
-public:
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __call_once_param(_F&& __f) : __f_(_STD::move(__f)) {}
-#else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __call_once_param(const _F& __f) : __f_(__f) {}
-#endif
-
-    _LIBCPP_INLINE_VISIBILITY
     void operator()()
     {
         __f_();
     }
 };
 
-#endif
-
 template <class _F>
 void
 __call_once_proxy(void* __vp)
@@ -532,14 +487,15 @@ call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args)
 {
     if (__builtin_expect(__flag.__state_ , ~0ul) != ~0ul)
     {
-        typedef tuple<typename decay<_Callable>::type, typename decay<_Args>::type...> _G;
-        __call_once_param<_G> __p(_G(__decay_copy(_STD::forward<_Callable>(__func)),
-                                __decay_copy(_STD::forward<_Args>(__args))...));
+        typedef decltype(std::bind(std::forward<_Callable>(__func),
+                         std::forward<_Args>(__args)...)) _G;
+        __call_once_param<_G> __p(std::bind(std::forward<_Callable>(__func),
+                                 std::forward<_Args>(__args)...));
         __call_once(__flag.__state_, &__p, &__call_once_proxy<_G>);
     }
 }
 
-#else  // _LIBCPP_HAS_NO_VARIADICS
+#else
 
 template<class _Callable>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -553,7 +509,7 @@ call_once(once_flag& __flag, _Callable __func)
     }
 }
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#endif
 
 _LIBCPP_END_NAMESPACE_STD
 

include/new

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -21,34 +21,34 @@ class bad_alloc
     : public exception
 {
 public:
-    bad_alloc() noexcept;
-    bad_alloc(const bad_alloc&) noexcept;
-    bad_alloc& operator=(const bad_alloc&) noexcept;
-    virtual const char* what() const noexcept;
+    bad_alloc() throw();
+    bad_alloc(const bad_alloc&) throw();
+    bad_alloc& operator=(const bad_alloc&) throw();
+    virtual ~bad_alloc() throw();
+    virtual const char* what() const throw();
 };
 
 struct nothrow_t {};
 extern const nothrow_t nothrow;
 typedef void (*new_handler)();
-new_handler set_new_handler(new_handler new_p) noexcept;
-new_handler get_new_handler() noexcept;
+new_handler set_new_handler(new_handler new_p) throw();
 
 }  // std
 
-void* operator new(std::size_t size);                                   // replaceable
-void* operator new(std::size_t size, const std::nothrow_t&) noexcept;   // replaceable
-void  operator delete(void* ptr) noexcept;                              // replaceable
-void  operator delete(void* ptr, const std::nothrow_t&) noexcept;       // replaceable
+void* operator new(std::size_t size) throw(std::bad_alloc);            // replaceable
+void* operator new(std::size_t size, const std::nothrow_t&) throw();   // replaceable
+void  operator delete(void* ptr) throw();                              // replaceable
+void  operator delete(void* ptr, const std::nothrow_t&) throw();       // replaceable
 
-void* operator new[](std::size_t size);                                 // replaceable
-void* operator new[](std::size_t size, const std::nothrow_t&) noexcept; // replaceable
-void  operator delete[](void* ptr) noexcept;                            // replaceable
-void  operator delete[](void* ptr, const std::nothrow_t&) noexcept;     // replaceable
+void* operator new[](std::size_t size) throw(std::bad_alloc);          // replaceable
+void* operator new[](std::size_t size, const std::nothrow_t&) throw(); // replaceable
+void  operator delete[](void* ptr) throw();                            // replaceable
+void  operator delete[](void* ptr, const std::nothrow_t&) throw();     // replaceable
 
-void* operator new  (std::size_t size, void* ptr) noexcept;
-void* operator new[](std::size_t size, void* ptr) noexcept;
-void  operator delete  (void* ptr, void*) noexcept;
-void  operator delete[](void* ptr, void*) noexcept;
+void* operator new  (std::size_t size, void* ptr) throw();
+void* operator new[](std::size_t size, void* ptr) throw();
+void  operator delete  (void* ptr, void*) throw();
+void  operator delete[](void* ptr, void*) throw();
 
 */
 
@@ -65,51 +65,42 @@ class _LIBCPP_EXCEPTION_ABI bad_alloc
     : public exception
 {
 public:
-    bad_alloc() _NOEXCEPT;
-    virtual ~bad_alloc() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+	bad_alloc() throw();
+    virtual ~bad_alloc() throw();
+    virtual const char* what() const throw();
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_array_new_length
     : public bad_alloc
 {
 public:
-    bad_array_new_length() _NOEXCEPT;
-    virtual ~bad_array_new_length() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    bad_array_new_length() throw();
+    virtual ~bad_array_new_length() throw();
+    virtual const char* what() const throw();
 };
 
 void __throw_bad_alloc();  // not in C++ spec
 
-struct _LIBCPP_VISIBLE nothrow_t {};
+struct nothrow_t {};
 extern _LIBCPP_VISIBLE const nothrow_t nothrow;
 typedef void (*new_handler)();
-_LIBCPP_VISIBLE new_handler set_new_handler(new_handler) _NOEXCEPT;
-_LIBCPP_VISIBLE new_handler get_new_handler() _NOEXCEPT;
+_LIBCPP_VISIBLE new_handler set_new_handler(new_handler) throw();
 
 }  // std
 
-_LIBCPP_VISIBLE void* operator new(std::size_t)
-#if !__has_feature(cxx_noexcept)
-    throw(std::bad_alloc)
-#endif
-;
-_LIBCPP_VISIBLE void* operator new(std::size_t, const std::nothrow_t&) _NOEXCEPT;
-_LIBCPP_VISIBLE void  operator delete(void*) _NOEXCEPT;
-_LIBCPP_VISIBLE void  operator delete(void*, const std::nothrow_t&) _NOEXCEPT;
+_LIBCPP_VISIBLE void* operator new(std::size_t) throw(std::bad_alloc);
+_LIBCPP_VISIBLE void* operator new(std::size_t, const std::nothrow_t&) throw();
+_LIBCPP_VISIBLE void  operator delete(void*) throw();
+_LIBCPP_VISIBLE void  operator delete(void*, const std::nothrow_t&) throw();
 
-_LIBCPP_VISIBLE void* operator new[](std::size_t)
-#if !__has_feature(cxx_noexcept)
-    throw(std::bad_alloc)
-#endif
-;
-_LIBCPP_VISIBLE void* operator new[](std::size_t, const std::nothrow_t&) _NOEXCEPT;
-_LIBCPP_VISIBLE void  operator delete[](void*) _NOEXCEPT;
-_LIBCPP_VISIBLE void  operator delete[](void*, const std::nothrow_t&) _NOEXCEPT;
+_LIBCPP_VISIBLE void* operator new[](std::size_t) throw(std::bad_alloc);
+_LIBCPP_VISIBLE void* operator new[](std::size_t, const std::nothrow_t&) throw();
+_LIBCPP_VISIBLE void  operator delete[](void*) throw();
+_LIBCPP_VISIBLE void  operator delete[](void*, const std::nothrow_t&) throw();
 
-_LIBCPP_INLINE_VISIBILITY inline void* operator new  (std::size_t, void* __p) _NOEXCEPT {return __p;}
-_LIBCPP_INLINE_VISIBILITY inline void* operator new[](std::size_t, void* __p) _NOEXCEPT {return __p;}
-_LIBCPP_INLINE_VISIBILITY inline void  operator delete  (void*, void*) _NOEXCEPT {}
-_LIBCPP_INLINE_VISIBILITY inline void  operator delete[](void*, void*) _NOEXCEPT {}
+_LIBCPP_INLINE_VISIBILITY inline void* operator new  (std::size_t, void* __p) throw() {return __p;}
+_LIBCPP_INLINE_VISIBILITY inline void* operator new[](std::size_t, void* __p) throw() {return __p;}
+_LIBCPP_INLINE_VISIBILITY inline void  operator delete  (void*, void*) throw() {}
+_LIBCPP_INLINE_VISIBILITY inline void  operator delete[](void*, void*) throw() {}
 
 #endif  // _LIBCPP_NEW

include/numeric

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/ostream

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -138,7 +138,7 @@ template <class charT, class traits, class T>
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_VISIBLE basic_ostream
+class basic_ostream
     : virtual public basic_ios<_CharT, _Traits>
 {
 public:
@@ -153,12 +153,12 @@ public:
     explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb);
     virtual ~basic_ostream();
 protected:
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_ostream(basic_ostream&& __rhs);
 #endif
 
     // 27.7.2.3 Assign/swap
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_ostream& operator=(basic_ostream&& __rhs);
 #endif
     void swap(basic_ostream& __rhs);
@@ -203,7 +203,7 @@ protected:
 };
 
 template <class _CharT, class _Traits>
-class _LIBCPP_VISIBLE basic_ostream<_CharT, _Traits>::sentry
+class basic_ostream<_CharT, _Traits>::sentry
 {
     bool __ok_;
     basic_ostream<_CharT, _Traits>& __os_;
@@ -242,7 +242,7 @@ basic_ostream<_CharT, _Traits>::sentry::~sentry()
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
             if (__os_.rdbuf()->pubsync() == -1)
                 __os_.setstate(ios_base::badbit);
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -250,7 +250,7 @@ basic_ostream<_CharT, _Traits>::sentry::~sentry()
         catch (...)
         {
         }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     }
 }
 
@@ -261,7 +261,7 @@ basic_ostream<_CharT, _Traits>::basic_ostream(basic_streambuf<char_type, traits_
     this->init(__sb);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -279,7 +279,7 @@ basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs)
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>::~basic_ostream()
@@ -328,7 +328,7 @@ basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_typ
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -337,7 +337,7 @@ basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_typ
 #ifndef _LIBCPP_NO_EXCEPTIONS
                 try
                 {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
                     typedef istreambuf_iterator<_CharT, _Traits> _I;
                     typedef ostreambuf_iterator<_CharT, _Traits> _O;
                     _I __i(__sb);
@@ -358,7 +358,7 @@ basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_typ
                 {
                     this->__set_failbit_and_consider_rethrow();
                 }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
             }
             else
                 this->setstate(ios_base::badbit);
@@ -369,7 +369,7 @@ basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_typ
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -380,7 +380,7 @@ basic_ostream<_CharT, _Traits>::operator<<(bool __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -395,7 +395,7 @@ basic_ostream<_CharT, _Traits>::operator<<(bool __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -406,7 +406,7 @@ basic_ostream<_CharT, _Traits>::operator<<(short __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -425,7 +425,7 @@ basic_ostream<_CharT, _Traits>::operator<<(short __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -436,7 +436,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -451,7 +451,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -462,7 +462,7 @@ basic_ostream<_CharT, _Traits>::operator<<(int __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -481,7 +481,7 @@ basic_ostream<_CharT, _Traits>::operator<<(int __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -492,7 +492,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -507,7 +507,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -518,7 +518,7 @@ basic_ostream<_CharT, _Traits>::operator<<(long __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -533,7 +533,7 @@ basic_ostream<_CharT, _Traits>::operator<<(long __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -544,7 +544,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -559,7 +559,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -570,7 +570,7 @@ basic_ostream<_CharT, _Traits>::operator<<(long long __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -585,7 +585,7 @@ basic_ostream<_CharT, _Traits>::operator<<(long long __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -596,7 +596,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -611,7 +611,7 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -622,7 +622,7 @@ basic_ostream<_CharT, _Traits>::operator<<(float __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -637,7 +637,7 @@ basic_ostream<_CharT, _Traits>::operator<<(float __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -648,7 +648,7 @@ basic_ostream<_CharT, _Traits>::operator<<(double __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -663,7 +663,7 @@ basic_ostream<_CharT, _Traits>::operator<<(double __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -674,7 +674,7 @@ basic_ostream<_CharT, _Traits>::operator<<(long double __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -689,7 +689,7 @@ basic_ostream<_CharT, _Traits>::operator<<(long double __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -700,7 +700,7 @@ basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -715,7 +715,7 @@ basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -726,7 +726,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
         if (__s)
         {
@@ -747,7 +747,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __os;
 }
 
@@ -758,7 +758,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
         if (__s)
         {
@@ -780,7 +780,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __os;
 }
 
@@ -791,7 +791,7 @@ operator<<(basic_ostream<char, _Traits>& __os, char __c)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_ostream<char, _Traits>::sentry __s(__os);
         if (__s)
         {
@@ -812,7 +812,7 @@ operator<<(basic_ostream<char, _Traits>& __os, char __c)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __os;
 }
 
@@ -823,7 +823,7 @@ operator<<(basic_ostream<char, _Traits>& __os, signed char __c)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_ostream<char, _Traits>::sentry __s(__os);
         if (__s)
         {
@@ -844,7 +844,7 @@ operator<<(basic_ostream<char, _Traits>& __os, signed char __c)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __os;
 }
 
@@ -855,7 +855,7 @@ operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_ostream<char, _Traits>::sentry __s(__os);
         if (__s)
         {
@@ -876,7 +876,7 @@ operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __os;
 }
 
@@ -887,7 +887,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
         if (__s)
         {
@@ -909,7 +909,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __os;
 }
 
@@ -920,7 +920,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
         if (__s)
         {
@@ -955,7 +955,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __os;
 }
 
@@ -966,7 +966,7 @@ operator<<(basic_ostream<char, _Traits>& __os, const char* __str)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_ostream<char, _Traits>::sentry __s(__os);
         if (__s)
         {
@@ -988,7 +988,7 @@ operator<<(basic_ostream<char, _Traits>& __os, const char* __str)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __os;
 }
 
@@ -999,7 +999,7 @@ operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_ostream<char, _Traits>::sentry __s(__os);
         if (__s)
         {
@@ -1021,7 +1021,7 @@ operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __os;
 }
 
@@ -1032,7 +1032,7 @@ operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_ostream<char, _Traits>::sentry __s(__os);
         if (__s)
         {
@@ -1054,7 +1054,7 @@ operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str)
     {
         __os.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __os;
 }
 
@@ -1065,7 +1065,7 @@ basic_ostream<_CharT, _Traits>::put(char_type __c)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __s(*this);
         if (__s)
         {
@@ -1081,7 +1081,7 @@ basic_ostream<_CharT, _Traits>::put(char_type __c)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -1092,7 +1092,7 @@ basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n)
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         sentry __sen(*this);
         if (__sen && __n)
         {
@@ -1114,7 +1114,7 @@ basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n)
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -1125,7 +1125,7 @@ basic_ostream<_CharT, _Traits>::flush()
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         if (this->rdbuf())
         {
             sentry __s(*this);
@@ -1141,7 +1141,7 @@ basic_ostream<_CharT, _Traits>::flush()
     {
         this->__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return *this;
 }
 
@@ -1206,7 +1206,7 @@ flush(basic_ostream<_CharT, _Traits>& __os)
     return __os;
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Stream, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1222,7 +1222,7 @@ operator<<(_Stream&& __os, const _Tp& __x)
     return __os;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_ostream<_CharT, _Traits>&
@@ -1232,7 +1232,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os,
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
         if (__s)
         {
@@ -1254,7 +1254,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os,
     {
         __os.__set_badbit_and_consider_rethrow();
     }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
     return __os;
 }
 
@@ -1276,7 +1276,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Y> const& __p)
 
 template <class _CharT, class _Traits, size_t _Size>
 basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
+operator<<(basic_ostream<_CharT, _Traits>& __os, bitset<_Size>& __x)
 {
     return __os << __x.template to_string<_CharT, _Traits>
                         (use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),

include/queue

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -31,28 +31,21 @@ protected:
     container_type c;
 
 public:
-    queue() = default;
-    ~queue() = default;
-
-    queue(const queue& q) = default;
-    queue(queue&& q) = default;
-
-    queue& operator=(const queue& q) = default;
-    queue& operator=(queue&& q) = default;
-
+    queue();
     explicit queue(const container_type& c);
-    explicit queue(container_type&& c)
+    explicit queue(container_type&& c);
+    queue(queue&& q);
     template <class Alloc>
         explicit queue(const Alloc& a);
     template <class Alloc>
         queue(const container_type& c, const Alloc& a);
     template <class Alloc>
         queue(container_type&& c, const Alloc& a);
-    template <class Alloc>
-        queue(const queue& q, const Alloc& a);
     template <class Alloc>
         queue(queue&& q, const Alloc& a);
 
+    queue& operator=(queue&& q);
+
     bool      empty() const;
     size_type size() const;
 
@@ -66,7 +59,7 @@ public:
     template <class... Args> void emplace(Args&&... args);
     void pop();
 
-    void swap(queue& q) noexcept(noexcept(swap(c, q.c)));
+    void swap(queue& q);
 };
 
 template <class T, class Container>
@@ -88,8 +81,7 @@ template <class T, class Container>
   bool operator<=(const queue<T, Container>& x,const queue<T, Container>& y);
 
 template <class T, class Container>
-  void swap(queue<T, Container>& x, queue<T, Container>& y)
-  noexcept(noexcept(x.swap(y)));
+  void swap(queue<T, Container>& x, queue<T, Container>& y);
 
 template <class T, class Container = vector<T>,
           class Compare = less<typename Container::value_type>>
@@ -107,16 +99,7 @@ protected:
     Compare comp;
 
 public:
-    priority_queue() = default;
-    ~priority_queue() = default;
-
-    priority_queue(const priority_queue& q) = default;
-    priority_queue(priority_queue&& q) = default;
-
-    priority_queue& operator=(const priority_queue& q) = default;
-    priority_queue& operator=(priority_queue&& q) = default;
-
-    explicit priority_queue(const Compare& comp);
+    explicit priority_queue(const Compare& comp = Compare());
     priority_queue(const Compare& comp, const container_type& c);
     explicit priority_queue(const Compare& comp, container_type&& c);
     template <class InputIterator>
@@ -128,6 +111,8 @@ public:
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Compare& comp, container_type&& c);
+    priority_queue(priority_queue&& q);
+    priority_queue& operator=(priority_queue&& q);
     template <class Alloc>
         explicit priority_queue(const Alloc& a);
     template <class Alloc>
@@ -138,8 +123,6 @@ public:
     template <class Alloc>
         priority_queue(const Compare& comp, container_type&& c,
                        const Alloc& a);
-    template <class Alloc>
-        priority_queue(const priority_queue& q, const Alloc& a);
     template <class Alloc>
         priority_queue(priority_queue&& q, const Alloc& a);
 
@@ -152,14 +135,12 @@ public:
     template <class... Args> void emplace(Args&&... args);
     void pop();
 
-    void swap(priority_queue& q)
-        noexcept(noexcept(swap(c, q.c)) && noexcept(swap(comp.q.comp)));
+    void swap(priority_queue& q);
 };
 
 template <class T, class Container, class Compare>
   void swap(priority_queue<T, Container, Compare>& x,
-            priority_queue<T, Container, Compare>& y)
-            noexcept(noexcept(x.swap(y)));
+            priority_queue<T, Container, Compare>& y);
 
 }  // std
 
@@ -186,7 +167,7 @@ bool
 operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container = deque<_Tp> >
-class _LIBCPP_VISIBLE queue
+class queue
 {
 public:
     typedef _Container                               container_type;
@@ -199,103 +180,64 @@ protected:
     container_type c;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    queue()
-        _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value)
-        : c() {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    queue(const queue& __q) : c(__q.c) {}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    queue(queue&& __q)
-        _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
-        : c(_STD::move(__q.c)) {}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    _LIBCPP_INLINE_VISIBILITY
-    queue& operator=(const queue& __q) {c = __q.c; return *this;}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    queue& operator=(queue&& __q)
-        _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
-        {c = _STD::move(__q.c); return *this;}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    _LIBCPP_INLINE_VISIBILITY
+    queue() : c() {}
     explicit queue(const container_type& __c)  : c(__c) {}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     explicit queue(container_type&& __c) : c(_STD::move(__c)) {}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    queue(queue&& __q) : c(_STD::move(__q.c)) {}
+#endif
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
         explicit queue(const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0)
             : c(__a) {}
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
         queue(const queue& __q, const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0)
             : c(__q.c, __a) {}
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
         queue(const container_type& __c, const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0)
             : c(__c, __a) {}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
         queue(container_type&& __c, const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0)
             : c(_STD::move(__c), __a) {}
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
         queue(queue&& __q, const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0)
             : c(_STD::move(__q.c), __a) {}
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    queue& operator=(queue&& __q)
+    {
+        c = _STD::move(__q.c);
+        return *this;
+    }
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY
     bool      empty() const {return c.empty();}
-    _LIBCPP_INLINE_VISIBILITY
     size_type size() const  {return c.size();}
 
-    _LIBCPP_INLINE_VISIBILITY
     reference       front()       {return c.front();}
-    _LIBCPP_INLINE_VISIBILITY
     const_reference front() const {return c.front();}
-    _LIBCPP_INLINE_VISIBILITY
     reference       back()        {return c.back();}
-    _LIBCPP_INLINE_VISIBILITY
     const_reference back() const  {return c.back();}
 
-    _LIBCPP_INLINE_VISIBILITY
     void push(const value_type& __v) {c.push_back(__v);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     void push(value_type&& __v)      {c.push_back(_STD::move(__v));}
-#ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
         void emplace(_Args&&... __args)
             {c.emplace_back(_STD::forward<_Args>(__args)...);}
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#endif
     void pop() {c.pop_front();}
 
-    _LIBCPP_INLINE_VISIBILITY
     void swap(queue& __q)
-        _NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
     {
         using _STD::swap;
         swap(c, __q.c);
@@ -303,19 +245,17 @@ public:
 
     template <class _T1, class _C1>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     bool
     operator==(const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);
-
+    
     template <class _T1, class _C1>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     bool
     operator< (const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);
 };
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 {
@@ -323,7 +263,7 @@ operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 {
@@ -331,7 +271,7 @@ operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator!=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 {
@@ -339,7 +279,7 @@ operator!=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator> (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 {
@@ -347,7 +287,7 @@ operator> (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator>=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 {
@@ -355,7 +295,7 @@ operator>=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator<=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 {
@@ -363,23 +303,22 @@ operator<=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 template <class _Tp, class _Container, class _Alloc>
-struct _LIBCPP_VISIBLE uses_allocator<queue<_Tp, _Container>, _Alloc>
+struct uses_allocator<queue<_Tp, _Container>, _Alloc>
     : public uses_allocator<_Container, _Alloc>
 {
 };
 
 template <class _Tp, class _Container = vector<_Tp>,
           class _Compare = less<typename _Container::value_type> >
-class _LIBCPP_VISIBLE priority_queue
+class priority_queue
 {
 public:
     typedef _Container                               container_type;
@@ -394,40 +333,10 @@ protected:
     value_compare comp;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue()
-        _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value &&
-                   is_nothrow_default_constructible<value_compare>::value)
-        : c(), comp() {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue(const priority_queue& __q) : c(__q.c), comp(__q.comp) {}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue(priority_queue&& __q)
-        _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value &&
-                   is_nothrow_move_constructible<value_compare>::value)
-        : c(_STD::move(__q.c)), comp(_STD::move(__q.comp)) {}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue& operator=(const priority_queue& __q)
-        {c = __q.c; comp = __q.comp; return *this;}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue& operator=(priority_queue&& __q)
-        _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value &&
-                   is_nothrow_move_assignable<value_compare>::value)
-        {c = _STD::move(__q.c); comp = _STD::move(__q.comp); return *this;}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit priority_queue(const value_compare& __comp)
+    explicit priority_queue(const value_compare& __comp = value_compare())
         : c(), comp(__comp) {}
     priority_queue(const value_compare& __comp, const container_type& __c);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     explicit priority_queue(const value_compare& __comp, container_type&& __c);
 #endif
     template <class _InputIter>
@@ -436,11 +345,13 @@ public:
     template <class _InputIter>
         priority_queue(_InputIter __f, _InputIter __l,
                        const value_compare& __comp, const container_type& __c);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     template <class _InputIter>
         priority_queue(_InputIter __f, _InputIter __l,
                        const value_compare& __comp, container_type&& __c);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    priority_queue(priority_queue&& __q);
+    priority_queue& operator=(priority_queue&& __q);
+#endif
     template <class _Alloc>
         explicit priority_queue(const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
@@ -458,7 +369,7 @@ public:
         priority_queue(const priority_queue& __q, const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     template <class _Alloc>
         priority_queue(const value_compare& __comp, container_type&& __c,
                        const _Alloc& __a,
@@ -468,31 +379,24 @@ public:
         priority_queue(priority_queue&& __q, const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY
     bool            empty() const {return c.empty();}
-    _LIBCPP_INLINE_VISIBILITY
     size_type       size() const  {return c.size();}
-    _LIBCPP_INLINE_VISIBILITY
     const_reference top() const   {return c.front();}
 
     void push(const value_type& __v);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     void push(value_type&& __v);
-#ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class... _Args> void emplace(_Args&&... __args);
 #endif
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     void pop();
 
-    void swap(priority_queue& __q)
-        _NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
-                   __is_nothrow_swappable<value_compare>::value);
+    void swap(priority_queue& __q);
 };
 
 template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp,
                                                           const container_type& __c)
     : c(__c),
@@ -501,10 +405,10 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp
     _STD::make_heap(c.begin(), c.end(), comp);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
                                                           container_type&& __c)
     : c(_STD::move(__c)),
@@ -513,11 +417,11 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
     _STD::make_heap(c.begin(), c.end(), comp);
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _Tp, class _Container, class _Compare>
 template <class _InputIter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
                                                           const value_compare& __comp)
     : c(__f, __l),
@@ -528,7 +432,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
 
 template <class _Tp, class _Container, class _Compare>
 template <class _InputIter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
                                                           const value_compare& __comp,
                                                           const container_type& __c)
@@ -539,11 +443,11 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
     _STD::make_heap(c.begin(), c.end(), comp);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Tp, class _Container, class _Compare>
 template <class _InputIter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
                                                           const value_compare& __comp,
                                                           container_type&& __c)
@@ -554,11 +458,28 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
     _STD::make_heap(c.begin(), c.end(), comp);
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+template <class _Tp, class _Container, class _Compare>
+inline
+priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q)
+    : c(_STD::move(__q.c)),
+      comp(_STD::move(__q.comp))
+{
+}
+
+template <class _Tp, class _Container, class _Compare>
+priority_queue<_Tp, _Container, _Compare>&
+priority_queue<_Tp, _Container, _Compare>::operator=(priority_queue&& __q)
+{
+    c = _STD::move(__q.c);
+    comp = _STD::move(__q.comp);
+    return *this;
+}
+
+#endif
 
 template <class _Tp, class _Container, class _Compare>
 template <class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type*)
@@ -568,7 +489,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Alloc& __a,
 
 template <class _Tp, class _Container, class _Compare>
 template <class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
                                                           const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
@@ -580,7 +501,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
 
 template <class _Tp, class _Container, class _Compare>
 template <class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
                                                           const container_type& __c,
                                                           const _Alloc& __a,
@@ -594,7 +515,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
 
 template <class _Tp, class _Container, class _Compare>
 template <class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue& __q,
                                                           const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
@@ -605,11 +526,11 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue&
     _STD::make_heap(c.begin(), c.end(), comp);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Tp, class _Container, class _Compare>
 template <class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
                                                           container_type&& __c,
                                                           const _Alloc& __a,
@@ -621,9 +542,10 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
     _STD::make_heap(c.begin(), c.end(), comp);
 }
 
+
 template <class _Tp, class _Container, class _Compare>
 template <class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q,
                                                           const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
@@ -634,10 +556,10 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q,
     _STD::make_heap(c.begin(), c.end(), comp);
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v)
 {
@@ -645,10 +567,10 @@ priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v)
     _STD::push_heap(c.begin(), c.end(), comp);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v)
 {
@@ -656,11 +578,9 @@ priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v)
     _STD::push_heap(c.begin(), c.end(), comp);
 }
 
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
 template <class _Tp, class _Container, class _Compare>
 template <class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args)
 {
@@ -668,11 +588,10 @@ priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args)
     _STD::push_heap(c.begin(), c.end(), comp);
 }
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 priority_queue<_Tp, _Container, _Compare>::pop()
 {
@@ -681,11 +600,9 @@ priority_queue<_Tp, _Container, _Compare>::pop()
 }
 
 template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
-        _NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
-                   __is_nothrow_swappable<value_compare>::value)
 {
     using _STD::swap;
     swap(c, __q.c);
@@ -693,17 +610,16 @@ priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
 }
 
 template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(priority_queue<_Tp, _Container, _Compare>& __x,
      priority_queue<_Tp, _Container, _Compare>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 template <class _Tp, class _Container, class _Compare, class _Alloc>
-struct _LIBCPP_VISIBLE uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc>
+struct uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc>
     : public uses_allocator<_Container, _Alloc>
 {
 };

include/ratio

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -23,14 +23,13 @@ class ratio
 public:
     static const intmax_t num;
     static const intmax_t den;
-    typedef ratio<num, den> type;
 };
 
 // ratio arithmetic
-template <class R1, class R2> using ratio_add = ...;
-template <class R1, class R2> using ratio_subtract = ...;
-template <class R1, class R2> using ratio_multiply = ...;
-template <class R1, class R2> using ratio_divide = ...;
+template <class R1, class R2> struct ratio_add;
+template <class R1, class R2> struct ratio_subtract;
+template <class R1, class R2> struct ratio_multiply;
+template <class R1, class R2> struct ratio_divide;
 
 // ratio comparison
 template <class R1, class R2> struct ratio_equal;
@@ -221,7 +220,7 @@ public:
 };
 
 template <intmax_t _Num, intmax_t _Den = 1>
-class _LIBCPP_VISIBLE ratio
+class ratio
 {
     static_assert(__static_abs<_Num>::value >= 0, "ratio numerator is out of range");
     static_assert(_Den != 0, "ratio divide by 0");
@@ -261,7 +260,7 @@ typedef ratio<   1000000000000000LL, 1LL> peta;
 typedef ratio<1000000000000000000LL, 1LL> exa;
 
 template <class _R1, class _R2>
-struct __ratio_multiply
+struct ratio_multiply
 {
 private:
     static const intmax_t __gcd_n1_d2 = __static_gcd<_R1::num, _R2::den>::value;
@@ -274,21 +273,8 @@ public:
         >::type type;
 };
 
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
-template <class _R1, class _R2> using ratio_multiply
-                                    = typename __ratio_multiply<_R1, _R2>::type;
-
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
 template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_multiply
-    : public __ratio_multiply<_R1, _R2>::type {};
-
-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
-template <class _R1, class _R2>
-struct __ratio_divide
+struct ratio_divide
 {
 private:
     static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
@@ -301,21 +287,8 @@ public:
         >::type type;
 };
 
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
-template <class _R1, class _R2> using ratio_divide
-                                      = typename __ratio_divide<_R1, _R2>::type;
-
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
 template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_divide
-    : public __ratio_divide<_R1, _R2>::type {};
-
-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
-template <class _R1, class _R2>
-struct __ratio_add
+struct ratio_add
 {
 private:
     static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
@@ -336,21 +309,8 @@ public:
         >::type type;
 };
 
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
-template <class _R1, class _R2> using ratio_add
-                                         = typename __ratio_add<_R1, _R2>::type;
-
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
 template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_add
-    : public __ratio_add<_R1, _R2>::type {};
-
-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
-template <class _R1, class _R2>
-struct __ratio_subtract
+struct ratio_subtract
 {
 private:
     static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
@@ -371,28 +331,15 @@ public:
         >::type type;
 };
 
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
-template <class _R1, class _R2> using ratio_subtract
-                                    = typename __ratio_subtract<_R1, _R2>::type;
-
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
-template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_subtract
-    : public __ratio_subtract<_R1, _R2>::type {};
-
-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
 // ratio_equal
 
 template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_equal
-    : public integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den> {};
+struct ratio_equal
+    : public integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den> {}; 
 
 template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_not_equal
-    : public integral_constant<bool, !ratio_equal<_R1, _R2>::value> {};
+struct ratio_not_equal
+    : public integral_constant<bool, !ratio_equal<_R1, _R2>::value> {}; 
 
 // ratio_less
 
@@ -450,19 +397,19 @@ struct __ratio_less<_R1, _R2, -1LL, -1LL>
 };
 
 template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_less
+struct ratio_less
     : public integral_constant<bool, __ratio_less<_R1, _R2>::value> {};
 
 template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_less_equal
+struct ratio_less_equal
     : public integral_constant<bool, !ratio_less<_R2, _R1>::value> {};
 
 template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_greater
+struct ratio_greater
     : public integral_constant<bool, ratio_less<_R2, _R1>::value> {};
 
 template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_greater_equal
+struct ratio_greater_equal
     : public integral_constant<bool, !ratio_less<_R1, _R2>::value> {};
 
 template <class _R1, class _R2>

include/scoped_allocator

@@ -1,576 +0,0 @@
-// -*- C++ -*-
-//===-------------------------- scoped_allocator --------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_SCOPED_ALLOCATOR
-#define _LIBCPP_SCOPED_ALLOCATOR
-
-/*
-    scoped_allocator synopsis
-
-namespace std
-{
-
-template <class OuterAlloc, class... InnerAllocs>
-class scoped_allocator_adaptor : public OuterAlloc
-{
-    typedef allocator_traits<OuterAlloc> OuterTraits; // exposition only
-    scoped_allocator_adaptor<InnerAllocs...> inner;   // exposition only
-public:
-
-    typedef OuterAlloc outer_allocator_type;
-    typedef see below inner_allocator_type;
-
-    typedef typename OuterTraits::value_type value_type;
-    typedef typename OuterTraits::size_type size_type;
-    typedef typename OuterTraits::difference_type difference_type;
-    typedef typename OuterTraits::pointer pointer;
-    typedef typename OuterTraits::const_pointer const_pointer;
-    typedef typename OuterTraits::void_pointer void_pointer;
-    typedef typename OuterTraits::const_void_pointer const_void_pointer;
-
-    typedef see below propagate_on_container_copy_assignment;
-    typedef see below propagate_on_container_move_assignment;
-    typedef see below propagate_on_container_swap;
-
-    template <class Tp>
-        struct rebind
-        {
-            typedef scoped_allocator_adaptor<
-                OuterTraits::template rebind_alloc<Tp>, InnerAllocs...> other;
-        };
-
-    scoped_allocator_adaptor();
-    template <class OuterA2>
-        scoped_allocator_adaptor(OuterA2&& outerAlloc,
-                                 const InnerAllocs&... innerAllocs) noexcept;
-    scoped_allocator_adaptor(const scoped_allocator_adaptor& other) noexcept;
-    scoped_allocator_adaptor(scoped_allocator_adaptor&& other) noexcept;
-    template <class OuterA2>
-        scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other) noexcept;
-    template <class OuterA2>
-        scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other) noexcept;
-
-    ~scoped_allocator_adaptor();
-
-    inner_allocator_type& inner_allocator() noexcept;
-    const inner_allocator_type& inner_allocator() const noexcept;
-
-    outer_allocator_type& outer_allocator() noexcept;
-    const outer_allocator_type& outer_allocator() const noexcept;
-
-    pointer allocate(size_type n);
-    pointer allocate(size_type n, const_void_pointer hint);
-    void deallocate(pointer p, size_type n) noexcept;
-
-    size_type max_size() const;
-    template <class T, class... Args> void construct(T* p, Args&& args);
-    template <class T1, class T2, class... Args1, class... Args2>
-        void construct(pair<T1, T2>* p, piecewise_construct t, tuple<Args1...> x,
-                       tuple<Args2...> y);
-    template <class T1, class T2>
-        void construct(pair<T1, T2>* p);
-    template <class T1, class T2, class U, class V>
-        void construct(pair<T1, T2>* p, U&& x, V&& y);
-    template <class T1, class T2, class U, class V>
-        void construct(pair<T1, T2>* p, const pair<U, V>& x);
-    template <class T1, class T2, class U, class V>
-        void construct(pair<T1, T2>* p, pair<U, V>&& x);
-    template <class T> void destroy(T* p);
-
-    template <class T> void destroy(T* p) noexcept;
-
-    scoped_allocator_adaptor select_on_container_copy_construction() const noexcept;
-};
-
-template <class OuterA1, class OuterA2, class... InnerAllocs>
-    bool
-    operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
-               const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
-
-template <class OuterA1, class OuterA2, class... InnerAllocs>
-    bool
-    operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
-               const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
-
-}  // std
-
-*/
-
-#include <__config>
-#include <memory>
-
-#pragma GCC system_header
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE)
-
-// scoped_allocator_adaptor
-
-template <class ..._Allocs>
-class scoped_allocator_adaptor;
-
-template <class ..._Allocs> struct __get_poc_copy_assignment;
-
-template <class _A0>
-struct __get_poc_copy_assignment<_A0>
-{
-    static const bool value = allocator_traits<_A0>::
-                              propagate_on_container_copy_assignment::value;
-};
-
-template <class _A0, class ..._Allocs>
-struct __get_poc_copy_assignment<_A0, _Allocs...>
-{
-    static const bool value =
-        allocator_traits<_A0>::propagate_on_container_copy_assignment::value ||
-        __get_poc_copy_assignment<_Allocs...>::value;
-};
-
-template <class ..._Allocs> struct __get_poc_move_assignment;
-
-template <class _A0>
-struct __get_poc_move_assignment<_A0>
-{
-    static const bool value = allocator_traits<_A0>::
-                              propagate_on_container_move_assignment::value;
-};
-
-template <class _A0, class ..._Allocs>
-struct __get_poc_move_assignment<_A0, _Allocs...>
-{
-    static const bool value =
-        allocator_traits<_A0>::propagate_on_container_move_assignment::value ||
-        __get_poc_move_assignment<_Allocs...>::value;
-};
-
-template <class ..._Allocs> struct __get_poc_swap;
-
-template <class _A0>
-struct __get_poc_swap<_A0>
-{
-    static const bool value = allocator_traits<_A0>::
-                              propagate_on_container_swap::value;
-};
-
-template <class _A0, class ..._Allocs>
-struct __get_poc_swap<_A0, _Allocs...>
-{
-    static const bool value =
-        allocator_traits<_A0>::propagate_on_container_swap::value ||
-        __get_poc_swap<_Allocs...>::value;
-};
-
-template <class ..._Allocs>
-class __scoped_allocator_storage;
-
-template <class _OuterAlloc, class... _InnerAllocs>
-class __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
-    : public _OuterAlloc
-{
-    typedef _OuterAlloc outer_allocator_type;
-protected:
-    typedef scoped_allocator_adaptor<_InnerAllocs...> inner_allocator_type;
-
-private:
-    inner_allocator_type __inner_;
-
-protected:
-
-    _LIBCPP_INLINE_VISIBILITY
-    __scoped_allocator_storage() _NOEXCEPT {}
-
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(_OuterA2&& __outerAlloc,
-                                   const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
-            : outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)),
-              __inner_(__innerAllocs...) {}
-
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, const _OuterA2&>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(
-            const __scoped_allocator_storage<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT
-            : outer_allocator_type(__other.outer_allocator()),
-              __inner_(__other.inner_allocator()) {}
-
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(
-            __scoped_allocator_storage<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
-            : outer_allocator_type(_STD::move(__other.outer_allocator())),
-              __inner_(_STD::move(__other.inner_allocator())) {}
-
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(_OuterA2&& __o,
-                                   const inner_allocator_type& __i) _NOEXCEPT
-            : outer_allocator_type(_STD::forward<_OuterA2>(__o)),
-              __inner_(__i)
-        {
-        }
-
-    _LIBCPP_INLINE_VISIBILITY
-    inner_allocator_type& inner_allocator() _NOEXCEPT             {return __inner_;}
-    _LIBCPP_INLINE_VISIBILITY
-    const inner_allocator_type& inner_allocator() const _NOEXCEPT {return __inner_;}
-
-    _LIBCPP_INLINE_VISIBILITY
-    outer_allocator_type& outer_allocator() _NOEXCEPT
-        {return static_cast<outer_allocator_type&>(*this);}
-    _LIBCPP_INLINE_VISIBILITY
-    const outer_allocator_type& outer_allocator() const _NOEXCEPT
-        {return static_cast<const outer_allocator_type&>(*this);}
-
-    scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
-    _LIBCPP_INLINE_VISIBILITY
-    select_on_container_copy_construction() const _NOEXCEPT
-        {
-            return scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
-            (
-                allocator_traits<outer_allocator_type>::
-                    select_on_container_copy_construction(outer_allocator()),
-                allocator_traits<inner_allocator_type>::
-                    select_on_container_copy_construction(inner_allocator())
-            );
-        }
-
-    template <class...> friend class __scoped_allocator_storage;
-};
-
-template <class _OuterAlloc>
-class __scoped_allocator_storage<_OuterAlloc>
-    : public _OuterAlloc
-{
-    typedef _OuterAlloc outer_allocator_type;
-protected:
-    typedef scoped_allocator_adaptor<_OuterAlloc> inner_allocator_type;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __scoped_allocator_storage() _NOEXCEPT {}
-
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(_OuterA2&& __outerAlloc) _NOEXCEPT
-            : outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)) {}
-
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, const _OuterA2&>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(
-            const __scoped_allocator_storage<_OuterA2>& __other) _NOEXCEPT
-            : outer_allocator_type(__other.outer_allocator()) {}
-
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(
-            __scoped_allocator_storage<_OuterA2>&& __other) _NOEXCEPT
-            : outer_allocator_type(_STD::move(__other.outer_allocator())) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    inner_allocator_type& inner_allocator() _NOEXCEPT
-        {return static_cast<inner_allocator_type&>(*this);}
-    _LIBCPP_INLINE_VISIBILITY
-    const inner_allocator_type& inner_allocator() const _NOEXCEPT
-        {return static_cast<const inner_allocator_type&>(*this);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    outer_allocator_type& outer_allocator() _NOEXCEPT
-        {return static_cast<outer_allocator_type&>(*this);}
-    _LIBCPP_INLINE_VISIBILITY
-    const outer_allocator_type& outer_allocator() const _NOEXCEPT
-        {return static_cast<const outer_allocator_type&>(*this);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    scoped_allocator_adaptor<outer_allocator_type>
-    select_on_container_copy_construction() const _NOEXCEPT
-        {return scoped_allocator_adaptor<outer_allocator_type>(
-            allocator_traits<outer_allocator_type>::
-                select_on_container_copy_construction(outer_allocator())
-        );}
-
-    __scoped_allocator_storage(const outer_allocator_type& __o,
-                               const inner_allocator_type& __i) _NOEXCEPT;
-
-    template <class...> friend class __scoped_allocator_storage;
-};
-
-// __outermost
-
-template <class _Alloc>
-decltype(declval<_Alloc>().outer_allocator(), true_type())
-__has_outer_allocator_test(_Alloc&& __a);
-
-template <class _Alloc>
-false_type
-__has_outer_allocator_test(const volatile _Alloc& __a);
-
-template <class _Alloc>
-struct __has_outer_allocator
-    : public common_type
-             <
-                 decltype(__has_outer_allocator_test(declval<_Alloc&>()))
-             >::type
-{
-};
-
-template <class _Alloc, bool = __has_outer_allocator<_Alloc>::value>
-struct __outermost
-{
-    typedef _Alloc type;
-    _LIBCPP_INLINE_VISIBILITY
-    type& operator()(type& __a) const _NOEXCEPT {return __a;}
-};
-
-template <class _Alloc>
-struct __outermost<_Alloc, true>
-{
-    typedef typename remove_reference
-                     <
-                        decltype(_STD::declval<_Alloc>().outer_allocator())
-                     >::type                                    _OuterAlloc;
-    typedef typename __outermost<_OuterAlloc>::type             type;
-    _LIBCPP_INLINE_VISIBILITY
-    type& operator()(_Alloc& __a) const _NOEXCEPT
-        {return __outermost<_OuterAlloc>()(__a.outer_allocator());}
-};
-
-template <class _OuterAlloc, class... _InnerAllocs>
-class _LIBCPP_VISIBLE scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>
-    : public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
-{
-    typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> base;
-    typedef allocator_traits<_OuterAlloc>             _OuterTraits;
-public:
-    typedef _OuterAlloc                               outer_allocator_type;
-    typedef typename base::inner_allocator_type       inner_allocator_type;
-    typedef typename _OuterTraits::size_type          size_type;
-    typedef typename _OuterTraits::difference_type    difference_type;
-    typedef typename _OuterTraits::pointer            pointer;
-    typedef typename _OuterTraits::const_pointer      const_pointer;
-    typedef typename _OuterTraits::void_pointer       void_pointer;
-    typedef typename _OuterTraits::const_void_pointer const_void_pointer;
-
-    typedef integral_constant
-            <
-                bool,
-                __get_poc_copy_assignment<outer_allocator_type,
-                                          _InnerAllocs...>::value
-            > propagate_on_container_copy_assignment;
-    typedef integral_constant
-            <
-                bool,
-                __get_poc_move_assignment<outer_allocator_type,
-                                          _InnerAllocs...>::value
-            > propagate_on_container_move_assignment;
-    typedef integral_constant
-            <
-                bool,
-                __get_poc_swap<outer_allocator_type, _InnerAllocs...>::value
-            > propagate_on_container_swap;
-
-    template <class _Tp>
-    struct rebind
-    {
-        typedef scoped_allocator_adaptor
-        <
-            typename _OuterTraits::template rebind_alloc<_Tp>, _InnerAllocs...
-        > other;
-    };
-
-    _LIBCPP_INLINE_VISIBILITY
-    scoped_allocator_adaptor() _NOEXCEPT {}
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        scoped_allocator_adaptor(_OuterA2&& __outerAlloc,
-                                 const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
-            : base(_STD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
-    // scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default;
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, const _OuterA2&>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        scoped_allocator_adaptor(
-            const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT
-                : base(__other) {}
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        scoped_allocator_adaptor(
-            scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
-                : base(_STD::move(__other)) {}
-
-    // ~scoped_allocator_adaptor() = default;
-
-    _LIBCPP_INLINE_VISIBILITY
-    inner_allocator_type& inner_allocator() _NOEXCEPT
-        {return base::inner_allocator();}
-    _LIBCPP_INLINE_VISIBILITY
-    const inner_allocator_type& inner_allocator() const _NOEXCEPT
-        {return base::inner_allocator();}
-
-    _LIBCPP_INLINE_VISIBILITY
-    outer_allocator_type& outer_allocator() _NOEXCEPT
-        {return base::outer_allocator();}
-    _LIBCPP_INLINE_VISIBILITY
-    const outer_allocator_type& outer_allocator() const _NOEXCEPT
-        {return base::outer_allocator();}
-
-    _LIBCPP_INLINE_VISIBILITY
-    pointer allocate(size_type __n)
-        {return allocator_traits<outer_allocator_type>::
-            allocate(outer_allocator(), __n);}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer allocate(size_type __n, const_void_pointer __hint)
-        {return allocator_traits<outer_allocator_type>::
-            allocate(outer_allocator(), __n, __hint);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    void deallocate(pointer __p, size_type __n) _NOEXCEPT
-        {allocator_traits<outer_allocator_type>::
-            deallocate(outer_allocator(), __p, __n);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const
-        {return allocator_traits<outer_allocator_type>::max_size(outer_allocator());}
-
-    template <class _Tp, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        void construct(_Tp* __p, _Args&& ...__args)
-            {__construct(__uses_alloc_ctor<_Tp, inner_allocator_type, _Args...>(),
-                         __p, _STD::forward<_Args>(__args)...);}
-    template <class _Tp>
-        _LIBCPP_INLINE_VISIBILITY
-        void destroy(_Tp* __p)
-            {
-                typedef __outermost<outer_allocator_type> _OM;
-                allocator_traits<typename _OM::type>::
-                                         destroy(_OM()(outer_allocator()), __p);
-            }
-
-    _LIBCPP_INLINE_VISIBILITY
-    scoped_allocator_adaptor select_on_container_copy_construction() const _NOEXCEPT
-        {return base::select_on_container_copy_construction();}
-
-private:
-
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-    _LIBCPP_INLINE_VISIBILITY
-    scoped_allocator_adaptor(_OuterA2&& __o,
-                             const inner_allocator_type& __i) _NOEXCEPT
-        : base(_STD::forward<_OuterA2>(__o), __i) {}
-
-    template <class _Tp, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        void __construct(integral_constant<int, 0>, _Tp* __p, _Args&& ...__args)
-            {
-                typedef __outermost<outer_allocator_type> _OM;
-                allocator_traits<typename _OM::type>::construct
-                (
-                    _OM()(outer_allocator()),
-                    __p,
-                    _STD::forward<_Args>(__args)...
-                );
-            }
-
-    template <class _Tp, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        void __construct(integral_constant<int, 1>, _Tp* __p, _Args&& ...__args)
-            {
-                typedef __outermost<outer_allocator_type> _OM;
-                allocator_traits<typename _OM::type>::construct
-                (
-                    _OM()(outer_allocator()),
-                    __p,
-                    allocator_arg,
-                    inner_allocator(),
-                    _STD::forward<_Args>(__args)...
-                );
-            }
-
-    template <class _Tp, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        void __construct(integral_constant<int, 2>, _Tp* __p, _Args&& ...__args)
-            {
-                typedef __outermost<outer_allocator_type> _OM;
-                allocator_traits<typename _OM::type>::construct
-                (
-                    _OM()(outer_allocator()),
-                    __p,
-                    _STD::forward<_Args>(__args)...,
-                    inner_allocator()
-                );
-            }
-
-    template <class...> friend class __scoped_allocator_storage;
-};
-
-template <class _OuterA1, class _OuterA2>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const scoped_allocator_adaptor<_OuterA1>& __a,
-           const scoped_allocator_adaptor<_OuterA2>& __b) _NOEXCEPT
-{
-    return __a.outer_allocator() == __b.outer_allocator();
-}
-
-template <class _OuterA1, class _OuterA2, class _InnerA0, class... _InnerAllocs>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const scoped_allocator_adaptor<_OuterA1, _InnerA0, _InnerAllocs...>& __a,
-           const scoped_allocator_adaptor<_OuterA2, _InnerA0, _InnerAllocs...>& __b) _NOEXCEPT
-{
-    return __a.outer_allocator() == __b.outer_allocator() &&
-           __a.inner_allocator() == __b.inner_allocator();
-}
-
-template <class _OuterA1, class _OuterA2, class... _InnerAllocs>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a,
-           const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b) _NOEXCEPT
-{
-    return !(__a == __b);
-}
-
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE)
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif  // _LIBCPP_SCOPED_ALLOCATOR

include/set

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -42,12 +42,7 @@ public:
     typedef std::reverse_iterator<const_iterator>    const_reverse_iterator;
 
     // construct/copy/destroy:
-    set()
-        noexcept(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_default_constructible<key_compare>::value &&
-            is_nothrow_copy_constructible<key_compare>::value);
-    explicit set(const value_compare& comp);
+    explicit set(const value_compare& comp = value_compare());
     set(const value_compare& comp, const allocator_type& a);
     template <class InputIterator>
         set(InputIterator first, InputIterator last,
@@ -56,10 +51,7 @@ public:
         set(InputIterator first, InputIterator last, const value_compare& comp,
             const allocator_type& a);
     set(const set& s);
-    set(set&& s)
-        noexcept(
-            is_nothrow_move_constructible<allocator_type>::value &&
-            is_nothrow_move_constructible<key_compare>::value);
+    set(set&& s);
     explicit set(const allocator_type& a);
     set(const set& s, const allocator_type& a);
     set(set&& s, const allocator_type& a);
@@ -69,33 +61,29 @@ public:
     ~set();
 
     set& operator=(const set& s);
-    set& operator=(set&& s)
-        noexcept(
-            allocator_type::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<allocator_type>::value &&
-            is_nothrow_move_assignable<key_compare>::value);
+    set& operator=(set&& s);
     set& operator=(initializer_list<value_type> il);
 
     // iterators:
-          iterator begin() noexcept;
-    const_iterator begin() const noexcept;
-          iterator end() noexcept;
-    const_iterator end()   const noexcept;
+          iterator begin();
+    const_iterator begin() const;
+          iterator end();
+    const_iterator end()   const;
 
-          reverse_iterator rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-          reverse_iterator rend() noexcept;
-    const_reverse_iterator rend()   const noexcept;
+          reverse_iterator rbegin();
+    const_reverse_iterator rbegin() const;
+          reverse_iterator rend();
+    const_reverse_iterator rend()   const;
 
-    const_iterator         cbegin()  const noexcept;
-    const_iterator         cend()    const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend()   const noexcept;
+    const_iterator         cbegin()  const;
+    const_iterator         cend()    const;
+    const_reverse_iterator crbegin() const;
+    const_reverse_iterator crend()   const;
 
     // capacity:
-    bool      empty()    const noexcept;
-    size_type size()     const noexcept;
-    size_type max_size() const noexcept;
+    bool      empty()    const;
+    size_type size()     const;
+    size_type max_size() const;
 
     // modifiers:
     template <class... Args>
@@ -113,16 +101,12 @@ public:
     iterator  erase(const_iterator position);
     size_type erase(const key_type& k);
     iterator  erase(const_iterator first, const_iterator last);
-    void clear() noexcept;
+    void clear();
 
-    void swap(set& s)
-        noexcept(
-            __is_nothrow_swappable<key_compare>::value &&
-            (!allocator_type::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<allocator_type>::value));
+    void swap(set& s);
 
     // observers:
-    allocator_type get_allocator() const noexcept;
+    allocator_type get_allocator() const;
     key_compare    key_comp()      const;
     value_compare  value_comp()    const;
 
@@ -171,8 +155,8 @@ operator<=(const set<Key, Compare, Allocator>& x,
 // specialized algorithms:
 template <class Key, class Compare, class Allocator>
 void
-swap(set<Key, Compare, Allocator>& x, set<Key, Compare, Allocator>& y)
-    noexcept(noexcept(x.swap(y)));
+swap(set<Key, Compare, Allocator>& x, set<Key, Compare, Allocator>& y);
+
 
 template <class Key, class Compare = less<Key>,
           class Allocator = allocator<Key>>
@@ -198,12 +182,7 @@ public:
     typedef std::reverse_iterator<const_iterator>    const_reverse_iterator;
 
     // construct/copy/destroy:
-    multiset()
-        noexcept(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_default_constructible<key_compare>::value &&
-            is_nothrow_copy_constructible<key_compare>::value);
-    explicit multiset(const value_compare& comp);
+    explicit multiset(const value_compare& comp = value_compare());
     multiset(const value_compare& comp, const allocator_type& a);
     template <class InputIterator>
         multiset(InputIterator first, InputIterator last,
@@ -212,10 +191,7 @@ public:
         multiset(InputIterator first, InputIterator last,
                  const value_compare& comp, const allocator_type& a);
     multiset(const multiset& s);
-    multiset(multiset&& s)
-        noexcept(
-            is_nothrow_move_constructible<allocator_type>::value &&
-            is_nothrow_move_constructible<key_compare>::value);
+    multiset(multiset&& s);
     explicit multiset(const allocator_type& a);
     multiset(const multiset& s, const allocator_type& a);
     multiset(multiset&& s, const allocator_type& a);
@@ -225,33 +201,29 @@ public:
     ~multiset();
 
     multiset& operator=(const multiset& s);
-    multiset& operator=(multiset&& s)
-        noexcept(
-            allocator_type::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<allocator_type>::value &&
-            is_nothrow_move_assignable<key_compare>::value);
+    multiset& operator=(multiset&& s);
     multiset& operator=(initializer_list<value_type> il);
 
     // iterators:
-          iterator begin() noexcept;
-    const_iterator begin() const noexcept;
-          iterator end() noexcept;
-    const_iterator end()   const noexcept;
+          iterator begin();
+    const_iterator begin() const;
+          iterator end();
+    const_iterator end()   const;
 
-          reverse_iterator rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-          reverse_iterator rend() noexcept;
-    const_reverse_iterator rend()   const noexcept;
+          reverse_iterator rbegin();
+    const_reverse_iterator rbegin() const;
+          reverse_iterator rend();
+    const_reverse_iterator rend()   const;
 
-    const_iterator         cbegin()  const noexcept;
-    const_iterator         cend()    const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend()   const noexcept;
+    const_iterator         cbegin()  const;
+    const_iterator         cend()    const;
+    const_reverse_iterator crbegin() const;
+    const_reverse_iterator crend()   const;
 
     // capacity:
-    bool      empty()    const noexcept;
-    size_type size()     const noexcept;
-    size_type max_size() const noexcept;
+    bool      empty()    const;
+    size_type size()     const;
+    size_type max_size() const;
 
     // modifiers:
     template <class... Args>
@@ -269,16 +241,12 @@ public:
     iterator  erase(const_iterator position);
     size_type erase(const key_type& k);
     iterator  erase(const_iterator first, const_iterator last);
-    void clear() noexcept;
+    void clear();
 
-    void swap(multiset& s)
-        noexcept(
-            __is_nothrow_swappable<key_compare>::value &&
-            (!allocator_type::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<allocator_type>::value));
+    void swap(multiset& s);
 
     // observers:
-    allocator_type get_allocator() const noexcept;
+    allocator_type get_allocator() const;
     key_compare    key_comp()      const;
     value_compare  value_comp()    const;
 
@@ -327,8 +295,7 @@ operator<=(const multiset<Key, Compare, Allocator>& x,
 // specialized algorithms:
 template <class Key, class Compare, class Allocator>
 void
-swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y)
-    noexcept(noexcept(x.swap(y)));
+swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y);
 
 }  // std
 
@@ -344,7 +311,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Key, class _Compare = less<_Key>,
           class _Allocator = allocator<_Key> >
-class _LIBCPP_VISIBLE set
+class set
 {
 public:
     // types:
@@ -373,18 +340,11 @@ public:
     typedef _STD::reverse_iterator<iterator>       reverse_iterator;
     typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
 
-    _LIBCPP_INLINE_VISIBILITY
     explicit set(const value_compare& __comp = value_compare())
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_default_constructible<key_compare>::value &&
-            is_nothrow_copy_constructible<key_compare>::value)
         : __tree_(__comp) {}
-    _LIBCPP_INLINE_VISIBILITY
     set(const value_compare& __comp, const allocator_type& __a)
         : __tree_(__comp, __a) {}
     template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
         set(_InputIterator __f, _InputIterator __l,
             const value_compare& __comp = value_compare())
         : __tree_(__comp)
@@ -393,7 +353,6 @@ public:
         }
 
     template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
         set(_InputIterator __f, _InputIterator __l, const value_compare& __comp,
             const allocator_type& __a)
         : __tree_(__comp, __a)
@@ -401,43 +360,36 @@ public:
             insert(__f, __l);
         }
 
-    _LIBCPP_INLINE_VISIBILITY
     set(const set& __s)
         : __tree_(__s.__tree_)
         {
             insert(__s.begin(), __s.end());
         }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     set(set&& __s)
-        _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
         : __tree_(_STD::move(__s.__tree_)) {}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY
     explicit set(const allocator_type& __a)
         : __tree_(__a) {}
 
-    _LIBCPP_INLINE_VISIBILITY
     set(const set& __s, const allocator_type& __a)
         : __tree_(__s.__tree_.value_comp(), __a)
         {
             insert(__s.begin(), __s.end());
         }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     set(set&& __s, const allocator_type& __a);
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
     set(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
         : __tree_(__comp)
         {
             insert(__il.begin(), __il.end());
         }
 
-    _LIBCPP_INLINE_VISIBILITY
     set(initializer_list<value_type> __il, const value_compare& __comp,
         const allocator_type& __a)
         : __tree_(__comp, __a)
@@ -445,151 +397,103 @@ public:
             insert(__il.begin(), __il.end());
         }
 
-    _LIBCPP_INLINE_VISIBILITY
     set& operator=(initializer_list<value_type> __il)
         {
             __tree_.__assign_unique(__il.begin(), __il.end());
             return *this;
         }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     set& operator=(set&& __s)
-        _NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
         {
             __tree_ = _STD::move(__s.__tree_);
             return *this;
         }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY
-          iterator begin() _NOEXCEPT       {return __tree_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-          iterator end() _NOEXCEPT         {return __tree_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()   const _NOEXCEPT {return __tree_.end();}
+          iterator begin()       {return __tree_.begin();}
+    const_iterator begin() const {return __tree_.begin();}
+          iterator end()         {return __tree_.end();}
+    const_iterator end()   const {return __tree_.end();}
 
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rbegin() _NOEXCEPT
-            {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rbegin() const _NOEXCEPT
-        {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rend() _NOEXCEPT
-            {return reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rend() const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
+          reverse_iterator rbegin()       {return       reverse_iterator(end());}
+    const_reverse_iterator rbegin() const {return const_reverse_iterator(end());}
+          reverse_iterator rend()         {return       reverse_iterator(begin());}
+    const_reverse_iterator rend()   const {return const_reverse_iterator(begin());}
 
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin()  const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crend() const _NOEXCEPT {return rend();}
+    const_iterator         cbegin()  const {return begin();}
+    const_iterator         cend()    const {return end();}
+    const_reverse_iterator crbegin() const {return rbegin();}
+    const_reverse_iterator crend()   const {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT {return __tree_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
+    bool      empty()    const {return __tree_.size() == 0;}
+    size_type size()     const {return __tree_.size();}
+    size_type max_size() const {return __tree_.max_size();}
 
     // modifiers:
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+#ifdef _LIBCPP_MOVE
     template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> emplace(_Args&&... __args)
             {return __tree_.__emplace_unique(_STD::forward<_Args>(__args)...);}
     template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
         iterator emplace_hint(const_iterator __p, _Args&&... __args)
             {return __tree_.__emplace_hint_unique(__p, _STD::forward<_Args>(__args)...);}
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
-    _LIBCPP_INLINE_VISIBILITY
+#endif
     pair<iterator,bool> insert(const value_type& __v)
         {return __tree_.__insert_unique(__v);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     pair<iterator,bool> insert(value_type&& __v)
         {return __tree_.__insert_unique(_STD::move(__v));}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#endif
     iterator insert(const_iterator __p, const value_type& __v)
         {return __tree_.__insert_unique(__p, __v);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     iterator insert(const_iterator __p, value_type&& __v)
         {return __tree_.__insert_unique(__p, _STD::move(__v));}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
         void insert(_InputIterator __f, _InputIterator __l)
         {
             for (const_iterator __e = cend(); __f != __l; ++__f)
                 __tree_.__insert_unique(__e, *__f);
         }
 
-    _LIBCPP_INLINE_VISIBILITY
     void insert(initializer_list<value_type> __il)
         {insert(__il.begin(), __il.end());}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator  erase(const_iterator __p) {return __tree_.erase(__p);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type erase(const key_type& __k)
         {return __tree_.__erase_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     iterator  erase(const_iterator __f, const_iterator __l)
         {return __tree_.erase(__f, __l);}
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__tree_.clear();}
+    void clear() {__tree_.clear();}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(set& __s) _NOEXCEPT_(__is_nothrow_swappable<__base>::value)
-        {__tree_.swap(__s.__tree_);}
+    void swap(set& __s) {__tree_.swap(__s.__tree_);}
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT {return __tree_.__alloc();}
-    _LIBCPP_INLINE_VISIBILITY
+    allocator_type get_allocator() const {return __tree_.__alloc();}
     key_compare    key_comp()      const {return __tree_.value_comp();}
-    _LIBCPP_INLINE_VISIBILITY
     value_compare  value_comp()    const {return __tree_.value_comp();}
 
     // set operations:
-    _LIBCPP_INLINE_VISIBILITY
     iterator find(const key_type& __k)             {return __tree_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type      count(const key_type& __k) const
         {return __tree_.__count_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     iterator lower_bound(const key_type& __k)
         {return __tree_.lower_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator lower_bound(const key_type& __k) const
         {return __tree_.lower_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     iterator upper_bound(const key_type& __k)
         {return __tree_.upper_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator upper_bound(const key_type& __k) const
         {return __tree_.upper_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<iterator,iterator> equal_range(const key_type& __k)
         {return __tree_.__equal_range_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
         {return __tree_.__equal_range_unique(__k);}
 };
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Key, class _Compare, class _Allocator>
 set<_Key, _Compare, _Allocator>::set(set&& __s, const allocator_type& __a)
@@ -603,10 +507,10 @@ set<_Key, _Compare, _Allocator>::set(set&& __s, const allocator_type& __a)
     }
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator==(const set<_Key, _Compare, _Allocator>& __x,
            const set<_Key, _Compare, _Allocator>& __y)
@@ -615,7 +519,7 @@ operator==(const set<_Key, _Compare, _Allocator>& __x,
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator< (const set<_Key, _Compare, _Allocator>& __x,
            const set<_Key, _Compare, _Allocator>& __y)
@@ -624,7 +528,7 @@ operator< (const set<_Key, _Compare, _Allocator>& __x,
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator!=(const set<_Key, _Compare, _Allocator>& __x,
            const set<_Key, _Compare, _Allocator>& __y)
@@ -633,7 +537,7 @@ operator!=(const set<_Key, _Compare, _Allocator>& __x,
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator> (const set<_Key, _Compare, _Allocator>& __x,
            const set<_Key, _Compare, _Allocator>& __y)
@@ -642,7 +546,7 @@ operator> (const set<_Key, _Compare, _Allocator>& __x,
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator>=(const set<_Key, _Compare, _Allocator>& __x,
            const set<_Key, _Compare, _Allocator>& __y)
@@ -651,7 +555,7 @@ operator>=(const set<_Key, _Compare, _Allocator>& __x,
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator<=(const set<_Key, _Compare, _Allocator>& __x,
            const set<_Key, _Compare, _Allocator>& __y)
@@ -661,18 +565,18 @@ operator<=(const set<_Key, _Compare, _Allocator>& __x,
 
 // specialized algorithms:
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(set<_Key, _Compare, _Allocator>& __x,
      set<_Key, _Compare, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
+
 template <class _Key, class _Compare = less<_Key>,
           class _Allocator = allocator<_Key> >
-class _LIBCPP_VISIBLE multiset
+class multiset
 {
 public:
     // types:
@@ -702,18 +606,11 @@ public:
     typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
 
     // construct/copy/destroy:
-    _LIBCPP_INLINE_VISIBILITY
     explicit multiset(const value_compare& __comp = value_compare())
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_default_constructible<key_compare>::value &&
-            is_nothrow_copy_constructible<key_compare>::value)
         : __tree_(__comp) {}
-    _LIBCPP_INLINE_VISIBILITY
     multiset(const value_compare& __comp, const allocator_type& __a)
         : __tree_(__comp, __a) {}
     template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
         multiset(_InputIterator __f, _InputIterator __l,
                  const value_compare& __comp = value_compare())
         : __tree_(__comp)
@@ -722,7 +619,6 @@ public:
         }
 
     template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
         multiset(_InputIterator __f, _InputIterator __l,
                  const value_compare& __comp, const allocator_type& __a)
         : __tree_(__comp, __a)
@@ -730,7 +626,6 @@ public:
             insert(__f, __l);
         }
 
-    _LIBCPP_INLINE_VISIBILITY
     multiset(const multiset& __s)
         : __tree_(__s.__tree_.value_comp(),
           __alloc_traits::select_on_container_copy_construction(__s.__tree_.__alloc()))
@@ -738,33 +633,27 @@ public:
             insert(__s.begin(), __s.end());
         }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     multiset(multiset&& __s)
-        _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
         : __tree_(_STD::move(__s.__tree_)) {}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#endif
     explicit multiset(const allocator_type& __a)
         : __tree_(__a) {}
-    _LIBCPP_INLINE_VISIBILITY
     multiset(const multiset& __s, const allocator_type& __a)
         : __tree_(__s.__tree_.value_comp(), __a)
         {
             insert(__s.begin(), __s.end());
         }
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     multiset(multiset&& __s, const allocator_type& __a);
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
     multiset(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
         : __tree_(__comp)
         {
             insert(__il.begin(), __il.end());
         }
 
-    _LIBCPP_INLINE_VISIBILITY
     multiset(initializer_list<value_type> __il, const value_compare& __comp,
         const allocator_type& __a)
         : __tree_(__comp, __a)
@@ -772,151 +661,102 @@ public:
             insert(__il.begin(), __il.end());
         }
 
-    _LIBCPP_INLINE_VISIBILITY
     multiset& operator=(initializer_list<value_type> __il)
         {
             __tree_.__assign_multi(__il.begin(), __il.end());
             return *this;
         }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     multiset& operator=(multiset&& __s)
-        _NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
         {
             __tree_ = _STD::move(__s.__tree_);
             return *this;
         }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY
-          iterator begin() _NOEXCEPT       {return __tree_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-          iterator end() _NOEXCEPT         {return __tree_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()   const _NOEXCEPT {return __tree_.end();}
+          iterator begin()       {return __tree_.begin();}
+    const_iterator begin() const {return __tree_.begin();}
+          iterator end()         {return __tree_.end();}
+    const_iterator end()   const {return __tree_.end();}
 
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rbegin() _NOEXCEPT
-            {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rbegin() const _NOEXCEPT
-        {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rend() _NOEXCEPT
-            {return       reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rend() const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
+          reverse_iterator rbegin()       {return       reverse_iterator(end());}
+    const_reverse_iterator rbegin() const {return const_reverse_iterator(end());}
+          reverse_iterator rend()         {return       reverse_iterator(begin());}
+    const_reverse_iterator rend()   const {return const_reverse_iterator(begin());}
 
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin()  const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crend() const _NOEXCEPT {return rend();}
+    const_iterator         cbegin()  const {return begin();}
+    const_iterator         cend()    const {return end();}
+    const_reverse_iterator crbegin() const {return rbegin();}
+    const_reverse_iterator crend()   const {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT {return __tree_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
+    bool      empty()    const {return __tree_.size() == 0;}
+    size_type size()     const {return __tree_.size();}
+    size_type max_size() const {return __tree_.max_size();}
 
     // modifiers:
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+#ifdef _LIBCPP_MOVE
     template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
         iterator emplace(_Args&&... __args)
             {return __tree_.__emplace_multi(_STD::forward<_Args>(__args)...);}
     template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
         iterator emplace_hint(const_iterator __p, _Args&&... __args)
             {return __tree_.__emplace_hint_multi(__p, _STD::forward<_Args>(__args)...);}
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
-    _LIBCPP_INLINE_VISIBILITY
+#endif
     iterator insert(const value_type& __v)
         {return __tree_.__insert_multi(__v);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     iterator insert(value_type&& __v)
         {return __tree_.__insert_multi(_STD::move(__v));}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#endif
     iterator insert(const_iterator __p, const value_type& __v)
         {return __tree_.__insert_multi(__p, __v);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     iterator insert(const_iterator __p, value_type&& __v)
         {return __tree_.__insert_multi(_STD::move(__v));}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
         void insert(_InputIterator __f, _InputIterator __l)
         {
             for (const_iterator __e = cend(); __f != __l; ++__f)
                 __tree_.__insert_multi(__e, *__f);
         }
 
-    _LIBCPP_INLINE_VISIBILITY
     void insert(initializer_list<value_type> __il)
         {insert(__il.begin(), __il.end());}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator  erase(const_iterator __p) {return __tree_.erase(__p);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type erase(const key_type& __k) {return __tree_.__erase_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     iterator  erase(const_iterator __f, const_iterator __l)
         {return __tree_.erase(__f, __l);}
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__tree_.clear();}
+    void clear() {__tree_.clear();}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(multiset& __s)
-        _NOEXCEPT_(__is_nothrow_swappable<__base>::value)
-        {__tree_.swap(__s.__tree_);}
+    void swap(multiset& __s) {__tree_.swap(__s.__tree_);}
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT {return __tree_.__alloc();}
-    _LIBCPP_INLINE_VISIBILITY
+    allocator_type get_allocator() const {return __tree_.__alloc();}
     key_compare    key_comp()      const {return __tree_.value_comp();}
-    _LIBCPP_INLINE_VISIBILITY
     value_compare  value_comp()    const {return __tree_.value_comp();}
 
     // set operations:
-    _LIBCPP_INLINE_VISIBILITY
     iterator find(const key_type& __k)             {return __tree_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type      count(const key_type& __k) const
         {return __tree_.__count_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     iterator lower_bound(const key_type& __k)
         {return __tree_.lower_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator lower_bound(const key_type& __k) const
             {return __tree_.lower_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     iterator upper_bound(const key_type& __k)
             {return __tree_.upper_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator upper_bound(const key_type& __k) const
             {return __tree_.upper_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<iterator,iterator>             equal_range(const key_type& __k)
             {return __tree_.__equal_range_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
             {return __tree_.__equal_range_multi(__k);}
 };
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Key, class _Compare, class _Allocator>
 multiset<_Key, _Compare, _Allocator>::multiset(multiset&& __s, const allocator_type& __a)
@@ -930,10 +770,10 @@ multiset<_Key, _Compare, _Allocator>::multiset(multiset&& __s, const allocator_t
     }
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator==(const multiset<_Key, _Compare, _Allocator>& __x,
            const multiset<_Key, _Compare, _Allocator>& __y)
@@ -942,7 +782,7 @@ operator==(const multiset<_Key, _Compare, _Allocator>& __x,
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator< (const multiset<_Key, _Compare, _Allocator>& __x,
            const multiset<_Key, _Compare, _Allocator>& __y)
@@ -951,7 +791,7 @@ operator< (const multiset<_Key, _Compare, _Allocator>& __x,
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator!=(const multiset<_Key, _Compare, _Allocator>& __x,
            const multiset<_Key, _Compare, _Allocator>& __y)
@@ -960,7 +800,7 @@ operator!=(const multiset<_Key, _Compare, _Allocator>& __x,
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator> (const multiset<_Key, _Compare, _Allocator>& __x,
            const multiset<_Key, _Compare, _Allocator>& __y)
@@ -969,7 +809,7 @@ operator> (const multiset<_Key, _Compare, _Allocator>& __x,
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator>=(const multiset<_Key, _Compare, _Allocator>& __x,
            const multiset<_Key, _Compare, _Allocator>& __y)
@@ -978,7 +818,7 @@ operator>=(const multiset<_Key, _Compare, _Allocator>& __x,
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator<=(const multiset<_Key, _Compare, _Allocator>& __x,
            const multiset<_Key, _Compare, _Allocator>& __y)
@@ -987,15 +827,15 @@ operator<=(const multiset<_Key, _Compare, _Allocator>& __x,
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(multiset<_Key, _Compare, _Allocator>& __x,
      multiset<_Key, _Compare, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_SET

include/sstream

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -182,7 +182,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // basic_stringbuf
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_VISIBLE basic_stringbuf
+class basic_stringbuf
     : public basic_streambuf<_CharT, _Traits>
 {
 public:
@@ -206,12 +206,12 @@ public:
     explicit basic_stringbuf(ios_base::openmode __wch = ios_base::in | ios_base::out);
     explicit basic_stringbuf(const string_type& __s,
                              ios_base::openmode __wch = ios_base::in | ios_base::out);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_stringbuf(basic_stringbuf&& __rhs);
 #endif
 
     // 27.8.1.2 Assign and swap:
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_stringbuf& operator=(basic_stringbuf&& __rhs);
 #endif
     void swap(basic_stringbuf& __rhs);
@@ -250,7 +250,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(const string_type&
     str(__s);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(basic_stringbuf&& __rhs)
@@ -298,7 +298,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::operator=(basic_stringbuf&& __rhs)
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _CharT, class _Traits, class _Allocator>
 void
@@ -434,7 +434,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c)
 #ifndef _LIBCPP_NO_EXCEPTIONS
             try
             {
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
                 ptrdiff_t __nout = this->pptr()  - this->pbase();
                 ptrdiff_t __hm = __hm_ - this->pbase();
                 __str_.push_back(char_type());
@@ -449,9 +449,9 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c)
             {
                 return traits_type::eof();
             }
-#endif  // _LIBCPP_NO_EXCEPTIONS
+#endif
         }
-        __hm_ = _STD::max(this->pptr() + 1, __hm_);
+        __hm_ = max(this->pptr() + 1, __hm_);
         if (__mode_ & ios_base::in)
         {
             char_type* __p = const_cast<char_type*>(__str_.data());
@@ -525,7 +525,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::seekpos(pos_type __sp,
 // basic_istringstream
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_VISIBLE basic_istringstream
+class basic_istringstream
     : public basic_istream<_CharT, _Traits>
 {
 public:
@@ -546,12 +546,12 @@ public:
     explicit basic_istringstream(ios_base::openmode __wch = ios_base::in);
     explicit basic_istringstream(const string_type& __s,
                                  ios_base::openmode __wch = ios_base::in);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_istringstream(basic_istringstream&& __rhs);
 
     // 27.8.2.2 Assign and swap:
     basic_istringstream& operator=(basic_istringstream&& __rhs);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     void swap(basic_istringstream& __rhs);
 
     // 27.8.2.3 Members:
@@ -577,7 +577,7 @@ basic_istringstream<_CharT, _Traits, _Allocator>::basic_istringstream(const stri
 {
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -597,7 +597,7 @@ basic_istringstream<_CharT, _Traits, _Allocator>::operator=(basic_istringstream&
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -644,7 +644,7 @@ basic_istringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
 // basic_ostringstream
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_VISIBLE basic_ostringstream
+class basic_ostringstream
     : public basic_ostream<_CharT, _Traits>
 {
 public:
@@ -665,12 +665,12 @@ public:
     explicit basic_ostringstream(ios_base::openmode __wch = ios_base::out);
     explicit basic_ostringstream(const string_type& __s,
                                  ios_base::openmode __wch = ios_base::out);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_ostringstream(basic_ostringstream&& __rhs);
 
     // 27.8.2.2 Assign and swap:
     basic_ostringstream& operator=(basic_ostringstream&& __rhs);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     void swap(basic_ostringstream& __rhs);
 
     // 27.8.2.3 Members:
@@ -696,7 +696,7 @@ basic_ostringstream<_CharT, _Traits, _Allocator>::basic_ostringstream(const stri
 {
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -716,7 +716,7 @@ basic_ostringstream<_CharT, _Traits, _Allocator>::operator=(basic_ostringstream&
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -763,7 +763,7 @@ basic_ostringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
 // basic_stringstream
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_VISIBLE basic_stringstream
+class basic_stringstream
     : public basic_iostream<_CharT, _Traits>
 {
 public:
@@ -784,12 +784,12 @@ public:
     explicit basic_stringstream(ios_base::openmode __wch = ios_base::in | ios_base::out);
     explicit basic_stringstream(const string_type& __s,
                                 ios_base::openmode __wch = ios_base::in | ios_base::out);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     basic_stringstream(basic_stringstream&& __rhs);
 
     // 27.8.2.2 Assign and swap:
     basic_stringstream& operator=(basic_stringstream&& __rhs);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     void swap(basic_stringstream& __rhs);
 
     // 27.8.2.3 Members:
@@ -815,7 +815,7 @@ basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(const string
 {
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -835,7 +835,7 @@ basic_stringstream<_CharT, _Traits, _Allocator>::operator=(basic_stringstream&&
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY

include/stack

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -31,21 +31,14 @@ protected:
     container_type c;
 
 public:
-    stack() = default;
-    ~stack() = default;
-
-    stack(const stack& q) = default;
-    stack(stack&& q) = default;
-
-    stack& operator=(const stack& q) = default;
-    stack& operator=(stack&& q) = default;
-
+    explicit stack();
     explicit stack(const container_type& c);
     explicit stack(container_type&& c);
+    stack(stack&& s);
+    stack& operator=(stack&& s);
     template <class Alloc> explicit stack(const Alloc& a);
     template <class Alloc> stack(const container_type& c, const Alloc& a);
     template <class Alloc> stack(container_type&& c, const Alloc& a);
-    template <class Alloc> stack(const stack& c, const Alloc& a);
     template <class Alloc> stack(stack&& c, const Alloc& a);
 
     bool empty() const;
@@ -58,7 +51,7 @@ public:
     template <class... Args> void emplace(Args&&... args);
     void pop();
 
-    void swap(stack& c) noexcept(noexcept(swap(c, q.c)));
+    void swap(stack& c);
 };
 
 template <class T, class Container>
@@ -75,8 +68,7 @@ template <class T, class Container>
   bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
 
 template <class T, class Container>
-  void swap(stack<T, Container>& x, stack<T, Container>& y)
-  noexcept(noexcept(x.swap(y)));
+  void swap(stack<T, Container>& x, stack<T, Container>& y);
 
 }  // std
 
@@ -100,7 +92,7 @@ bool
 operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container = deque<_Tp> >
-class _LIBCPP_VISIBLE stack
+class stack
 {
 public:
     typedef _Container                               container_type;
@@ -113,97 +105,55 @@ protected:
     container_type c;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    stack()
-        _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value)
-        : c() {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    stack(const stack& __q) : c(__q.c) {}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    stack(stack&& __q)
-        _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
-        : c(_STD::move(__q.c)) {}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    _LIBCPP_INLINE_VISIBILITY
-    stack& operator=(const stack& __q) {c = __q.c; return *this;}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    stack& operator=(stack&& __q)
-        _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
-        {c = _STD::move(__q.c); return *this;}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    _LIBCPP_INLINE_VISIBILITY
+    stack() : c() {}
     explicit stack(const container_type& __c) : c(__c) {}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     explicit stack(container_type&& __c) : c(_STD::move(__c)) {}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    stack(stack&& __s) : c(_STD::move(__s.c)) {}
+    stack& operator=(stack&& __s) {c = _STD::move(__s.c); return *this;}
+#endif
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
         explicit stack(const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0)
             : c(__a) {}
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
         stack(const container_type& __c, const _Alloc& __a,
               typename enable_if<uses_allocator<container_type,
                                                 _Alloc>::value>::type* = 0)
             : c(__c, __a) {}
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
         stack(const stack& __s, const _Alloc& __a,
               typename enable_if<uses_allocator<container_type,
                                                 _Alloc>::value>::type* = 0)
             : c(__s.c, __a) {}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
         stack(container_type&& __c, const _Alloc& __a,
               typename enable_if<uses_allocator<container_type,
                                                 _Alloc>::value>::type* = 0)
             : c(_STD::move(__c), __a) {}
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
         stack(stack&& __s, const _Alloc& __a,
               typename enable_if<uses_allocator<container_type,
                                                 _Alloc>::value>::type* = 0)
             : c(_STD::move(__s.c), __a) {}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY
     bool empty()     const      {return c.empty();}
-    _LIBCPP_INLINE_VISIBILITY
     size_type size() const      {return c.size();}
-    _LIBCPP_INLINE_VISIBILITY
     reference top()             {return c.back();}
-    _LIBCPP_INLINE_VISIBILITY
     const_reference top() const {return c.back();}
 
-    _LIBCPP_INLINE_VISIBILITY
     void push(const value_type& __v) {c.push_back(__v);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     void push(value_type&& __v) {c.push_back(_STD::move(__v));}
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        void emplace(_Args&&... __args)
+    template <class... _Args> void emplace(_Args&&... __args)
         {c.emplace_back(_STD::forward<_Args>(__args)...);}
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#endif
     void pop() {c.pop_back();}
 
-    _LIBCPP_INLINE_VISIBILITY
     void swap(stack& __s)
-        _NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
     {
         using _STD::swap;
         swap(c, __s.c);
@@ -213,7 +163,7 @@ public:
     friend
     bool
     operator==(const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);
-
+    
     template <class T1, class _C1>
     friend
     bool
@@ -221,7 +171,7 @@ public:
 };
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 {
@@ -229,7 +179,7 @@ operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 {
@@ -237,7 +187,7 @@ operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator!=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 {
@@ -245,7 +195,7 @@ operator!=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator> (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 {
@@ -253,7 +203,7 @@ operator> (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator>=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 {
@@ -261,7 +211,7 @@ operator>=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator<=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 {
@@ -269,16 +219,15 @@ operator<=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 template <class _Tp, class _Container, class _Alloc>
-struct _LIBCPP_VISIBLE uses_allocator<stack<_Tp, _Container>, _Alloc>
+struct uses_allocator<stack<_Tp, _Container>, _Alloc>
     : public uses_allocator<_Container, _Alloc>
 {
 };

include/stdbool.h

@@ -0,0 +1,44 @@
+// -*- C++ -*-
+//===--------------------------- stdbool.h --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_STDBOOL_H
+#define _LIBCPP_STDBOOL_H
+
+/*
+    stdbool.h synopsis
+
+Macros:
+
+    __bool_true_false_are_defined
+
+*/
+
+#ifdef __cplusplus
+#include <__config>
+#endif
+
+#pragma GCC system_header
+
+#undef __bool_true_false_are_defined
+#define __bool_true_false_are_defined 1
+
+#ifndef __cplusplus
+
+#define bool _Bool
+#if __STDC_VERSION__ < 199901L && __GNUC__ < 3
+typedef int _Bool;
+#endif
+
+#define false (bool)0
+#define true (bool)1
+
+#endif /* !__cplusplus */
+
+#endif  // _LIBCPP_STDBOOL_H

include/stdexcept

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -33,9 +33,9 @@ class xxx_error : public exception // at least indirectly
 {
 public:
     explicit xxx_error(const string& what_arg);
-    explicit xxx_error(const char*   what_arg);
+    explicit xxx_error(const char*   what_arg);  // extension
 
-    virtual const char* what() const noexcept // returns what_arg
+    virtual const char* what() const // returns what_arg
 };
 
 }  // std
@@ -60,12 +60,12 @@ public:
     explicit logic_error(const string&);
     explicit logic_error(const char*);
 
-    logic_error(const logic_error&) _NOEXCEPT;
-    logic_error& operator=(const logic_error&) _NOEXCEPT;
+    logic_error(const logic_error&) throw();
+    logic_error& operator=(const logic_error&) throw();
 
-    virtual ~logic_error() _NOEXCEPT;
+    virtual ~logic_error() throw();
 
-    virtual const char* what() const _NOEXCEPT;
+    virtual const char* what() const throw();
 };
 
 class _LIBCPP_EXCEPTION_ABI runtime_error
@@ -77,12 +77,12 @@ public:
     explicit runtime_error(const string&);
     explicit runtime_error(const char*);
 
-    runtime_error(const runtime_error&) _NOEXCEPT;
-    runtime_error& operator=(const runtime_error&) _NOEXCEPT;
+    runtime_error(const runtime_error&) throw();
+    runtime_error& operator=(const runtime_error&) throw();
 
-    virtual ~runtime_error() _NOEXCEPT;
+    virtual ~runtime_error() throw();
 
-    virtual const char* what() const _NOEXCEPT;
+    virtual const char* what() const throw();
 };
 
 class _LIBCPP_EXCEPTION_ABI domain_error
@@ -92,7 +92,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY explicit domain_error(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s)   : logic_error(__s) {}
 
-    virtual ~domain_error() _NOEXCEPT;
+    virtual ~domain_error() throw();
 };
 
 class _LIBCPP_EXCEPTION_ABI invalid_argument
@@ -102,7 +102,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s)   : logic_error(__s) {}
 
-    virtual ~invalid_argument() _NOEXCEPT;
+    virtual ~invalid_argument() throw();
 };
 
 class _LIBCPP_EXCEPTION_ABI length_error
@@ -112,7 +112,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s)   : logic_error(__s) {}
 
-    virtual ~length_error() _NOEXCEPT;
+    virtual ~length_error() throw();
 };
 
 class _LIBCPP_EXCEPTION_ABI out_of_range
@@ -122,7 +122,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s)   : logic_error(__s) {}
 
-    virtual ~out_of_range() _NOEXCEPT;
+    virtual ~out_of_range() throw();
 };
 
 class _LIBCPP_EXCEPTION_ABI range_error
@@ -132,7 +132,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY explicit range_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s)   : runtime_error(__s) {}
 
-    virtual ~range_error() _NOEXCEPT;
+    virtual ~range_error() throw();
 };
 
 class _LIBCPP_EXCEPTION_ABI overflow_error
@@ -142,7 +142,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s)   : runtime_error(__s) {}
 
-    virtual ~overflow_error() _NOEXCEPT;
+    virtual ~overflow_error() throw();
 };
 
 class _LIBCPP_EXCEPTION_ABI underflow_error
@@ -152,9 +152,10 @@ public:
     _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s)   : runtime_error(__s) {}
 
-    virtual ~underflow_error() _NOEXCEPT;
+    virtual ~underflow_error() throw();
 };
 
+
 }  // std
 
 #endif  // _LIBCPP_STDEXCEPT

include/streambuf

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -117,7 +117,7 @@ protected:
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_VISIBLE basic_streambuf
+class basic_streambuf
 {
 public:
     // types:
@@ -557,6 +557,7 @@ extern template class basic_streambuf<wchar_t>;
 extern template class basic_ios<char>;
 extern template class basic_ios<wchar_t>;
 
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_STEAMBUF

include/strstream

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -135,7 +135,7 @@ private:
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_VISIBLE strstreambuf
+class strstreambuf
     : public streambuf
 {
 public:
@@ -149,10 +149,10 @@ public:
     strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = 0);
     strstreambuf(const unsigned char* __gnext, streamsize __n);
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
     strstreambuf(strstreambuf&& __rhs);
     strstreambuf& operator=(strstreambuf&& __rhs);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
     virtual ~strstreambuf();
 
@@ -187,25 +187,20 @@ private:
     void __init(char* __gnext, streamsize __n, char* __pbeg);
 };
 
-class _LIBCPP_VISIBLE istrstream
+class istrstream
     : public istream
 {
 public:
-    _LIBCPP_INLINE_VISIBILITY
     explicit istrstream(const char* __s)
         : istream(&__sb_), __sb_(__s, 0) {}
-    _LIBCPP_INLINE_VISIBILITY
     explicit istrstream(char* __s)
         : istream(&__sb_), __sb_(__s, 0) {}
-    _LIBCPP_INLINE_VISIBILITY
     istrstream(const char* __s, streamsize __n)
         : istream(&__sb_), __sb_(__s, __n) {}
-    _LIBCPP_INLINE_VISIBILITY
     istrstream(char* __s, streamsize __n)
         : istream(&__sb_), __sb_(__s, __n) {}
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     istrstream(istrstream&& __rhs)
         : istream(_STD::move(__rhs)),
           __sb_(_STD::move(__rhs.__sb_))
@@ -213,48 +208,41 @@ public:
         istream::set_rdbuf(&__sb_);
     }
 
-    _LIBCPP_INLINE_VISIBILITY
     istrstream& operator=(istrstream&& __rhs)
     {
         istream::operator=(_STD::move(__rhs));
         __sb_ = _STD::move(__rhs.__sb_);
         return *this;
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
     virtual ~istrstream();
 
-    _LIBCPP_INLINE_VISIBILITY
     void swap(istrstream& __rhs)
     {
         istream::swap(__rhs);
         __sb_.swap(__rhs.__sb_);
     }
 
-    _LIBCPP_INLINE_VISIBILITY
     strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
-    _LIBCPP_INLINE_VISIBILITY
     char *str() {return __sb_.str();}
 
 private:
     strstreambuf __sb_;
 };
 
-class _LIBCPP_VISIBLE ostrstream
+class ostrstream
     : public ostream
 {
 public:
-    _LIBCPP_INLINE_VISIBILITY
     ostrstream()
         : ostream(&__sb_) {}
-    _LIBCPP_INLINE_VISIBILITY
     ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
         : ostream(&__sb_),
           __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
         {}
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     ostrstream(ostrstream&& __rhs)
         : ostream(_STD::move(__rhs)),
           __sb_(_STD::move(__rhs.__sb_))
@@ -262,38 +250,32 @@ public:
         ostream::set_rdbuf(&__sb_);
     }
 
-    _LIBCPP_INLINE_VISIBILITY
     ostrstream& operator=(ostrstream&& __rhs)
     {
         ostream::operator=(_STD::move(__rhs));
         __sb_ = _STD::move(__rhs.__sb_);
         return *this;
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
     virtual ~ostrstream();
 
-    _LIBCPP_INLINE_VISIBILITY
     void swap(ostrstream& __rhs)
     {
         ostream::swap(__rhs);
         __sb_.swap(__rhs.__sb_);
     }
 
-    _LIBCPP_INLINE_VISIBILITY
     strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
-    _LIBCPP_INLINE_VISIBILITY
     void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
-    _LIBCPP_INLINE_VISIBILITY
     char* str()         {return __sb_.str();}
-    _LIBCPP_INLINE_VISIBILITY
     int pcount() const  {return __sb_.pcount();}
 
 private:
     strstreambuf __sb_; // exposition only
 };
 
-class _LIBCPP_VISIBLE strstream
+class strstream
     : public iostream
 {
 public:
@@ -304,17 +286,14 @@ public:
     typedef char_traits<char>::off_type off_type;
 
     // constructors/destructor
-    _LIBCPP_INLINE_VISIBILITY
     strstream()
         : iostream(&__sb_) {}
-    _LIBCPP_INLINE_VISIBILITY
     strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)
         : iostream(&__sb_),
           __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
         {}
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     strstream(strstream&& __rhs)
         : iostream(_STD::move(__rhs)),
           __sb_(_STD::move(__rhs.__sb_))
@@ -322,18 +301,16 @@ public:
         iostream::set_rdbuf(&__sb_);
     }
 
-    _LIBCPP_INLINE_VISIBILITY
     strstream& operator=(strstream&& __rhs)
     {
         iostream::operator=(_STD::move(__rhs));
         __sb_ = _STD::move(__rhs.__sb_);
         return *this;
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
     virtual ~strstream();
 
-    _LIBCPP_INLINE_VISIBILITY
     void swap(strstream& __rhs)
     {
         iostream::swap(__rhs);
@@ -341,13 +318,9 @@ public:
     }
 
     // Members:
-    _LIBCPP_INLINE_VISIBILITY
     strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
-    _LIBCPP_INLINE_VISIBILITY
     void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
-    _LIBCPP_INLINE_VISIBILITY
     int pcount() const {return __sb_.pcount();}
-    _LIBCPP_INLINE_VISIBILITY
     char* str()        {return __sb_.str();}
 
 private:

include/system_error

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -20,24 +20,24 @@ namespace std
 class error_category
 {
 public:
-    virtual ~error_category() noexcept;
+    virtual ~error_category();
 
     error_category(const error_category&) = delete;
     error_category& operator=(const error_category&) = delete;
 
-    virtual const char* name() const noexcept = 0;
-    virtual error_condition default_error_condition(int ev) const noexcept;
-    virtual bool equivalent(int code, const error_condition& condition) const noexcept;
-    virtual bool equivalent(const error_code& code, int condition) const noexcept;
+    virtual const char* name() const = 0;
+    virtual error_condition default_error_condition(int ev) const;
+    virtual bool equivalent(int code, const error_condition& condition) const;
+    virtual bool equivalent(const error_code& code, int condition) const;
     virtual string message(int ev) const = 0;
 
-    bool operator==(const error_category& rhs) const noexcept;
-    bool operator!=(const error_category& rhs) const noexcept;
-    bool operator<(const error_category& rhs) const noexcept;
+    bool operator==(const error_category& rhs) const;
+    bool operator!=(const error_category& rhs) const;
+    bool operator<(const error_category& rhs) const;
 };
 
-const error_category& generic_category() noexcept;
-const error_category& system_category() noexcept;
+const error_category& generic_category();
+const error_category& system_category();
 
 template <class T> struct is_error_code_enum
     : public false_type {};
@@ -49,27 +49,27 @@ class error_code
 {
 public:
     // constructors:
-    error_code() noexcept;
-    error_code(int val, const error_category& cat) noexcept;
+    error_code();
+    error_code(int val, const error_category& cat);
     template <class ErrorCodeEnum>
-        error_code(ErrorCodeEnum e) noexcept;
+        error_code(ErrorCodeEnum e);
 
     // modifiers:
-    void assign(int val, const error_category& cat) noexcept;
+    void assign(int val, const error_category& cat);
     template <class ErrorCodeEnum>
-        error_code& operator=(ErrorCodeEnum e) noexcept;
-    void clear() noexcept;
+        error_code& operator=(ErrorCodeEnum e);
+    void clear();
 
     // observers:
-    int value() const noexcept;
-    const error_category& category() const noexcept;
-    error_condition default_error_condition() const noexcept;
+    int value() const;
+    const error_category& category() const;
+    error_condition default_error_condition() const;
     string message() const;
-    explicit operator bool() const noexcept;
+    explicit operator bool() const;
 };
 
 // non-member functions:
-bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
+bool operator<(const error_code& lhs, const error_code& rhs);
 template <class charT, class traits>
     basic_ostream<charT,traits>&
     operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
@@ -78,25 +78,25 @@ class error_condition
 {
 public:
     // constructors:
-    error_condition() noexcept;
-    error_condition(int val, const error_category& cat) noexcept;
+    error_condition();
+    error_condition(int val, const error_category& cat);
     template <class ErrorConditionEnum>
-        error_condition(ErrorConditionEnum e) noexcept;
+        error_condition(ErrorConditionEnum e);
 
     // modifiers:
-    void assign(int val, const error_category& cat) noexcept;
+    void assign(int val, const error_category& cat);
     template <class ErrorConditionEnum>
-        error_condition& operator=(ErrorConditionEnum e) noexcept;
-    void clear() noexcept;
+        error_condition& operator=(ErrorConditionEnum e);
+    void clear();
 
     // observers:
-    int value() const noexcept;
-    const error_category& category() const noexcept;
-    string message() const noexcept;
-    explicit operator bool() const noexcept;
+    int value() const;
+    const error_category& category() const;
+    string message() const;
+    explicit operator bool() const;
 };
 
-bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
+bool operator<(const error_condition& lhs, const error_condition& rhs);
 
 class system_error
     : public runtime_error
@@ -109,8 +109,8 @@ public:
     system_error(int ev, const error_category& ecat, const char* what_arg);
     system_error(int ev, const error_category& ecat);
 
-    const error_code& code() const noexcept;
-    const char* what() const noexcept;
+    const error_code& code() const throw();
+    const char* what() const throw();
 };
 
 enum class errc
@@ -198,18 +198,18 @@ enum class errc
 template <> struct is_error_condition_enum<errc>
     : true_type { }
 
-error_code make_error_code(errc e) noexcept;
-error_condition make_error_condition(errc e) noexcept;
+error_code make_error_code(errc e);
+error_condition make_error_condition(errc e);
 
 // Comparison operators:
-bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
-bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
-bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
-bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
-bool operator!=(const error_code& lhs, const error_code& rhs) noexcept;
-bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
-bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
-bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
+bool operator==(const error_code& lhs, const error_code& rhs);
+bool operator==(const error_code& lhs, const error_condition& rhs);
+bool operator==(const error_condition& lhs, const error_code& rhs);
+bool operator==(const error_condition& lhs, const error_condition& rhs);
+bool operator!=(const error_code& lhs, const error_code& rhs);
+bool operator!=(const error_code& lhs, const error_condition& rhs);
+bool operator!=(const error_condition& lhs, const error_code& rhs);
+bool operator!=(const error_condition& lhs, const error_condition& rhs);
 
 template <> struct hash<std::error_code>;
 
@@ -229,19 +229,14 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // is_error_code_enum
 
-template <class _Tp>
-struct _LIBCPP_VISIBLE is_error_code_enum
+template <class _Tp> struct is_error_code_enum
     : public false_type {};
 
 // is_error_condition_enum
 
-template <class _Tp>
-struct _LIBCPP_VISIBLE is_error_condition_enum
+template <class _Tp> struct is_error_condition_enum
     : public false_type {};
 
-// Some error codes are not present on all platforms, so we provide equivalents
-// for them:
-
 //enum class errc
 struct errc
 {
@@ -286,30 +281,18 @@ enum _ {
     no_child_process                    = ECHILD,
     no_link                             = ENOLINK,
     no_lock_available                   = ENOLCK,
-#ifdef ENODATA
     no_message_available                = ENODATA,
-#else
-    no_message_available                = ENOMSG,
-#endif
     no_message                          = ENOMSG,
     no_protocol_option                  = ENOPROTOOPT,
     no_space_on_device                  = ENOSPC,
-#ifdef ENOSR
     no_stream_resources                 = ENOSR,
-#else
-    no_stream_resources                 = ENOMEM,
-#endif
     no_such_device_or_address           = ENXIO,
     no_such_device                      = ENODEV,
     no_such_file_or_directory           = ENOENT,
     no_such_process                     = ESRCH,
     not_a_directory                     = ENOTDIR,
     not_a_socket                        = ENOTSOCK,
-#ifdef ENOSTR
     not_a_stream                        = ENOSTR,
-#else
-    not_a_stream                        = EINVAL,
-#endif
     not_connected                       = ENOTCONN,
     not_enough_memory                   = ENOMEM,
     not_supported                       = ENOTSUP,
@@ -327,11 +310,7 @@ enum _ {
     resource_unavailable_try_again      = EAGAIN,
     result_out_of_range                 = ERANGE,
     state_not_recoverable               = ENOTRECOVERABLE,
-#ifdef ETIME
     stream_timeout                      = ETIME,
-#else
-    stream_timeout                      = ETIMEDOUT,
-#endif
     text_file_busy                      = ETXTBSY,
     timed_out                           = ETIMEDOUT,
     too_many_files_open_in_system       = ENFILE,
@@ -344,19 +323,15 @@ enum _ {
 
     _ __v_;
 
-    _LIBCPP_ALWAYS_INLINE
     errc(_ __v) : __v_(__v) {}
-    _LIBCPP_ALWAYS_INLINE
     operator int() const {return __v_;}
 
 };
 
-template <>
-struct _LIBCPP_VISIBLE is_error_condition_enum<errc>
+template <> struct is_error_condition_enum<errc>
     : true_type { };
 
-template <>
-struct _LIBCPP_VISIBLE is_error_condition_enum<errc::_>
+template <> struct is_error_condition_enum<errc::_>
     : true_type { };
 
 class error_condition;
@@ -366,31 +341,31 @@ class error_code;
 
 class __do_message;
 
-class _LIBCPP_VISIBLE error_category
+class error_category
 {
 public:
-    virtual ~error_category() _NOEXCEPT;
+    virtual ~error_category();
 
 private:
-    error_category() _NOEXCEPT;
+    error_category();
     error_category(const error_category&);// = delete;
     error_category& operator=(const error_category&);// = delete;
 
 public:
-    virtual const char* name() const _NOEXCEPT = 0;
-    virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
-    virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
-    virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
+    virtual const char* name() const = 0;
+    virtual error_condition default_error_condition(int __ev) const;
+    virtual bool equivalent(int __code, const error_condition& __condition) const;
+    virtual bool equivalent(const error_code& __code, int __condition) const;
     virtual string message(int __ev) const = 0;
 
     _LIBCPP_ALWAYS_INLINE
-    bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
+    bool operator==(const error_category& __rhs) const {return this == &__rhs;}
 
     _LIBCPP_ALWAYS_INLINE
-    bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
+    bool operator!=(const error_category& __rhs) const {return !(*this == __rhs);}
 
     _LIBCPP_ALWAYS_INLINE
-    bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
+    bool operator< (const error_category& __rhs) const {return this < &__rhs;}
 
     friend class __do_message;
 };
@@ -402,30 +377,28 @@ public:
     virtual string message(int ev) const;
 };
 
-const error_category& generic_category() _NOEXCEPT;
-const error_category& system_category() _NOEXCEPT;
+const error_category& generic_category();
+const error_category& system_category();
 
-class _LIBCPP_VISIBLE error_condition
+class error_condition
 {
     int __val_;
     const error_category* __cat_;
 public:
     _LIBCPP_ALWAYS_INLINE
-    error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
+    error_condition() : __val_(0), __cat_(&generic_category()) {}
 
     _LIBCPP_ALWAYS_INLINE
-    error_condition(int __val, const error_category& __cat) _NOEXCEPT
+    error_condition(int __val, const error_category& __cat)
         : __val_(__val), __cat_(&__cat) {}
 
     template <class _E>
         _LIBCPP_ALWAYS_INLINE
-        error_condition(_E __e,
-              typename enable_if<is_error_condition_enum<_E>::value>::type* = 0
-                                                                     ) _NOEXCEPT
+        error_condition(_E __e, typename enable_if<is_error_condition_enum<_E>::value>::type* = 0)
             {*this = make_error_condition(__e);}
 
     _LIBCPP_ALWAYS_INLINE
-    void assign(int __val, const error_category& __cat) _NOEXCEPT
+    void assign(int __val, const error_category& __cat)
     {
         __val_ = __val;
         __cat_ = &__cat;
@@ -438,38 +411,38 @@ public:
             is_error_condition_enum<_E>::value,
             error_condition&
         >::type
-        operator=(_E __e) _NOEXCEPT
+        operator=(_E __e)
             {*this = make_error_condition(__e); return *this;}
 
     _LIBCPP_ALWAYS_INLINE
-    void clear() _NOEXCEPT
+    void clear()
     {
         __val_ = 0;
         __cat_ = &generic_category();
     }
 
     _LIBCPP_ALWAYS_INLINE
-    int value() const _NOEXCEPT {return __val_;}
+    int value() const {return __val_;}
 
     _LIBCPP_ALWAYS_INLINE
-    const error_category& category() const _NOEXCEPT {return *__cat_;}
+    const error_category& category() const {return *__cat_;}
     string message() const;
 
     _LIBCPP_ALWAYS_INLINE
     //explicit
-        operator bool() const _NOEXCEPT {return __val_ != 0;}
+        operator bool() const {return __val_ != 0;}
 };
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_condition
-make_error_condition(errc __e) _NOEXCEPT
+make_error_condition(errc __e)
 {
     return error_condition(static_cast<int>(__e), generic_category());
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
+operator<(const error_condition& __x, const error_condition& __y)
 {
     return __x.category() < __y.category()
         || __x.category() == __y.category() && __x.value() < __y.value();
@@ -477,27 +450,25 @@ operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
 
 // error_code
 
-class _LIBCPP_VISIBLE error_code
+class error_code
 {
     int __val_;
     const error_category* __cat_;
 public:
     _LIBCPP_ALWAYS_INLINE
-    error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
+    error_code() : __val_(0), __cat_(&system_category()) {}
 
     _LIBCPP_ALWAYS_INLINE
-    error_code(int __val, const error_category& __cat) _NOEXCEPT
+    error_code(int __val, const error_category& __cat)
         : __val_(__val), __cat_(&__cat) {}
 
     template <class _E>
         _LIBCPP_ALWAYS_INLINE
-        error_code(_E __e,
-                   typename enable_if<is_error_code_enum<_E>::value>::type* = 0
-                                                                     ) _NOEXCEPT
+        error_code(_E __e, typename enable_if<is_error_code_enum<_E>::value>::type* = 0)
             {*this = make_error_code(__e);}
 
     _LIBCPP_ALWAYS_INLINE
-    void assign(int __val, const error_category& __cat) _NOEXCEPT
+    void assign(int __val, const error_category& __cat)
     {
         __val_ = __val;
         __cat_ = &__cat;
@@ -510,43 +481,43 @@ public:
             is_error_code_enum<_E>::value,
             error_code&
         >::type
-        operator=(_E __e) _NOEXCEPT
+        operator=(_E __e)
             {*this = make_error_code(__e); return *this;}
 
     _LIBCPP_ALWAYS_INLINE
-    void clear() _NOEXCEPT
+    void clear()
     {
         __val_ = 0;
         __cat_ = &system_category();
     }
 
     _LIBCPP_ALWAYS_INLINE
-    int value() const _NOEXCEPT {return __val_;}
+    int value() const {return __val_;}
 
     _LIBCPP_ALWAYS_INLINE
-    const error_category& category() const _NOEXCEPT {return *__cat_;}
+    const error_category& category() const {return *__cat_;}
 
     _LIBCPP_ALWAYS_INLINE
-    error_condition default_error_condition() const _NOEXCEPT
+    error_condition default_error_condition() const
         {return __cat_->default_error_condition(__val_);}
 
     string message() const;
 
     _LIBCPP_ALWAYS_INLINE
     //explicit
-        operator bool() const _NOEXCEPT {return __val_ != 0;}
+        operator bool() const {return __val_ != 0;}
 };
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_code
-make_error_code(errc __e) _NOEXCEPT
+make_error_code(errc __e)
 {
     return error_code(static_cast<int>(__e), generic_category());
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
+operator<(const error_code& __x, const error_code& __y)
 {
     return __x.category() < __y.category()
         || __x.category() == __y.category() && __x.value() < __y.value();
@@ -554,14 +525,14 @@ operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
+operator==(const error_code& __x, const error_code& __y)
 {
     return __x.category() == __y.category() && __x.value() == __y.value();
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
+operator==(const error_code& __x, const error_condition& __y)
 {
     return __x.category().equivalent(__x.value(), __y)
         || __y.category().equivalent(__x, __y.value());
@@ -569,44 +540,39 @@ operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
+operator==(const error_condition& __x, const error_code& __y)
 {
     return __y == __x;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
+operator==(const error_condition& __x, const error_condition& __y)
 {
     return __x.category() == __y.category() && __x.value() == __y.value();
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
-{return !(__x == __y);}
+operator!=(const error_code& __x, const error_code& __y) {return !(__x == __y);}
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
-{return !(__x == __y);}
+operator!=(const error_code& __x, const error_condition& __y) {return !(__x == __y);}
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
-{return !(__x == __y);}
+operator!=(const error_condition& __x, const error_code& __y) {return !(__x == __y);}
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
-{return !(__x == __y);}
+operator!=(const error_condition& __x, const error_condition& __y) {return !(__x == __y);}
 
 template <>
-struct _LIBCPP_VISIBLE hash<error_code>
+struct hash<error_code>
     : public unary_function<error_code, size_t>
 {
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const error_code& __ec) const _NOEXCEPT
+    size_t operator()(const error_code& __ec) const
     {
         return static_cast<size_t>(__ec.value());
     }
@@ -614,7 +580,7 @@ struct _LIBCPP_VISIBLE hash<error_code>
 
 // system_error
 
-class _LIBCPP_VISIBLE system_error
+class system_error
     : public runtime_error
 {
     error_code __ec_;
@@ -625,10 +591,10 @@ public:
     system_error(int __ev, const error_category& __ecat, const string& __what_arg);
     system_error(int __ev, const error_category& __ecat, const char* __what_arg);
     system_error(int __ev, const error_category& __ecat);
-    ~system_error() _NOEXCEPT;
+    ~system_error() throw();
 
     _LIBCPP_ALWAYS_INLINE
-    const error_code& code() const _NOEXCEPT {return __ec_;}
+    const error_code& code() const throw() {return __ec_;}
 
 private:
     static string __init(const error_code&, string);

include/tgmath.h

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/thread

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -15,7 +15,7 @@
 
     thread synopsis
 
-#define __STDCPP_THREADS__ __cplusplus
+#define __STDCPP_THREADS __cplusplus
 
 namespace std
 {
@@ -95,82 +95,14 @@ void sleep_for(const chrono::duration<Rep, Period>& rel_time);
 #include <system_error>
 #include <chrono>
 #include <__mutex_base>
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-#include <tuple>
-#endif
 #include <pthread.h>
 
 #pragma GCC system_header
 
-#define __STDCPP_THREADS__ __cplusplus
+#define __STDCPP_THREADS __cplusplus
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp>
-class __thread_specific_ptr
-{
-    pthread_key_t __key_;
-
-    __thread_specific_ptr(const __thread_specific_ptr&);
-    __thread_specific_ptr& operator=(const __thread_specific_ptr&);
-
-    static void __at_thread_exit(void*);
-public:
-    typedef _Tp* pointer;
-
-    __thread_specific_ptr();
-    ~__thread_specific_ptr();
-
-    _LIBCPP_INLINE_VISIBILITY
-    pointer get() const {return static_cast<_Tp*>(pthread_getspecific(__key_));}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator*() const {return *get();}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {return get();}
-    pointer release();
-    void reset(pointer __p = nullptr);
-};
-
-template <class _Tp>
-void
-__thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
-{
-	delete static_cast<pointer>(__p);
-}
-
-template <class _Tp>
-__thread_specific_ptr<_Tp>::__thread_specific_ptr()
-{
-    int __ec = pthread_key_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
-	if (__ec)
-		throw system_error(error_code(__ec, system_category()),
-		                   "__thread_specific_ptr construction failed");
-}
-
-template <class _Tp>
-__thread_specific_ptr<_Tp>::~__thread_specific_ptr()
-{
-	pthread_key_delete(__key_);
-}
-
-template <class _Tp>
-typename __thread_specific_ptr<_Tp>::pointer
-__thread_specific_ptr<_Tp>::release()
-{
-	pointer __p = get();
-	pthread_setspecific(__key_, 0);
-	return __p;
-}
-
-template <class _Tp>
-void
-__thread_specific_ptr<_Tp>::reset(pointer __p)
-{
-	pointer __p_old = get();
-	pthread_setspecific(__key_, __p);
-	delete __p_old;
-}
-
 class thread;
 class __thread_id;
 
@@ -181,7 +113,7 @@ __thread_id get_id();
 
 }  // this_thread
 
-class _LIBCPP_VISIBLE __thread_id
+class __thread_id
 {
     // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
     // NULL is the no-thread value on Darwin.  Someone needs to check
@@ -189,50 +121,40 @@ class _LIBCPP_VISIBLE __thread_id
     pthread_t __id_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
     __thread_id() : __id_(0) {}
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(__thread_id __x, __thread_id __y)
+    friend bool operator==(__thread_id __x, __thread_id __y)
         {return __x.__id_ == __y.__id_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(__thread_id __x, __thread_id __y)
+    friend bool operator!=(__thread_id __x, __thread_id __y)
         {return !(__x == __y);}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator< (__thread_id __x, __thread_id __y)
+    friend bool operator< (__thread_id __x, __thread_id __y)
         {return __x.__id_ < __y.__id_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator<=(__thread_id __x, __thread_id __y)
+    friend bool operator<=(__thread_id __x, __thread_id __y)
         {return !(__y < __x);}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator> (__thread_id __x, __thread_id __y)
+    friend bool operator> (__thread_id __x, __thread_id __y)
         {return   __y < __x ;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator>=(__thread_id __x, __thread_id __y)
+    friend bool operator>=(__thread_id __x, __thread_id __y)
         {return !(__x < __y);}
 
     template<class _CharT, class _Traits>
     friend
-    _LIBCPP_INLINE_VISIBILITY
     basic_ostream<_CharT, _Traits>&
     operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
         {return __os << __id.__id_;}
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
     __thread_id(pthread_t __id) : __id_(__id) {}
 
     friend __thread_id this_thread::get_id();
-    friend class _LIBCPP_VISIBLE thread;
+    friend class thread;
 };
 
 template<class _Tp> struct hash;
 
 template<>
-struct _LIBCPP_VISIBLE hash<__thread_id>
+struct hash<__thread_id>
     : public unary_function<__thread_id, size_t>
 {
-    _LIBCPP_INLINE_VISIBILITY
     size_t operator()(__thread_id __v) const
     {
         const size_t* const __p = reinterpret_cast<const size_t*>(&__v);
@@ -243,7 +165,7 @@ struct _LIBCPP_VISIBLE hash<__thread_id>
 namespace this_thread
 {
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __thread_id
 get_id()
 {
@@ -252,17 +174,18 @@ get_id()
 
 }  // this_thread
 
-class _LIBCPP_VISIBLE thread
+class thread
 {
     pthread_t __t_;
 
-    thread(const thread&);
-    thread& operator=(const thread&);
+#ifndef _LIBCPP_MOVE
+    thread(const thread&); // = delete;
+    thread& operator=(const thread&); // = delete;
+#endif
 public:
     typedef __thread_id id;
     typedef pthread_t native_handle_type;
 
-    _LIBCPP_INLINE_VISIBILITY
     thread() : __t_(0) {}
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class _F, class ..._Args,
@@ -272,81 +195,48 @@ public:
               >::type
              >
         explicit thread(_F&& __f, _Args&&... __args);
-#else  // _LIBCPP_HAS_NO_VARIADICS
+#else
     template <class _F> explicit thread(_F __f);
 #endif
     ~thread();
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
+    thread(const thread&) = delete;
     thread(thread&& __t) : __t_(__t.__t_) {__t.__t_ = 0;}
+    thread& operator=(const thread&) = delete;
     thread& operator=(thread&& __t);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY
     void swap(thread& __t) {_STD::swap(__t_, __t.__t_);}
 
-    _LIBCPP_INLINE_VISIBILITY
     bool joinable() const {return __t_ != 0;}
     void join();
     void detach();
-    _LIBCPP_INLINE_VISIBILITY
     id get_id() const {return __t_;}
-    _LIBCPP_INLINE_VISIBILITY
     native_handle_type native_handle() {return __t_;}
 
     static unsigned hardware_concurrency();
 };
 
-class __assoc_sub_state;
-
-class _LIBCPP_HIDDEN __thread_struct_imp;
-
-class __thread_struct
-{
-    __thread_struct_imp* __p_;
-
-    __thread_struct(const __thread_struct&);
-    __thread_struct& operator=(const __thread_struct&);
-public:
-    __thread_struct();
-    ~__thread_struct();
-
-    void notify_all_at_thread_exit(condition_variable*, mutex*);
-    void __make_ready_at_thread_exit(__assoc_sub_state*);
-};
-
-__thread_specific_ptr<__thread_struct>& __thread_local_data();
-
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
-template <class _F, class ..._Args, size_t ..._Indices>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-__threaad_execute(tuple<_F, _Args...>& __t, __tuple_indices<_Indices...>)
-{
-    __invoke(_STD::move(_STD::get<0>(__t)), _STD::move(_STD::get<_Indices>(__t))...);
-}
-
 template <class _F>
 void*
 __thread_proxy(void* __vp)
 {
-    __thread_local_data().reset(new __thread_struct);
     std::unique_ptr<_F> __p(static_cast<_F*>(__vp));
-    typedef typename __make_tuple_indices<tuple_size<_F>::value, 1>::type _Index;
-    __threaad_execute(*__p, _Index());
+    (*__p)();
     return nullptr;
 }
 
+#ifndef _LIBCPP_HAS_NO_VARIADICS
+
 template <class _F, class ..._Args,
           class
          >
 thread::thread(_F&& __f, _Args&&... __args)
 {
-    typedef tuple<typename decay<_F>::type, typename decay<_Args>::type...> _G;
-    _STD::unique_ptr<_G> __p(new _G(__decay_copy(_STD::forward<_F>(__f)),
-                                __decay_copy(_STD::forward<_Args>(__args))...));
+    typedef decltype(bind(std::forward<_F>(__f), std::forward<_Args>(__args)...)) _G;
+    std::unique_ptr<_G> __p(new _G(bind(std::forward<_F>(__f),
+                              std::forward<_Args>(__args)...)));
     int __ec = pthread_create(&__t_, 0, &__thread_proxy<_G>, __p.get());
     if (__ec == 0)
         __p.release();
@@ -354,17 +244,7 @@ thread::thread(_F&& __f, _Args&&... __args)
         __throw_system_error(__ec, "thread constructor failed");
 }
 
-#else  // _LIBCPP_HAS_NO_VARIADICS
-
-template <class _F>
-void*
-__thread_proxy(void* __vp)
-{
-    __thread_local_data().reset(new __thread_struct);
-    std::unique_ptr<_F> __p(static_cast<_F*>(__vp));
-    (*__p)();
-    return nullptr;
-}
+#else
 
 template <class _F>
 thread::thread(_F __f)
@@ -377,11 +257,11 @@ thread::thread(_F __f)
         __throw_system_error(__ec, "thread constructor failed");
 }
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#endif
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 thread&
 thread::operator=(thread&& __t)
 {
@@ -392,11 +272,12 @@ thread::operator=(thread&& __t)
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void swap(thread& __x, thread& __y) {__x.swap(__y);}
 
+
 namespace this_thread
 {
 
@@ -426,15 +307,15 @@ sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
 }
 
 template <class _Duration>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
-sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
+sleep_until(const chrono::time_point<chrono::monotonic_clock, _Duration>& __t)
 {
     using namespace chrono;
-    sleep_for(__t - steady_clock::now());
+    sleep_for(__t - monotonic_clock::now());
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void yield() {sched_yield();}
 
 }  // this_thread

include/tuple

@@ -25,7 +25,7 @@ public:
     template <class... U>
         explicit tuple(U&&...);
     tuple(const tuple&) = default;
-    tuple(tuple&&) = default;
+    tuple(tuple&&);
     template <class... U>
         tuple(const tuple<U...>&);
     template <class... U>
@@ -56,8 +56,7 @@ public:
         tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
 
     tuple& operator=(const tuple&);
-    tuple&
-        operator=(tuple&&) noexcept(AND(is_nothrow_move_assignable<T>::value ...));
+    tuple& operator=(tuple&&);
     template <class... U>
         tuple& operator=(const tuple<U...>&);
     template <class... U>
@@ -67,16 +66,18 @@ public:
     template <class U1, class U2>
         tuple& operator=(pair<U1, U2>&&); //iffsizeof...(T) == 2
 
-    void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));
+    void swap(tuple&);
 };
 
 const unspecified ignore;
 
 template <class... T> tuple<V...>  make_tuple(T&&...);
-template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept;
-template <class... T> tuple<T&...> tie(T&...) noexcept;
-template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls);
-  
+template <class... T> tuple<T&...> tie(T&...);
+template <class... T, class... U> tuple<T..., U...> tuple_cat(const tuple<T...>&, const tuple<U...>&);
+template <class... T, class... U> tuple<T..., U...> tuple_cat(tuple<T...>&&, const tuple<U...>&);
+template <class... T, class... U> tuple<T..., U...> tuple_cat(const tuple<T...>&, tuple<U...>&&);
+template <class... T, class... U> tuple<T..., U...> tuple_cat(tuple<T...>&&, tuple<U...>&&);
+
 // 20.4.1.4, tuple helper classes:
 template <class T> class tuple_size; // undefined
 template <class... T> class tuple_size<tuple<T...>>;
@@ -84,15 +85,8 @@ template <intsize_t I, class T> class tuple_element; // undefined
 template <intsize_t I, class... T> class tuple_element<I, tuple<T...>>;
 
 // 20.4.1.5, element access:
-template <intsize_t I, class... T>
-    typename tuple_element<I, tuple<T...>>::type&
-    get(tuple<T...>&) noexcept;
-template <intsize_t I, class... T>
-    typename tuple_element<I, tuple<T...>>::type const&
-    get(const tuple<T...>&) noexcept;
-template <intsize_t I, class... T>
-    typename tuple_element<I, tuple<T...>>::type&&
-    get(tuple<T...>&&) noexcept;
+template <intsize_t I, class... T> typename tuple_element<I, tuple<T...>>::type& get(tuple<T...>&);
+template <intsize_t I, class... T> typename tuple_element<I, tuple<T...>>::type const& get(const tuple<T...>&);
 
 // 20.4.1.6, relational operators:
 template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&);
@@ -106,8 +100,13 @@ template <class... Types, class Alloc>
   struct uses_allocator<tuple<Types...>, Alloc>;
 
 template <class... Types>
-  void
-  swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
+  void swap(tuple<Types...>& x, tuple<Types...>& y);
+
+template <class InputIterator>
+  InputIterator begin(const std::tuple<InputIterator, InputIterator>& t);
+
+template <class InputIterator>
+  InputIterator end(const std::tuple<InputIterator, InputIterator>& t);
 
 }  // std
 
@@ -128,7 +127,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // tuple_size
 
 template <class ..._Tp>
-class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...> >
+class tuple_size<tuple<_Tp...>>
+    : public integral_constant<size_t, sizeof...(_Tp)>
+{
+};
+
+template <class ..._Tp>
+class tuple_size<const tuple<_Tp...>>
     : public integral_constant<size_t, sizeof...(_Tp)>
 {
 };
@@ -136,10 +141,17 @@ class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...> >
 // tuple_element
 
 template <size_t _Ip, class ..._Tp>
-class _LIBCPP_VISIBLE tuple_element<_Ip, tuple<_Tp...> >
+class tuple_element<_Ip, tuple<_Tp...>>
 {
 public:
-    typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
+    typedef typename tuple_element<_Ip, __tuple_types<_Tp...>>::type type;
+};
+
+template <size_t _Ip, class ..._Tp>
+class tuple_element<_Ip, const tuple<_Tp...>>
+{
+public:
+    typedef const typename tuple_element<_Ip, __tuple_types<_Tp...>>::type type;
 };
 
 // __tuple_leaf
@@ -148,9 +160,8 @@ template <size_t _Ip, class _Hp, bool=is_empty<_Hp>::value>
 class __tuple_leaf;
 
 template <size_t _Ip, class _Hp, bool _Ep>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
-    _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
 {
     swap(__x.get(), __y.get());
 }
@@ -187,21 +198,18 @@ public:
         {static_assert(!is_reference<_Hp>::value,
               "Attempted to default construct a reference element in a tuple");}
 
-    template <class _Tp,
-              class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
+    template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(_Tp&& __t)
             : value(_STD::forward<_Tp>(__t))
-        {static_assert(!is_reference<_Hp>::value ||
+        {static_assert(!is_lvalue_reference<_Hp>::value ||
                         is_lvalue_reference<_Hp>::value &&
                         (is_lvalue_reference<_Tp>::value ||
                          is_same<typename remove_reference<_Tp>::type,
                                  reference_wrapper<
                                     typename remove_reference<_Hp>::type
                                  >
-                                >::value) ||
-                        (is_rvalue_reference<_Hp>::value &&
-                         !is_lvalue_reference<_Tp>::value),
+                                >::value),
        "Attempted to construct a reference element in a tuple with an rvalue");}
 
     template <class _Tp, class _Alloc>
@@ -246,10 +254,6 @@ public:
                                 >::value),
        "Attempted to construct a reference element in a tuple with an rvalue");}
 
-    __tuple_leaf(const __tuple_leaf& __t)
-        : value(__t.get())
-        {static_assert(!is_rvalue_reference<_Hp>::value, "Can not copy a tuple with rvalue reference member");}
-
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
@@ -265,7 +269,7 @@ public:
         }
 
     _LIBCPP_INLINE_VISIBILITY
-    int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
+    int swap(__tuple_leaf& __t)
     {
         _STD::swap(*this, __t);
         return 0;
@@ -298,8 +302,7 @@ public:
         __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
             : _Hp(__a) {}
 
-    template <class _Tp,
-              class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
+    template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(_Tp&& __t)
             : _Hp(_STD::forward<_Tp>(__t)) {}
@@ -333,9 +336,7 @@ public:
             return *this;
         }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int
-    swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
+    _LIBCPP_INLINE_VISIBILITY int swap(__tuple_leaf& __t)
     {
         _STD::swap(*this, __t);
         return 0;
@@ -345,23 +346,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY const _Hp& get() const {return static_cast<const _Hp&>(*this);}
 };
 
-template <class ..._Tp>
-_LIBCPP_INLINE_VISIBILITY
-void __swallow(_Tp&&...) {}
-
-template <bool ...> struct __all;
-
-template <>
-struct __all<>
-{
-    static const bool value = true;
-};
-
-template <bool _B0, bool ... _B>
-struct __all<_B0, _B...>
-{
-    static const bool value = _B0 && __all<_B...>::value;
-};
+template <class ..._Tp> void __swallow(_Tp&&...) {}
 
 // __tuple_impl
 
@@ -373,7 +358,6 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
 {
     template <size_t ..._Uf, class ..._Tf,
               size_t ..._Ul, class ..._Tl, class ..._Up>
-        _LIBCPP_INLINE_VISIBILITY
         explicit
         __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
                      __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
@@ -384,7 +368,6 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
 
     template <class _Alloc, size_t ..._Uf, class ..._Tf,
               size_t ..._Ul, class ..._Tl, class ..._Up>
-        _LIBCPP_INLINE_VISIBILITY
         explicit
         __tuple_impl(allocator_arg_t, const _Alloc& __a,
                      __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
@@ -398,10 +381,9 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
     template <class _Tuple,
               class = typename enable_if
                       <
-                         __tuple_convertible<_Tuple, tuple<_Tp...> >::value
+                         __tuple_convertible<_Tuple, tuple<_Tp...>>::value
                       >::type
              >
-        _LIBCPP_INLINE_VISIBILITY
         __tuple_impl(_Tuple&& __t)
             : __tuple_leaf<_Indx, _Tp>(_STD::forward<typename tuple_element<_Indx,
                                        typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...
@@ -410,22 +392,20 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
     template <class _Alloc, class _Tuple,
               class = typename enable_if
                       <
-                         __tuple_convertible<_Tuple, tuple<_Tp...> >::value
+                         __tuple_convertible<_Tuple, tuple<_Tp...>>::value
                       >::type
              >
-        _LIBCPP_INLINE_VISIBILITY
         __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
             : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>(), __a,
+                                       typename __make_tuple_types<_Tuple>::type>::type>(), __a, 
                                        _STD::forward<typename tuple_element<_Indx,
                                        typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...
             {}
 
     template <class _Tuple>
-        _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
-            __tuple_assignable<_Tuple, tuple<_Tp...> >::value,
+            __tuple_assignable<_Tuple, tuple<_Tp...>>::value,
             __tuple_impl&
         >::type
         operator=(_Tuple&& __t)
@@ -435,30 +415,25 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
             return *this;
         }
 
-    _LIBCPP_INLINE_VISIBILITY
     void swap(__tuple_impl& __t)
-        _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
     {
         __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
     }
 };
 
 template <class ..._Tp>
-class _LIBCPP_VISIBLE tuple
+class tuple
 {
     typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base;
 
     base base_;
 
     template <size_t _Jp, class ..._Up> friend
-        typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&);
+        typename tuple_element<_Jp, tuple<_Up...>>::type& get(tuple<_Up...>&);
     template <size_t _Jp, class ..._Up> friend
-        const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&);
-    template <size_t _Jp, class ..._Up> friend
-        typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&);
+        const typename tuple_element<_Jp, tuple<_Up...>>::type& get(const tuple<_Up...>&);
 public:
 
-    _LIBCPP_INLINE_VISIBILITY
     explicit tuple(const _Tp& ... __t)
         : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
@@ -468,7 +443,6 @@ public:
                ) {}
 
     template <class _Alloc>
-      _LIBCPP_INLINE_VISIBILITY
       tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
         : base_(allocator_arg_t(), __a,
                 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
@@ -492,7 +466,6 @@ public:
                          >::value
                       >::type
              >
-        _LIBCPP_INLINE_VISIBILITY
         explicit
         tuple(_Up&&... __u)
             : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
@@ -515,7 +488,6 @@ public:
                          >::value
                       >::type
              >
-        _LIBCPP_INLINE_VISIBILITY
         tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
             : base_(allocator_arg_t(), __a,
                     typename __make_tuple_indices<sizeof...(_Up)>::type(),
@@ -530,7 +502,6 @@ public:
                          __tuple_convertible<_Tuple, tuple>::value
                       >::type
              >
-        _LIBCPP_INLINE_VISIBILITY
         tuple(_Tuple&& __t)
             : base_(_STD::forward<_Tuple>(__t)) {}
 
@@ -540,7 +511,6 @@ public:
                          __tuple_convertible<_Tuple, tuple>::value
                       >::type
              >
-        _LIBCPP_INLINE_VISIBILITY
         tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
             : base_(allocator_arg_t(), __a, _STD::forward<_Tuple>(__t)) {}
 
@@ -550,7 +520,6 @@ public:
                          __tuple_assignable<_Tuple, tuple>::value
                       >::type
              >
-        _LIBCPP_INLINE_VISIBILITY
         tuple&
         operator=(_Tuple&& __t)
         {
@@ -558,78 +527,54 @@ public:
             return *this;
         }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
-        {base_.swap(__t.base_);}
+    void swap(tuple& __t) {base_.swap(__t.base_);}
 };
 
 template <>
-class _LIBCPP_VISIBLE tuple<>
+class tuple<>
 {
 public:
-    _LIBCPP_INLINE_VISIBILITY
     tuple() {}
     template <class _Alloc>
-    _LIBCPP_INLINE_VISIBILITY
         tuple(allocator_arg_t, const _Alloc&) {}
     template <class _Alloc>
-    _LIBCPP_INLINE_VISIBILITY
         tuple(allocator_arg_t, const _Alloc&, const tuple&) {}
     template <class _U>
-    _LIBCPP_INLINE_VISIBILITY
         tuple(array<_U, 0>) {}
     template <class _Alloc, class _U>
-    _LIBCPP_INLINE_VISIBILITY
         tuple(allocator_arg_t, const _Alloc&, array<_U, 0>) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(tuple&) _NOEXCEPT {}
+    void swap(tuple&) {}
 };
 
 template <class ..._Tp>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __all<__is_swappable<_Tp>::value...>::value,
-    void
->::type
-swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
-                 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
-    {__t.swap(__u);}
+void
+swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u) {__t.swap(__u);}
 
 // get
 
 template <size_t _Ip, class ..._Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename tuple_element<_Ip, tuple<_Tp...> >::type&
+inline
+typename tuple_element<_Ip, tuple<_Tp...>>::type&
 get(tuple<_Tp...>& __t)
 {
-    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
+    typedef typename tuple_element<_Ip, tuple<_Tp...>>::type type;
     return static_cast<__tuple_leaf<_Ip, type>&>(__t.base_).get();
 }
 
 template <size_t _Ip, class ..._Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-const typename tuple_element<_Ip, tuple<_Tp...> >::type&
+inline
+const typename tuple_element<_Ip, tuple<_Tp...>>::type&
 get(const tuple<_Tp...>& __t)
 {
-    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
+    typedef typename tuple_element<_Ip, tuple<_Tp...>>::type type;
     return static_cast<const __tuple_leaf<_Ip, type>&>(__t.base_).get();
 }
 
-template <size_t _Ip, class ..._Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename tuple_element<_Ip, tuple<_Tp...> >::type&&
-get(tuple<_Tp...>&& __t)
-{
-    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
-    return static_cast<type&&>(
-             static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get());
-}
-
 // tie
 
 template <class ..._Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 tuple<_Tp&...>
 tie(_Tp&... __t)
 {
@@ -639,13 +584,10 @@ tie(_Tp&... __t)
 template <class _Up>
 struct __ignore_t
 {
-    _LIBCPP_INLINE_VISIBILITY
     __ignore_t() {}
     template <class _Tp>
-        _LIBCPP_INLINE_VISIBILITY
         __ignore_t(_Tp&&) {}
     template <class _Tp>
-        _LIBCPP_INLINE_VISIBILITY
         const __ignore_t& operator=(_Tp&&) const {return *this;}
 };
 
@@ -660,7 +602,7 @@ struct ___make_tuple_return
 };
 
 template <class _Tp>
-struct ___make_tuple_return<reference_wrapper<_Tp> >
+struct ___make_tuple_return<reference_wrapper<_Tp>>
 {
     typedef _Tp& type;
 };
@@ -672,26 +614,17 @@ struct __make_tuple_return
 };
 
 template <class... _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 tuple<typename __make_tuple_return<_Tp>::type...>
 make_tuple(_Tp&&... __t)
 {
     return tuple<typename __make_tuple_return<_Tp>::type...>(_STD::forward<_Tp>(__t)...);
 }
 
-template <class... _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-tuple<_Tp&&...>
-forward_as_tuple(_Tp&&... __t)
-{
-    return tuple<_Tp&&...>(_STD::forward<_Tp>(__t)...);
-}
-
 template <size_t _I>
 struct __tuple_equal
 {
     template <class _Tp, class _Up>
-    _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Up& __y)
     {
         return __tuple_equal<_I - 1>()(__x, __y) && get<_I-1>(__x) == get<_I-1>(__y);
@@ -702,7 +635,6 @@ template <>
 struct __tuple_equal<0>
 {
     template <class _Tp, class _Up>
-    _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp&, const _Up&)
     {
         return true;
@@ -710,7 +642,7 @@ struct __tuple_equal<0>
 };
 
 template <class ..._Tp, class ..._Up>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 {
@@ -718,7 +650,7 @@ operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 }
 
 template <class ..._Tp, class ..._Up>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 {
@@ -729,7 +661,6 @@ template <size_t _I>
 struct __tuple_less
 {
     template <class _Tp, class _Up>
-    _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Up& __y)
     {
         return __tuple_less<_I-1>()(__x, __y) ||
@@ -741,7 +672,6 @@ template <>
 struct __tuple_less<0>
 {
     template <class _Tp, class _Up>
-    _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp&, const _Up&)
     {
         return false;
@@ -749,7 +679,7 @@ struct __tuple_less<0>
 };
 
 template <class ..._Tp, class ..._Up>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 {
@@ -757,7 +687,7 @@ operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 }
 
 template <class ..._Tp, class ..._Up>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 {
@@ -765,7 +695,7 @@ operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 }
 
 template <class ..._Tp, class ..._Up>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 {
@@ -773,7 +703,7 @@ operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 }
 
 template <class ..._Tp, class ..._Up>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 {
@@ -782,146 +712,94 @@ operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 
 // tuple_cat
 
-template <class _Tp, class _Up> struct __tuple_cat_type;
-
-template <class ..._Ttypes, class ..._Utypes>
-struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
+template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
+inline
+tuple<_Tp..., _Up...>
+__tuple_cat(const tuple<_Tp...>& __x, __tuple_indices<_I1...>, const tuple<_Up...>& __y, __tuple_indices<_I2...>)
 {
-    typedef tuple<_Ttypes..., _Utypes...> type;
-};
-
-template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
-struct __tuple_cat_return_1
-{
-};
-
-template <class ..._Types, class _Tuple0>
-struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
-{
-    typedef typename __tuple_cat_type<tuple<_Types...>,
-            typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type>::type
-                                                                           type;
-};
-
-template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
-struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
-    : public __tuple_cat_return_1<
-                 typename __tuple_cat_type<
-                     tuple<_Types...>,
-                     typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type
-                 >::type,
-                 __tuple_like<typename remove_reference<_Tuple1>::type>::value,
-                 _Tuple1, _Tuples...>
-{
-};
-
-template <class ..._Tuples> struct __tuple_cat_return;
-
-template <class _Tuple0, class ..._Tuples>
-struct __tuple_cat_return<_Tuple0, _Tuples...>
-    : public __tuple_cat_return_1<tuple<>,
-         __tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0,
-                                                                     _Tuples...>
-{
-};
-
-template <>
-struct __tuple_cat_return<>
-{
-    typedef tuple<> type;
-};
-
-inline _LIBCPP_INLINE_VISIBILITY
-tuple<>
-tuple_cat()
-{
-    return tuple<>();
+    return tuple<_Tp..., _Up...>(get<_I1>(__x)..., get<_I2>(__y)...);
 }
 
-template <class _R, class _Indices, class _Tuple0, class ..._Tuples>
-struct __tuple_cat_return_ref_imp;
-
-template <class ..._Types, size_t ..._I0, class _Tuple0>
-struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
+template <class... _Tp, class... _Up>
+inline
+tuple<_Tp..., _Up...>
+tuple_cat(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 {
-    typedef typename remove_reference<_Tuple0>::type _T0;
-    typedef tuple<_Types..., typename __apply_cv<_Tuple0,
-                          typename tuple_element<_I0, _T0>::type>::type&&...> type;
-};
+    return __tuple_cat(__x, typename __make_tuple_indices<sizeof...(_Tp)>::type(),
+                       __y, typename __make_tuple_indices<sizeof...(_Up)>::type());
+}
 
-template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
-struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
-                                  _Tuple0, _Tuple1, _Tuples...>
-    : public __tuple_cat_return_ref_imp<
-         tuple<_Types..., typename __apply_cv<_Tuple0,
-               typename tuple_element<_I0,
-                  typename remove_reference<_Tuple0>::type>::type>::type&&...>,
-         typename __make_tuple_indices<tuple_size<typename
-                                 remove_reference<_Tuple1>::type>::value>::type,
-         _Tuple1, _Tuples...>
+template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
+inline
+tuple<_Tp..., _Up...>
+__tuple_cat(tuple<_Tp...>&& __x, __tuple_indices<_I1...>, const tuple<_Up...>& __y, __tuple_indices<_I2...>)
 {
-};
+    return tuple<_Tp..., _Up...>(_STD::forward<_Tp>(get<_I1>(__x))..., get<_I2>(__y)...);
+}
 
-template <class _Tuple0, class ..._Tuples>
-struct __tuple_cat_return_ref
-    : public __tuple_cat_return_ref_imp<tuple<>,
-               typename __make_tuple_indices<
-                        tuple_size<typename remove_reference<_Tuple0>::type>::value
-               >::type, _Tuple0, _Tuples...>
+template <class... _Tp, class... _Up>
+inline
+tuple<_Tp..., _Up...>
+tuple_cat(tuple<_Tp...>&& __x, const tuple<_Up...>& __y)
 {
-};
+    return __tuple_cat(_STD::move(__x), typename __make_tuple_indices<sizeof...(_Tp)>::type(),
+                       __y, typename __make_tuple_indices<sizeof...(_Up)>::type());
+}
 
-template <class _Types, class _I0, class _J0>
-struct __tuple_cat;
-
-template <class ..._Types, size_t ..._I0, size_t ..._J0>
-struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
+template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
+inline
+tuple<_Tp..., _Up...>
+__tuple_cat(const tuple<_Tp...>& __x, __tuple_indices<_I1...>, tuple<_Up...>&& __y, __tuple_indices<_I2...>)
 {
-    template <class _Tuple0>
-    _LIBCPP_INLINE_VISIBILITY
-    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
-    operator()(tuple<_Types...> __t, _Tuple0&& __t0)
-    {
-        return _STD::forward_as_tuple(_STD::forward<_Types>(get<_I0>(__t))...,
-                                      get<_J0>(_STD::forward<_Tuple0>(__t0))...);
-    }
+    return tuple<_Tp..., _Up...>(get<_I1>(__x)..., _STD::forward<_Up>(get<_I2>(__y))...);
+}
 
-    template <class _Tuple0, class _Tuple1, class ..._Tuples>
-    _LIBCPP_INLINE_VISIBILITY
-    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
-    operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
-    {
-        typedef typename remove_reference<_Tuple0>::type _T0;
-        typedef typename remove_reference<_Tuple1>::type _T1;
-        return __tuple_cat<
-           tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
-           typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
-           typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
-                           (_STD::forward_as_tuple(
-                              _STD::forward<_Types>(get<_I0>(__t))...,
-                              get<_J0>(_STD::forward<_Tuple0>(__t0))...
-                            ),
-                            _STD::forward<_Tuple1>(__t1),
-                            _STD::forward<_Tuples>(__tpls)...);
-    }
-};
-
-template <class _Tuple0, class... _Tuples>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __tuple_cat_return<_Tuple0, _Tuples...>::type
-tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
+template <class... _Tp, class... _Up>
+inline
+tuple<_Tp..., _Up...>
+tuple_cat(const tuple<_Tp...>& __x, tuple<_Up...>&& __y)
 {
-    typedef typename remove_reference<_Tuple0>::type _T0;
-    return __tuple_cat<tuple<>, __tuple_indices<>,
-                  typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
-                  (tuple<>(), _STD::forward<_Tuple0>(__t0),
-                                            _STD::forward<_Tuples>(__tpls)...);
+    return __tuple_cat(__x, typename __make_tuple_indices<sizeof...(_Tp)>::type(),
+                       _STD::move(__y), typename __make_tuple_indices<sizeof...(_Up)>::type());
+}
+
+template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
+inline
+tuple<_Tp..., _Up...>
+__tuple_cat(tuple<_Tp...>&& __x, __tuple_indices<_I1...>, tuple<_Up...>&& __y, __tuple_indices<_I2...>)
+{
+    return tuple<_Tp..., _Up...>(_STD::forward<_Tp>(get<_I1>(__x))..., _STD::forward<_Up>(get<_I2>(__y))...);
+}
+
+template <class... _Tp, class... _Up>
+inline
+tuple<_Tp..., _Up...>
+tuple_cat(tuple<_Tp...>&& __x, tuple<_Up...>&& __y)
+{
+    return __tuple_cat(_STD::move(__x), typename __make_tuple_indices<sizeof...(_Tp)>::type(),
+                       _STD::move(__y), typename __make_tuple_indices<sizeof...(_Up)>::type());
 }
 
 template <class ..._Tp, class _Alloc>
-struct _LIBCPP_VISIBLE uses_allocator<tuple<_Tp...>, _Alloc>
+struct uses_allocator<tuple<_Tp...>, _Alloc>
     : true_type {};
 
+template <class _InputIterator>
+inline
+_InputIterator
+begin(const std::tuple<_InputIterator, _InputIterator>& __t)
+{
+    return get<0>(__t);
+}
+
+template <class _InputIterator>
+inline
+_InputIterator
+end(const std::tuple<_InputIterator, _InputIterator>& __t)
+{
+    return get<1>(__t);
+}
+
 template <class _T1, class _T2>
 template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -933,7 +811,7 @@ pair<_T1, _T2>::pair(piecewise_construct_t,
 {
 }
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#endif
 
 _LIBCPP_END_NAMESPACE_STD
 

include/typeindex

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -21,24 +21,24 @@ namespace std
 class type_index
 {
 public:
-    type_index(const type_info& rhs) noexcept;
+    type_index(const type_info& rhs);
 
-    bool operator==(const type_index& rhs) const noexcept;
-    bool operator!=(const type_index& rhs) const noexcept;
-    bool operator< (const type_index& rhs) const noexcept;
-    bool operator<=(const type_index& rhs) const noexcept;
-    bool operator> (const type_index& rhs) const noexcept;
-    bool operator>=(const type_index& rhs) const noexcept;
+    bool operator==(const type_index& rhs) const;
+    bool operator!=(const type_index& rhs) const;
+    bool operator< (const type_index& rhs) const;
+    bool operator<=(const type_index& rhs) const;
+    bool operator> (const type_index& rhs) const;
+    bool operator>=(const type_index& rhs) const;
 
-    size_t hash_code() const noexcept;
-    const char* name() const noexcept;
+    size_t hash_code() const;
+    const char* name() const;
 };
 
 template <>
 struct hash<type_index>
     : public unary_function<type_index, size_t>
 {
-    size_t operator()(type_index index) const noexcept;
+    size_t operator()(type_index index) const;
 };
 
 }  // std
@@ -53,47 +53,30 @@ struct hash<type_index>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_VISIBLE type_index
+class type_index
 {
     const type_info* __t_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    type_index(const type_info& __y) _NOEXCEPT : __t_(&__y) {}
+    type_index(const type_info& __y) : __t_(&__y) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const type_index& __y) const _NOEXCEPT
-        {return *__t_ == *__y.__t_;}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const type_index& __y) const _NOEXCEPT
-        {return *__t_ != *__y.__t_;}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator< (const type_index& __y) const _NOEXCEPT
-        {return  __t_->before(*__y.__t_);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator<=(const type_index& __y) const _NOEXCEPT
-        {return !__y.__t_->before(*__t_);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator> (const type_index& __y) const _NOEXCEPT
-        {return  __y.__t_->before(*__t_);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator>=(const type_index& __y) const _NOEXCEPT
-        {return !__t_->before(*__y.__t_);}
+    bool operator==(const type_index& __y) const {return *__t_ == *__y.__t_;}
+    bool operator!=(const type_index& __y) const {return *__t_ != *__y.__t_;}
+    bool operator< (const type_index& __y) const {return  __t_->before(*__y.__t_);}
+    bool operator<=(const type_index& __y) const {return !__y.__t_->before(*__t_);}
+    bool operator> (const type_index& __y) const {return  __y.__t_->before(*__t_);}
+    bool operator>=(const type_index& __y) const {return !__t_->before(*__y.__t_);}
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t hash_code() const _NOEXCEPT {return __t_->hash_code();}
-    _LIBCPP_INLINE_VISIBILITY
-    const char* name() const _NOEXCEPT {return __t_->name();}
+    size_t hash_code() const {return __t_->hash_code();}
+    const char* name() const {return __t_->name();}
 };
 
-template <class _Tp> struct _LIBCPP_VISIBLE hash;
+template <class _Tp> struct hash;
 
 template <>
-struct _LIBCPP_VISIBLE hash<type_index>
+struct hash<type_index>
     : public unary_function<type_index, size_t>
 {
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(type_index __index) const _NOEXCEPT
-        {return __index.hash_code();}
+    size_t operator()(type_index __index) const {return __index.hash_code();}
 };
 
 _LIBCPP_END_NAMESPACE_STD

include/typeinfo

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -21,14 +21,14 @@ class type_info
 {
 public:
     virtual ~type_info();
-
-    bool operator==(const type_info& rhs) const noexcept;
-    bool operator!=(const type_info& rhs) const noexcept;
-
-    bool before(const type_info& rhs) const noexcept;
-    size_t hash_code() const noexcept;
-    const char* name() const noexcept;
-
+    
+    bool operator==(const type_info& rhs) const;
+    bool operator!=(const type_info& rhs) const;
+    
+    bool before(const type_info& rhs) const;
+    size_t hash_code() const throw();
+    const char* name() const;
+    
     type_info(const type_info& rhs) = delete;
     type_info& operator=(const type_info& rhs) = delete;
 };
@@ -37,20 +37,20 @@ class bad_cast
     : public exception
 {
 public:
-    bad_cast() noexcept;
-    bad_cast(const bad_cast&) noexcept;
-    bad_cast& operator=(const bad_cast&) noexcept;
-    virtual const char* what() const noexcept;
+    bad_cast() throw();
+    bad_cast(const bad_cast&) throw();
+    bad_cast& operator=(const bad_cast&) throw();
+    virtual const char* what() const throw();
 };
 
 class bad_typeid
     : public exception
 {
 public:
-    bad_typeid() noexcept;
-    bad_typeid(const bad_typeid&) noexcept;
-    bad_typeid& operator=(const bad_typeid&) noexcept;
-    virtual const char* what() const noexcept;
+    bad_typeid() throw();
+    bad_typeid(const bad_typeid&) throw();
+    bad_typeid& operator=(const bad_typeid&) throw();
+    virtual const char* what() const throw();
 };
 
 }  // std
@@ -63,60 +63,58 @@ public:
 
 #pragma GCC system_header
 
+
 namespace std  // purposefully not using versioning namespace
 {
 
-class _LIBCPP_EXCEPTION_ABI type_info
+class _LIBCPP_EXCEPTION_ABI type_info 
 {
     type_info& operator=(const type_info&);
     type_info(const type_info&);
 protected:
     const char* __type_name;
 
-    _LIBCPP_INLINE_VISIBILITY
     explicit type_info(const char* __n)
         : __type_name(__n) {}
 
 public:
     virtual ~type_info();
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char* name() const _NOEXCEPT {return __type_name;}
+    const char* name() const {return __type_name;}
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool before(const type_info& __arg) const _NOEXCEPT
+    bool before(const type_info& __arg) const
         {return __type_name < __arg.__type_name;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_t hash_code() const _NOEXCEPT
+    size_t hash_code() const throw()
         {return *reinterpret_cast<const size_t*>(&__type_name);}
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const type_info& __arg) const _NOEXCEPT
+    bool operator==(const type_info& __arg) const
         {return __type_name == __arg.__type_name;}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const type_info& __arg) const _NOEXCEPT
+    bool operator!=(const type_info& __arg) const
         {return !operator==(__arg);}
 
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_cast
-    : public exception
+    : public exception 
 {
 public:
-    bad_cast() _NOEXCEPT;
-    virtual ~bad_cast() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    bad_cast() throw();
+    virtual ~bad_cast() throw();
+    virtual const char* what() const throw();
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_typeid
-    : public exception
+    : public exception 
 {
 public:
-    bad_typeid() _NOEXCEPT;
-    virtual ~bad_typeid() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    bad_typeid() throw();
+    virtual ~bad_typeid() throw();
+    virtual const char* what() const throw();
 };
 
+
 }  // std
 
+
+
 #endif  // __LIBCPP_TYPEINFO

include/unordered_set

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -43,12 +43,7 @@ public:
     typedef /unspecified/ local_iterator;
     typedef /unspecified/ const_local_iterator;
 
-    unordered_set()
-        noexcept(
-            is_nothrow_default_constructible<hasher>::value &&
-            is_nothrow_default_constructible<key_equal>::value &&
-            is_nothrow_default_constructible<allocator_type>::value);
-    explicit unordered_set(size_type n, const hasher& hf = hasher(),
+    explicit unordered_set(size_type n = 0, const hasher& hf = hasher(),
                            const key_equal& eql = key_equal(),
                            const allocator_type& a = allocator_type());
     template <class InputIterator>
@@ -59,37 +54,28 @@ public:
     explicit unordered_set(const allocator_type&);
     unordered_set(const unordered_set&);
     unordered_set(const unordered_set&, const Allocator&);
-    unordered_set(unordered_set&&)
-        noexcept(
-            is_nothrow_move_constructible<hasher>::value &&
-            is_nothrow_move_constructible<key_equal>::value &&
-            is_nothrow_move_constructible<allocator_type>::value);
+    unordered_set(unordered_set&&);
     unordered_set(unordered_set&&, const Allocator&);
     unordered_set(initializer_list<value_type>, size_type n = 0,
                   const hasher& hf = hasher(), const key_equal& eql = key_equal(),
                   const allocator_type& a = allocator_type());
     ~unordered_set();
     unordered_set& operator=(const unordered_set&);
-    unordered_set& operator=(unordered_set&&)
-        noexcept(
-            allocator_type::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<allocator_type>::value &&
-            is_nothrow_move_assignable<hasher>::value &&
-            is_nothrow_move_assignable<key_equal>::value);
+    unordered_set& operator=(unordered_set&&);
     unordered_set& operator=(initializer_list<value_type>);
 
-    allocator_type get_allocator() const noexcept;
+    allocator_type get_allocator() const;
 
-    bool      empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
+    bool      empty() const;
+    size_type size() const;
+    size_type max_size() const;
 
-    iterator       begin() noexcept;
-    iterator       end() noexcept;
-    const_iterator begin()  const noexcept;
-    const_iterator end()    const noexcept;
-    const_iterator cbegin() const noexcept;
-    const_iterator cend()   const noexcept;
+    iterator       begin();
+    iterator       end();
+    const_iterator begin()  const;
+    const_iterator end()    const;
+    const_iterator cbegin() const;
+    const_iterator cend()   const;
 
     template <class... Args>
         pair<iterator, bool> emplace(Args&&... args);
@@ -106,14 +92,9 @@ public:
     iterator erase(const_iterator position);
     size_type erase(const key_type& k);
     iterator erase(const_iterator first, const_iterator last);
-    void clear() noexcept;
+    void clear();
 
-    void swap(unordered_set&)
-        noexcept(
-            (!allocator_type::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<allocator_type>::value) &&
-            __is_nothrow_swappable<hasher>::value &&
-            __is_nothrow_swappable<key_equal>::value);
+    void swap(unordered_set&);
 
     hasher hash_function() const;
     key_equal key_eq() const;
@@ -124,8 +105,8 @@ public:
     pair<iterator, iterator>             equal_range(const key_type& k);
     pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
 
-    size_type bucket_count() const noexcept;
-    size_type max_bucket_count() const noexcept;
+    size_type bucket_count() const;
+    size_type max_bucket_count() const;
 
     size_type bucket_size(size_type n) const;
     size_type bucket(const key_type& k) const;
@@ -137,8 +118,8 @@ public:
     const_local_iterator cbegin(size_type n) const;
     const_local_iterator cend(size_type n) const;
 
-    float load_factor() const noexcept;
-    float max_load_factor() const noexcept;
+    float load_factor() const;
+    float max_load_factor() const;
     void max_load_factor(float z);
     void rehash(size_type n);
     void reserve(size_type n);
@@ -146,8 +127,7 @@ public:
 
 template <class Value, class Hash, class Pred, class Alloc>
     void swap(unordered_set<Value, Hash, Pred, Alloc>& x,
-              unordered_set<Value, Hash, Pred, Alloc>& y)
-              noexcept(noexcept(x.swap(y)));
+              unordered_set<Value, Hash, Pred, Alloc>& y);
 
 template <class Value, class Hash, class Pred, class Alloc>
     bool
@@ -182,12 +162,7 @@ public:
     typedef /unspecified/ local_iterator;
     typedef /unspecified/ const_local_iterator;
 
-    unordered_multiset()
-        noexcept(
-            is_nothrow_default_constructible<hasher>::value &&
-            is_nothrow_default_constructible<key_equal>::value &&
-            is_nothrow_default_constructible<allocator_type>::value);
-    explicit unordered_multiset(size_type n, const hasher& hf = hasher(),
+    explicit unordered_multiset(size_type n = 0, const hasher& hf = hasher(),
                            const key_equal& eql = key_equal(),
                            const allocator_type& a = allocator_type());
     template <class InputIterator>
@@ -198,37 +173,28 @@ public:
     explicit unordered_multiset(const allocator_type&);
     unordered_multiset(const unordered_multiset&);
     unordered_multiset(const unordered_multiset&, const Allocator&);
-    unordered_multiset(unordered_multiset&&)
-        noexcept(
-            is_nothrow_move_constructible<hasher>::value &&
-            is_nothrow_move_constructible<key_equal>::value &&
-            is_nothrow_move_constructible<allocator_type>::value);
+    unordered_multiset(unordered_multiset&&);
     unordered_multiset(unordered_multiset&&, const Allocator&);
     unordered_multiset(initializer_list<value_type>, size_type n = /see below/,
                   const hasher& hf = hasher(), const key_equal& eql = key_equal(),
                   const allocator_type& a = allocator_type());
     ~unordered_multiset();
     unordered_multiset& operator=(const unordered_multiset&);
-    unordered_multiset& operator=(unordered_multiset&&)
-        noexcept(
-            allocator_type::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<allocator_type>::value &&
-            is_nothrow_move_assignable<hasher>::value &&
-            is_nothrow_move_assignable<key_equal>::value);
+    unordered_multiset& operator=(unordered_multiset&&);
     unordered_multiset& operator=(initializer_list<value_type>);
 
-    allocator_type get_allocator() const noexcept;
+    allocator_type get_allocator() const;
 
-    bool      empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
+    bool      empty() const;
+    size_type size() const;
+    size_type max_size() const;
 
-    iterator       begin() noexcept;
-    iterator       end() noexcept;
-    const_iterator begin()  const noexcept;
-    const_iterator end()    const noexcept;
-    const_iterator cbegin() const noexcept;
-    const_iterator cend()   const noexcept;
+    iterator       begin();
+    iterator       end();
+    const_iterator begin()  const;
+    const_iterator end()    const;
+    const_iterator cbegin() const;
+    const_iterator cend()   const;
 
     template <class... Args>
         iterator emplace(Args&&... args);
@@ -245,14 +211,9 @@ public:
     iterator erase(const_iterator position);
     size_type erase(const key_type& k);
     iterator erase(const_iterator first, const_iterator last);
-    void clear() noexcept;
+    void clear();
 
-    void swap(unordered_multiset&)
-        noexcept(
-            (!allocator_type::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<allocator_type>::value) &&
-            __is_nothrow_swappable<hasher>::value &&
-            __is_nothrow_swappable<key_equal>::value);
+    void swap(unordered_multiset&);
 
     hasher hash_function() const;
     key_equal key_eq() const;
@@ -263,8 +224,8 @@ public:
     pair<iterator, iterator>             equal_range(const key_type& k);
     pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
 
-    size_type bucket_count() const noexcept;
-    size_type max_bucket_count() const noexcept;
+    size_type bucket_count() const;
+    size_type max_bucket_count() const;
 
     size_type bucket_size(size_type n) const;
     size_type bucket(const key_type& k) const;
@@ -276,8 +237,8 @@ public:
     const_local_iterator cbegin(size_type n) const;
     const_local_iterator cend(size_type n) const;
 
-    float load_factor() const noexcept;
-    float max_load_factor() const noexcept;
+    float load_factor() const;
+    float max_load_factor() const;
     void max_load_factor(float z);
     void rehash(size_type n);
     void reserve(size_type n);
@@ -285,8 +246,7 @@ public:
 
 template <class Value, class Hash, class Pred, class Alloc>
     void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x,
-              unordered_multiset<Value, Hash, Pred, Alloc>& y)
-              noexcept(noexcept(x.swap(y)));
+              unordered_multiset<Value, Hash, Pred, Alloc>& y);
 
 template <class Value, class Hash, class Pred, class Alloc>
     bool
@@ -311,7 +271,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
           class _Alloc = allocator<_Value> >
-class _LIBCPP_VISIBLE unordered_set
+class unordered_set
 {
 public:
     // types
@@ -339,10 +299,7 @@ public:
     typedef typename __table::const_local_iterator local_iterator;
     typedef typename __table::const_local_iterator const_local_iterator;
 
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_set()
-        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
-        {} // = default;
+    unordered_set() {} // = default;
     explicit unordered_set(size_type __n, const hasher& __hf = hasher(),
                            const key_equal& __eql = key_equal());
     unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql,
@@ -360,11 +317,10 @@ public:
     explicit unordered_set(const allocator_type& __a);
     unordered_set(const unordered_set& __u);
     unordered_set(const unordered_set& __u, const allocator_type& __a);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    unordered_set(unordered_set&& __u)
-        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
+#ifdef _LIBCPP_MOVE
+    unordered_set(unordered_set&& __u);
     unordered_set(unordered_set&& __u, const allocator_type& __a);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     unordered_set(initializer_list<value_type> __il);
     unordered_set(initializer_list<value_type> __il, size_type __n,
                   const hasher& __hf = hasher(),
@@ -374,133 +330,86 @@ public:
                   const allocator_type& __a);
     // ~unordered_set() = default;
     // unordered_set& operator=(const unordered_set& __u) = default;
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    unordered_set& operator=(unordered_set&& __u)
-        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
+#ifdef _LIBCPP_MOVE
+    unordered_set& operator=(unordered_set&& __u);
 #endif
     unordered_set& operator=(initializer_list<value_type> __il);
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT
+    allocator_type get_allocator() const
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __table_.max_size();}
+    bool      empty() const {return __table_.size() == 0;}
+    size_type size() const  {return __table_.size();}
+    size_type max_size() const {return __table_.max_size();}
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       begin() _NOEXCEPT        {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       end() _NOEXCEPT          {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin()  const _NOEXCEPT {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()    const _NOEXCEPT {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const _NOEXCEPT {return __table_.end();}
+    iterator       begin()        {return __table_.begin();}
+    iterator       end()          {return __table_.end();}
+    const_iterator begin()  const {return __table_.begin();}
+    const_iterator end()    const {return __table_.end();}
+    const_iterator cbegin() const {return __table_.begin();}
+    const_iterator cend()   const {return __table_.end();}
 
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+#ifdef _LIBCPP_MOVE
     template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> emplace(_Args&&... __args)
             {return __table_.__emplace_unique(_STD::forward<_Args>(__args)...);}
     template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
         iterator emplace_hint(const_iterator, _Args&&... __args)
             {return __table_.__emplace_unique(_STD::forward<_Args>(__args)...).first;}
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
-    _LIBCPP_INLINE_VISIBILITY
+#endif
     pair<iterator, bool> insert(const value_type& __x)
         {return __table_.__insert_unique(__x);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     pair<iterator, bool> insert(value_type&& __x)
         {return __table_.__insert_unique(_STD::move(__x));}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#endif
     iterator insert(const_iterator, const value_type& __x)
         {return insert(__x).first;}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     iterator insert(const_iterator, value_type&& __x)
         {return insert(_STD::move(__x)).first;}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     template <class _InputIterator>
         void insert(_InputIterator __first, _InputIterator __last);
-    _LIBCPP_INLINE_VISIBILITY
     void insert(initializer_list<value_type> __il)
         {insert(__il.begin(), __il.end());}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator erase(const_iterator __p) {return __table_.erase(__p);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     iterator erase(const_iterator __first, const_iterator __last)
         {return __table_.erase(__first, __last);}
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__table_.clear();}
+    void clear() {__table_.clear();}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(unordered_set& __u)
-        _NOEXCEPT_(__is_nothrow_swappable<__table>::value)
-        {__table_.swap(__u.__table_);}
+    void swap(unordered_set& __u) {__table_.swap(__u.__table_);}
 
-    _LIBCPP_INLINE_VISIBILITY
     hasher hash_function() const {return __table_.hash_function();}
-    _LIBCPP_INLINE_VISIBILITY
     key_equal key_eq() const {return __table_.key_eq();}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator       find(const key_type& __k)       {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator find(const key_type& __k) const {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<iterator, iterator>             equal_range(const key_type& __k)
         {return __table_.__equal_range_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
         {return __table_.__equal_range_unique(__k);}
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
+    size_type bucket_count() const {return __table_.bucket_count();}
+    size_type max_bucket_count() const {return __table_.max_bucket_count();}
 
-    _LIBCPP_INLINE_VISIBILITY
     size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
 
-    _LIBCPP_INLINE_VISIBILITY
     local_iterator       begin(size_type __n)        {return __table_.begin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     local_iterator       end(size_type __n)          {return __table_.end(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     const_local_iterator begin(size_type __n) const  {return __table_.cbegin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     const_local_iterator end(size_type __n) const    {return __table_.cend(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);}
 
-    _LIBCPP_INLINE_VISIBILITY
-    float load_factor() const _NOEXCEPT {return __table_.load_factor();}
-    _LIBCPP_INLINE_VISIBILITY
-    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
-    _LIBCPP_INLINE_VISIBILITY
+    float load_factor() const {return __table_.load_factor();}
+    float max_load_factor() const {return __table_.max_load_factor();}
     void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
-    _LIBCPP_INLINE_VISIBILITY
     void rehash(size_type __n) {__table_.rehash(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     void reserve(size_type __n) {__table_.reserve(__n);}
 };
 
@@ -551,7 +460,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
         const allocator_type& __a)
     : __table_(__a)
@@ -576,13 +485,12 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
     insert(__u.begin(), __u.end());
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
         unordered_set&& __u)
-    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
     : __table_(_STD::move(__u.__table_))
 {
 }
@@ -600,7 +508,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
     }
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
@@ -629,22 +537,21 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
     insert(__il.begin(), __il.end());
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_set<_Value, _Hash, _Pred, _Alloc>&
 unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
 {
     __table_ = _STD::move(__u.__table_);
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_set<_Value, _Hash, _Pred, _Alloc>&
 unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(
         initializer_list<value_type> __il)
@@ -655,7 +562,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 unordered_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                     _InputIterator __last)
@@ -665,11 +572,10 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
      unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
@@ -694,7 +600,7 @@ operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
            const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
@@ -704,7 +610,7 @@ operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
 
 template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
           class _Alloc = allocator<_Value> >
-class _LIBCPP_VISIBLE unordered_multiset
+class unordered_multiset
 {
 public:
     // types
@@ -732,10 +638,7 @@ public:
     typedef typename __table::const_local_iterator local_iterator;
     typedef typename __table::const_local_iterator const_local_iterator;
 
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset()
-        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
-        {} // = default
+    unordered_multiset() {} // = default
     explicit unordered_multiset(size_type __n, const hasher& __hf = hasher(),
                                 const key_equal& __eql = key_equal());
     unordered_multiset(size_type __n, const hasher& __hf,
@@ -753,11 +656,10 @@ public:
     explicit unordered_multiset(const allocator_type& __a);
     unordered_multiset(const unordered_multiset& __u);
     unordered_multiset(const unordered_multiset& __u, const allocator_type& __a);
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    unordered_multiset(unordered_multiset&& __u)
-        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
+#ifdef _LIBCPP_MOVE
+    unordered_multiset(unordered_multiset&& __u);
     unordered_multiset(unordered_multiset&& __u, const allocator_type& __a);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     unordered_multiset(initializer_list<value_type> __il);
     unordered_multiset(initializer_list<value_type> __il, size_type __n,
                        const hasher& __hf = hasher(),
@@ -767,131 +669,84 @@ public:
                        const allocator_type& __a);
     // ~unordered_multiset() = default;
     // unordered_multiset& operator=(const unordered_multiset& __u) = default;
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    unordered_multiset& operator=(unordered_multiset&& __u)
-        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
+#ifdef _LIBCPP_MOVE
+    unordered_multiset& operator=(unordered_multiset&& __u);
 #endif
     unordered_multiset& operator=(initializer_list<value_type> __il);
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT
+    allocator_type get_allocator() const
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __table_.max_size();}
+    bool      empty() const {return __table_.size() == 0;}
+    size_type size() const  {return __table_.size();}
+    size_type max_size() const {return __table_.max_size();}
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       begin() _NOEXCEPT        {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       end() _NOEXCEPT          {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin()  const _NOEXCEPT {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()    const _NOEXCEPT {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const _NOEXCEPT {return __table_.end();}
+    iterator       begin()        {return __table_.begin();}
+    iterator       end()          {return __table_.end();}
+    const_iterator begin()  const {return __table_.begin();}
+    const_iterator end()    const {return __table_.end();}
+    const_iterator cbegin() const {return __table_.begin();}
+    const_iterator cend()   const {return __table_.end();}
 
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+#ifdef _LIBCPP_MOVE
     template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
         iterator emplace(_Args&&... __args)
             {return __table_.__emplace_multi(_STD::forward<_Args>(__args)...);}
     template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
         iterator emplace_hint(const_iterator __p, _Args&&... __args)
             {return __table_.__emplace_hint_multi(__p, _STD::forward<_Args>(__args)...);}
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
-    _LIBCPP_INLINE_VISIBILITY
+#endif
     iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     iterator insert(value_type&& __x) {return __table_.__insert_multi(_STD::move(__x));}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, const value_type& __x)
         {return __table_.__insert_multi(__p, __x);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+#ifdef _LIBCPP_MOVE
     iterator insert(const_iterator __p, value_type&& __x)
         {return __table_.__insert_multi(__p, _STD::move(__x));}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
     template <class _InputIterator>
         void insert(_InputIterator __first, _InputIterator __last);
-    _LIBCPP_INLINE_VISIBILITY
     void insert(initializer_list<value_type> __il)
         {insert(__il.begin(), __il.end());}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator erase(const_iterator __p) {return __table_.erase(__p);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     iterator erase(const_iterator __first, const_iterator __last)
         {return __table_.erase(__first, __last);}
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__table_.clear();}
+    void clear() {__table_.clear();}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(unordered_multiset& __u)
-        _NOEXCEPT_(__is_nothrow_swappable<__table>::value)
-        {__table_.swap(__u.__table_);}
+    void swap(unordered_multiset& __u) {__table_.swap(__u.__table_);}
 
-    _LIBCPP_INLINE_VISIBILITY
     hasher hash_function() const {return __table_.hash_function();}
-    _LIBCPP_INLINE_VISIBILITY
     key_equal key_eq() const {return __table_.key_eq();}
 
-    _LIBCPP_INLINE_VISIBILITY
     iterator       find(const key_type& __k)       {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     const_iterator find(const key_type& __k) const {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<iterator, iterator>             equal_range(const key_type& __k)
         {return __table_.__equal_range_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
     pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
         {return __table_.__equal_range_multi(__k);}
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
+    size_type bucket_count() const {return __table_.bucket_count();}
+    size_type max_bucket_count() const {return __table_.max_bucket_count();}
 
-    _LIBCPP_INLINE_VISIBILITY
     size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
 
-    _LIBCPP_INLINE_VISIBILITY
     local_iterator       begin(size_type __n)        {return __table_.begin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     local_iterator       end(size_type __n)          {return __table_.end(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     const_local_iterator begin(size_type __n) const  {return __table_.cbegin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     const_local_iterator end(size_type __n) const    {return __table_.cend(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);}
 
-    _LIBCPP_INLINE_VISIBILITY
-    float load_factor() const _NOEXCEPT {return __table_.load_factor();}
-    _LIBCPP_INLINE_VISIBILITY
-    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
-    _LIBCPP_INLINE_VISIBILITY
+    float load_factor() const {return __table_.load_factor();}
+    float max_load_factor() const {return __table_.max_load_factor();}
     void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
-    _LIBCPP_INLINE_VISIBILITY
     void rehash(size_type __n) {__table_.rehash(__n);}
-    _LIBCPP_INLINE_VISIBILITY
     void reserve(size_type __n) {__table_.reserve(__n);}
 };
 
@@ -943,7 +798,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
         const allocator_type& __a)
     : __table_(__a)
@@ -968,13 +823,12 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
     insert(__u.begin(), __u.end());
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
         unordered_multiset&& __u)
-    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
     : __table_(_STD::move(__u.__table_))
 {
 }
@@ -992,7 +846,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
     }
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
@@ -1021,20 +875,19 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
     insert(__il.begin(), __il.end());
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
         unordered_multiset&& __u)
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
 {
     __table_ = _STD::move(__u.__table_);
     return *this;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 inline
@@ -1048,7 +901,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
                                                          _InputIterator __last)
@@ -1058,11 +911,10 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
      unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
@@ -1091,7 +943,7 @@ operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
            const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)

include/utility

@@ -3,8 +3,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ -29,28 +29,20 @@ namespace rel_ops
     template<class T> bool operator>=(const T&, const T&);
 }
 
-template<class T>
-void
-swap(T& a, T& b) noexcept(is_nothrow_move_constructible<T>::value &&
-                          is_nothrow_move_assignable<T>::value);
+template<class T> void swap(T& a, T& b);
+template <class T, size_t N> void swap(T (&a)[N], T (&b)[N]);
 
-template <class T, size_t N>
-void
-swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b)));
-
-template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;
-template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept;
-
-template <class T> typename remove_reference<T>::type&& move(T&&) noexcept;
+template <class T, class U> T&& forward(U&&);
+template <class T> typename remove_reference<T>::type&& move(T&&);
 
 template <class T>
     typename conditional
     <
-        !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
+        !has_nothrow_move_constructor<T>::value && has_copy_constructor<T>::value,
         const T&,
         T&&
     >::type
-    move_if_noexcept(T& x) noexcept;
+    move_if_noexcept(T& x);
 
 template <class T> typename add_rvalue_reference<T>::type declval() noexcept;
 
@@ -64,7 +56,6 @@ struct pair
     T2 second;
 
     pair(const pair&) = default;
-    pair(pair&&) = default;
     constexpr pair();
     pair(const T1& x, const T2& y);
     template <class U, class V> pair(U&& x, V&& y);
@@ -75,12 +66,10 @@ struct pair
              tuple<Args2...> second_args);
 
     template <class U, class V> pair& operator=(const pair<U, V>& p);
-    pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable<T1>::value &&
-                                       is_nothrow_move_assignable<T2>::value);
+    pair& operator=(pair&& p);
     template <class U, class V> pair& operator=(pair<U, V>&& p);
 
-    void swap(pair& p) noexcept(noexcept(swap(first, p.first)) &&
-                                noexcept(swap(second, p.second)));
+    void swap(pair& p);
 };
 
 template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&);
@@ -91,9 +80,7 @@ template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,
 template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&);
 
 template <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&);
-template <class T1, class T2>
-void
-swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));
+template <class T1, class T2> void swap(pair<T1, T2>& x, pair<T1, T2>& y);
 
 struct piecewise_construct_t { };
 constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
@@ -107,15 +94,16 @@ template <class T1, class T2> struct tuple_element<1, std::pair<T1, T2> >;
 
 template<size_t I, class T1, class T2>
     typename tuple_element<I, std::pair<T1, T2> >::type&
-    get(std::pair<T1, T2>&) noexcept;
+    get(std::pair<T1, T2>&);
 
 template<size_t I, class T1, class T2>
     const typename const tuple_element<I, std::pair<T1, T2> >::type&
-    get(const std::pair<T1, T2>&) noexcept;
+    get(const std::pair<T1, T2>&);
 
-template<size_t I, class T1, class T2>
-    typename tuple_element<I, std::pair<T1, T2> >::type&&
-    get(std::pair<T1, T2>&&) noexcept;
+template <class InputIterator>
+    InputIterator begin(const std::pair<InputIterator, InputIterator>& p);
+template <class InputIterator>
+    InputIterator end(const std::pair<InputIterator, InputIterator>& p);
 
 }  // std
 
@@ -181,34 +169,37 @@ swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardItera
 template<class _Tp, size_t _N>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-swap(_Tp (&__a)[_N], _Tp (&__b)[_N]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
+swap(_Tp (&__a)[_N], _Tp (&__b)[_N])
 {
     _STD::swap_ranges(__a, __a + _N, __b);
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 typename conditional
 <
-    !is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value,
+    !has_nothrow_move_constructor<_Tp>::value && has_copy_constructor<_Tp>::value,
     const _Tp&,
     _Tp&&
 >::type
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#else
 const _Tp&
 #endif
-move_if_noexcept(_Tp& __x) _NOEXCEPT
+move_if_noexcept(_Tp& __x)
 {
     return _STD::move(__x);
 }
 
-struct _LIBCPP_VISIBLE piecewise_construct_t { };
+struct piecewise_construct_t { };
 //constexpr
 extern const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();
 
+template <class _T1, class _T2> struct pair;
+template <class _T1, class _T2> void swap(pair<_T1, _T2>&, pair<_T1, _T2>&);
+
 template <class _T1, class _T2>
-struct _LIBCPP_VISIBLE pair
+struct pair
 {
     typedef _T1 first_type;
     typedef _T2 second_type;
@@ -216,30 +207,12 @@ struct _LIBCPP_VISIBLE pair
     _T1 first;
     _T2 second;
 
-    // pair(const pair&) = default;
-    // pair(pair&&) = default;
-
     _LIBCPP_INLINE_VISIBILITY pair() : first(), second() {}
 
     _LIBCPP_INLINE_VISIBILITY pair(const _T1& __x, const _T2& __y)
         : first(__x), second(__y) {}
 
-    template<class _U1, class _U2>
-        _LIBCPP_INLINE_VISIBILITY
-        pair(const pair<_U1, _U2>& __p,
-                 typename enable_if<is_convertible<_U1, _T1>::value &&
-                                    is_convertible<_U2, _T2>::value>::type* = 0)
-            : first(__p.first), second(__p.second) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    pair& operator=(const pair& __p)
-    {
-        first = __p.first;
-        second = __p.second;
-        return *this;
-    }
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
     template <class _U1, class _U2,
               class = typename enable_if<is_convertible<_U1, first_type >::value &&
@@ -250,26 +223,6 @@ struct _LIBCPP_VISIBLE pair
               second(_STD::forward<_U2>(__u2))
             {}
 
-    template<class _U1, class _U2>
-        _LIBCPP_INLINE_VISIBILITY
-        pair(pair<_U1, _U2>&& __p,
-                 typename enable_if<is_convertible<_U1, _T1>::value &&
-                                    is_convertible<_U2, _T2>::value>::type* = 0)
-            : first(_STD::forward<_U1>(__p.first)),
-              second(_STD::forward<_U2>(__p.second)) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    pair&
-    operator=(pair&& __p) _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
-                                     is_nothrow_move_assignable<second_type>::value)
-    {
-        first = _STD::forward<first_type>(__p.first);
-        second = _STD::forward<second_type>(__p.second);
-        return *this;
-    }
-
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
     template<class _Tuple,
              class = typename enable_if<__tuple_convertible<_Tuple, pair>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
@@ -280,20 +233,18 @@ struct _LIBCPP_VISIBLE pair
                                    typename __make_tuple_types<_Tuple>::type>::type>(get<1>(__p)))
             {}
 
-
-
+#ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
-        _LIBCPP_INLINE_VISIBILITY
         pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
                                     tuple<_Args2...> __second_args)
-            : pair(__pc, __first_args, __second_args,
+            : pair(__pc, __first_args, __second_args, 
                    typename __make_tuple_indices<sizeof...(_Args1)>::type(),
                    typename __make_tuple_indices<sizeof...(_Args2) >::type())
             {}
+#endif
 
     template <class _Tuple,
               class = typename enable_if<__tuple_assignable<_Tuple, pair>::value>::type>
-        _LIBCPP_INLINE_VISIBILITY
         pair&
         operator=(_Tuple&& __p)
         {
@@ -305,26 +256,20 @@ struct _LIBCPP_VISIBLE pair
             return *this;
         }
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    void
-    swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
-                               __is_nothrow_swappable<second_type>::value)
-    {
-        _STD::iter_swap(&first, &__p.first);
-        _STD::iter_swap(&second, &__p.second);
-    }
+#else
+    template<class _U1, class _U2>
+        _LIBCPP_INLINE_VISIBILITY pair(const pair<_U1, _U2>& __p)
+            : first(__p.first), second(__p.second) {}
+#endif
+    void _LIBCPP_INLINE_VISIBILITY swap(pair& __p) {_STD::swap(*this, __p);}
 private:
-
+    
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
-        _LIBCPP_INLINE_VISIBILITY
         pair(piecewise_construct_t,
              tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
              __tuple_indices<_I1...>, __tuple_indices<_I2...>);
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#endif
 };
 
 template <class _T1, class _T2>
@@ -377,20 +322,14 @@ operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
 
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_swappable<_T1>::value &&
-    __is_swappable<_T2>::value,
-    void
->::type
+void
 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
-                     _NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
-                                 __is_nothrow_swappable<_T2>::value))
 {
-    __x.swap(__y);
+    swap(__x.first, __y.first);
+    swap(__x.second, __y.second);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#ifdef _LIBCPP_MOVE
 
 template <class _Tp> class reference_wrapper;
 
@@ -413,7 +352,7 @@ struct __make_pair_return
 };
 
 template <class _T1, class _T2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
 make_pair(_T1&& __t1, _T2&& __t2)
 {
@@ -421,7 +360,7 @@ make_pair(_T1&& __t1, _T2&& __t2)
                (_STD::forward<_T1>(__t1), _STD::forward<_T2>(__t2));
 }
 
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#else
 
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -431,41 +370,39 @@ make_pair(_T1 __x, _T2 __y)
     return pair<_T1, _T2>(__x, __y);
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 template <class _T1, class _T2>
-  class _LIBCPP_VISIBLE tuple_size<pair<_T1, _T2> >
-    : public integral_constant<size_t, 2> {};
+  class tuple_size<pair<_T1, _T2> > : public integral_constant<size_t, 2> {};
 
 template <class _T1, class _T2>
-  class _LIBCPP_VISIBLE tuple_size<const pair<_T1, _T2> >
-    : public integral_constant<size_t, 2> {};
+  class tuple_size<const pair<_T1, _T2> > : public integral_constant<size_t, 2> {};
 
 template <class _T1, class _T2>
-class _LIBCPP_VISIBLE tuple_element<0, pair<_T1, _T2> >
+class tuple_element<0, pair<_T1, _T2> >
 {
 public:
     typedef _T1 type;
 };
 
 template <class _T1, class _T2>
-class _LIBCPP_VISIBLE tuple_element<1, pair<_T1, _T2> >
+class tuple_element<1, pair<_T1, _T2> >
 {
 public:
     typedef _T2 type;
 };
 
 template <class _T1, class _T2>
-class _LIBCPP_VISIBLE tuple_element<0, const pair<_T1, _T2> >
+class tuple_element<0, const pair<_T1, _T2> >
 {
 public:
     typedef const _T1 type;
 };
 
 template <class _T1, class _T2>
-class _LIBCPP_VISIBLE tuple_element<1, const pair<_T1, _T2> >
+class tuple_element<1, const pair<_T1, _T2> >
 {
 public:
     typedef const _T2 type;
@@ -480,23 +417,13 @@ struct __get_pair<0>
     static
     _LIBCPP_INLINE_VISIBILITY
     _T1&
-    get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
+    get(pair<_T1, _T2>& __p) {return __p.first;}
 
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY
     const _T1&
-    get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    template <class _T1, class _T2>
-    static
-    _LIBCPP_INLINE_VISIBILITY
-    _T1&&
-    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _STD::forward<_T1>(__p.first);}
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    get(const pair<_T1, _T2>& __p) {return __p.first;}
 };
 
 template <>
@@ -506,29 +433,19 @@ struct __get_pair<1>
     static
     _LIBCPP_INLINE_VISIBILITY
     _T2&
-    get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
+    get(pair<_T1, _T2>& __p) {return __p.second;}
 
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY
     const _T2&
-    get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    template <class _T1, class _T2>
-    static
-    _LIBCPP_INLINE_VISIBILITY
-    _T2&&
-    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _STD::forward<_T2>(__p.second);}
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    get(const pair<_T1, _T2>& __p) {return __p.second;}
 };
 
 template <size_t _Ip, class _T1, class _T2>
 _LIBCPP_INLINE_VISIBILITY inline
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
-get(pair<_T1, _T2>& __p) _NOEXCEPT
+get(pair<_T1, _T2>& __p)
 {
     return __get_pair<_Ip>::get(__p);
 }
@@ -536,24 +453,28 @@ get(pair<_T1, _T2>& __p) _NOEXCEPT
 template <size_t _Ip, class _T1, class _T2>
 _LIBCPP_INLINE_VISIBILITY inline
 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
-get(const pair<_T1, _T2>& __p) _NOEXCEPT
+get(const pair<_T1, _T2>& __p)
 {
     return __get_pair<_Ip>::get(__p);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 
-template <size_t _Ip, class _T1, class _T2>
+template <class _InputIterator>
 _LIBCPP_INLINE_VISIBILITY inline
-typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
-get(pair<_T1, _T2>&& __p) _NOEXCEPT
+_InputIterator
+begin(const pair<_InputIterator, _InputIterator>& __p)
 {
-    return __get_pair<_Ip>::get(_STD::move(__p));
+    return __p.first;
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+template <class _InputIterator>
+_LIBCPP_INLINE_VISIBILITY inline
+_InputIterator
+end(const pair<_InputIterator, _InputIterator>& __p)
+{
+    return __p.second;
+}
 
 _LIBCPP_END_NAMESPACE_STD