From 72d25f1d46f25a6aa4fbaea884bb583cec7332c5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Wed, 23 Oct 2013 17:43:01 +0300
Subject: [PATCH 01/93] Implement SDL_SetVideoMode(0,0, ...) to create the
 canvas in whatever size the <canvas> was in, and not try to resize the canvas
 to 0x0 pixels. Derive a new test for that from sdl_ogl.c. Fixes #1059.

---
 src/library_sdl.js         |   8 ++
 tests/sdl_canvas_size.c    | 191 +++++++++++++++++++++++++++++++++++++
 tests/sdl_canvas_size.html |  93 ++++++++++++++++++
 tests/test_browser.py      |   5 +
 4 files changed, 297 insertions(+)
 create mode 100644 tests/sdl_canvas_size.c
 create mode 100644 tests/sdl_canvas_size.html

diff --git a/src/library_sdl.js b/src/library_sdl.js
index a06893436050d..857ab7d4b418d 100644
--- a/src/library_sdl.js
+++ b/src/library_sdl.js
@@ -786,6 +786,14 @@ var LibrarySDL = {
     ['mousedown', 'mouseup', 'mousemove', 'DOMMouseScroll', 'mousewheel', 'mouseout'].forEach(function(event) {
       Module['canvas'].addEventListener(event, SDL.receiveEvent, true);
     });
+
+    // (0,0) means 'use fullscreen' in native; in Emscripten, use the current canvas size.
+    if (width == 0 && height == 0) {
+      var canvas = Module['canvas'];
+      width = canvas.width;
+      height = canvas.height;
+    }
+
     Browser.setCanvasSize(width, height, true);
     // Free the old surface first.
     if (SDL.screen) {
diff --git a/tests/sdl_canvas_size.c b/tests/sdl_canvas_size.c
new file mode 100644
index 0000000000000..923a90147dfb3
--- /dev/null
+++ b/tests/sdl_canvas_size.c
@@ -0,0 +1,191 @@
+/*******************************************************************
+ *                                                                 *
+ *                        Using SDL With OpenGL                    *
+ *                                                                 *
+ *                    Tutorial by Kyle Foley (sdw)                 *
+ *                                                                 *
+ * http://gpwiki.org/index.php/SDL:Tutorials:Using_SDL_with_OpenGL *
+ *                                                                 *
+ *******************************************************************/
+
+/*
+THIS WORK, INCLUDING THE SOURCE CODE, DOCUMENTATION
+AND RELATED MEDIA AND DATA, IS PLACED INTO THE PUBLIC DOMAIN.
+
+THE ORIGINAL AUTHOR IS KYLE FOLEY.
+
+THIS SOFTWARE IS PROVIDED AS-IS WITHOUT WARRANTY
+OF ANY KIND, NOT EVEN THE IMPLIED WARRANTY OF
+MERCHANTABILITY. THE AUTHOR OF THIS SOFTWARE,
+ASSUMES _NO_ RESPONSIBILITY FOR ANY CONSEQUENCE
+RESULTING FROM THE USE, MODIFICATION, OR
+REDISTRIBUTION OF THIS SOFTWARE.
+*/
+
+#include "SDL/SDL.h"
+#include "SDL/SDL_image.h"
+#include "SDL/SDL_opengl.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#ifdef EMSCRIPTEN
+#include <emscripten.h>
+#endif
+
+int main(int argc, char *argv[])
+{
+    SDL_Surface *screen;
+
+    // Slightly different SDL initialization
+    if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) {
+        printf("Unable to initialize SDL: %s\n", SDL_GetError());
+        return 1;
+    }
+
+    SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // *new*
+
+#ifdef EMSCRIPTEN
+    // Test 1: Check that initializing video mode with size (0,0) will use the size from the <canvas> element.
+    screen = SDL_SetVideoMode( 0, 0, 16, SDL_OPENGL ); // *changed*
+
+    // Test 2: Check that getting current canvas size works.
+    int w, h, fs;
+    emscripten_get_canvas_size(&w, &h, &fs);
+    printf("w:%d,h:%d\n", w,h);
+    assert(w == 700);
+    assert(h == 200);
+    
+    // Test 3: Check that resizing the canvas works as well.
+    emscripten_set_canvas_size(640, 480);
+    // Set the OpenGL state after creating the context with SDL_SetVideoMode
+#else
+    screen = SDL_SetVideoMode( 640, 480, 16, SDL_OPENGL ); // *changed*
+#endif
+
+     if ( !screen ) {
+        printf("Unable to set video mode: %s\n", SDL_GetError());
+        return 1;
+    }
+
+    glClearColor( 0, 0, 0, 0 );
+
+    glEnable( GL_TEXTURE_2D ); // Needed when we're using the fixed-function pipeline.
+
+    glViewport( 0, 0, 640, 480 );
+
+    glMatrixMode( GL_PROJECTION );
+    glPushMatrix(); // just for testing
+    glLoadIdentity();
+
+    glOrtho( 0, 640, 480, 0, -1, 1 );
+
+    glMatrixMode( GL_MODELVIEW );
+    glLoadIdentity();
+
+    // Load the OpenGL texture
+
+    GLuint texture; // Texture object handle
+    SDL_Surface *surface; // Gives us the information to make the texture
+
+    if ( (surface = IMG_Load("screenshot.png")) ) {
+
+        // Check that the image's width is a power of 2
+        if ( (surface->w & (surface->w - 1)) != 0 ) {
+            printf("warning: image.bmp's width is not a power of 2\n");
+        }
+
+        // Also check if the height is a power of 2
+        if ( (surface->h & (surface->h - 1)) != 0 ) {
+            printf("warning: image.bmp's height is not a power of 2\n");
+        }
+
+        // Have OpenGL generate a texture object handle for us
+        glGenTextures( 1, &texture );
+
+        // Bind the texture object
+        glBindTexture( GL_TEXTURE_2D, texture );
+
+        // Set the texture's stretching properties
+        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+
+        //SDL_LockSurface(surface);
+
+        // Add some greyness
+        memset(surface->pixels, 0x66, surface->w*surface->h);
+
+        // Edit the texture object's image data using the information SDL_Surface gives us
+        glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, surface->w, surface->h, 0,
+                      GL_RGBA, GL_UNSIGNED_BYTE, surface->pixels );
+
+        //SDL_UnlockSurface(surface);
+    }
+    else {
+        printf("SDL could not load image.bmp: %s\n", SDL_GetError());
+        SDL_Quit();
+        return 1;
+    }
+
+    // Free the SDL_Surface only if it was successfully created
+    if ( surface ) {
+        SDL_FreeSurface( surface );
+    }
+
+    // Clear the screen before drawing
+    glClear( GL_COLOR_BUFFER_BIT );
+
+    // Bind the texture to which subsequent calls refer to
+    glBindTexture( GL_TEXTURE_2D, texture );
+
+    glBegin( GL_QUADS );
+        glTexCoord2i( 0, 0 ); glVertex3f( 10, 10, 0 );
+        glTexCoord2i( 1, 0 ); glVertex3f( 300, 10, 0 );
+        glTexCoord2i( 1, 1 ); glVertex3f( 300, 128, 0 );
+        glTexCoord2i( 0, 1 ); glVertex3f( 10, 128, 0 );
+
+        glTexCoord2f( 0, 0.5 ); glVertex3f( 410, 10, 0 );
+        glTexCoord2f( 1, 0.5 ); glVertex3f( 600, 10, 0 );
+        glTexCoord2f( 1, 1   ); glVertex3f( 630, 200, 0 );
+        glTexCoord2f( 0.5, 1 ); glVertex3f( 310, 250, 0 );
+    glEnd();
+
+    glBegin( GL_TRIANGLE_STRIP );
+        glTexCoord2i( 0, 0 ); glVertex3f( 100, 300, 0 );
+        glTexCoord2i( 1, 0 ); glVertex3f( 300, 300, 0 );
+        glTexCoord2i( 1, 1 ); glVertex3f( 300, 400, 0 );
+        glTexCoord2i( 0, 1 ); glVertex3f( 500, 410, 0 );
+    glEnd();
+
+    glDisable(GL_TEXTURE_2D);
+
+    glColor3ub(90, 255, 255);
+    glBegin( GL_QUADS );
+        glVertex3f( 10, 410, 0 );
+        glVertex3f( 300, 410, 0 );
+        glVertex3f( 300, 480, 0 );
+        glVertex3f( 10, 470, 0 );
+    glEnd();
+
+    glBegin( GL_QUADS );
+        glColor3f(1.0, 0, 1.0);   glVertex3f( 410, 410, 0 );
+        glColor3f(0, 1.0, 0);     glVertex3f( 600, 410, 0 );
+        glColor3f(0, 0, 1.0);     glVertex3f( 600, 480, 0 );
+        glColor3f(1.0, 1.0, 1.0); glVertex3f( 410, 470, 0 );
+    glEnd();
+
+    SDL_GL_SwapBuffers();
+
+#if !EMSCRIPTEN
+    // Wait for 3 seconds to give us a chance to see the image
+    SDL_Delay(3000);
+#endif
+
+    // Now we can delete the OpenGL texture and close down SDL
+    glDeleteTextures( 1, &texture );
+
+    SDL_Quit();
+
+    return 0;
+}
diff --git a/tests/sdl_canvas_size.html b/tests/sdl_canvas_size.html
new file mode 100644
index 0000000000000..5c70210b9bc13
--- /dev/null
+++ b/tests/sdl_canvas_size.html
@@ -0,0 +1,93 @@
+<!doctype html>
+<html lang="en-us">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <title>Emscripten-Generated Code</title>
+    <style>
+      .emscripten { padding-right: 0; margin-left: auto; margin-right: auto; display: block; }
+      textarea.emscripten { font-family: monospace; width: 80%; }
+      div.emscripten { text-align: center; }
+      div.emscripten_border { border: 1px solid black; }
+      /* the canvas *must not* have any border or padding, or mouse coords will be wrong */
+      canvas.emscripten { border: 0px none; }
+    </style>
+  </head>
+  <body>
+    <hr/>
+    <div class="emscripten" id="status">Downloading...</div>
+    <div class="emscripten">
+      <progress value="0" max="100" id="progress" hidden=1></progress>  
+    </div>
+    <div class="emscripten_border">
+    <!-- Pass custom width/height to test that SDL_SetVideoMode(0,0, ...) will use these. -->
+      <canvas class="emscripten" id="canvas" width="700" height="200" oncontextmenu="event.preventDefault()"></canvas>
+    </div>
+    <hr/>
+    <div class="emscripten">
+      <input type="checkbox" id="resize">Resize canvas
+      <input type="checkbox" id="pointerLock" checked>Lock/hide mouse pointer
+      &nbsp;&nbsp;&nbsp;
+      <input type="button" value="Fullscreen" onclick="Module.requestFullScreen(document.getElementById('pointerLock').checked, 
+                                                                                document.getElementById('resize').checked)">
+    </div>
+    
+    <hr/>
+    <textarea class="emscripten" id="output" rows="8"></textarea>
+    <hr>
+    <script type='text/javascript'>
+      // connect to canvas
+      var Module = {
+        preRun: [],
+        postRun: [],
+        print: (function() {
+          var element = document.getElementById('output');
+          element.value = ''; // clear browser cache
+          return function(text) {
+            text = Array.prototype.slice.call(arguments).join(' ');
+            // These replacements are necessary if you render to raw HTML
+            //text = text.replace(/&/g, "&amp;");
+            //text = text.replace(/</g, "&lt;");
+            //text = text.replace(/>/g, "&gt;");
+            //text = text.replace('\n', '<br>', 'g');
+            element.value += text + "\n";
+            element.scrollTop = 99999; // focus on bottom
+          };
+        })(),
+        printErr: function(text) {
+          text = Array.prototype.slice.call(arguments).join(' ');
+          if (0) { // XXX disabled for safety typeof dump == 'function') {
+            dump(text + '\n'); // fast, straight to the real console
+          } else {
+            console.log(text);
+          }
+        },
+        canvas: document.getElementById('canvas'),
+        setStatus: function(text) {
+          if (Module.setStatus.interval) clearInterval(Module.setStatus.interval);
+          var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/);
+          var statusElement = document.getElementById('status');
+          var progressElement = document.getElementById('progress');
+          if (m) {
+            text = m[1];
+            progressElement.value = parseInt(m[2])*100;
+            progressElement.max = parseInt(m[4])*100;
+            progressElement.hidden = false;
+          } else {
+            progressElement.value = null;
+            progressElement.max = null;
+            progressElement.hidden = true;
+          }
+          statusElement.innerHTML = text;
+        },
+        totalDependencies: 0,
+        monitorRunDependencies: function(left) {
+          this.totalDependencies = Math.max(this.totalDependencies, left);
+          Module.setStatus(left ? 'Preparing... (' + (this.totalDependencies-left) + '/' + this.totalDependencies + ')' : 'All downloads complete.');
+        }
+      };
+      Module.setStatus('Downloading...');
+    </script>
+    <script async type='text/javascript'>{{{ SCRIPT_CODE }}}</script>
+  </body>
+</html>
diff --git a/tests/test_browser.py b/tests/test_browser.py
index ecd331fd3c699..000dd95ab648e 100644
--- a/tests/test_browser.py
+++ b/tests/test_browser.py
@@ -942,6 +942,11 @@ def test_sdl_audio_beeps(self):
     Popen([PYTHON, EMCC, '-O2', '--closure', '1', '--minify', '0', os.path.join(self.get_dir(), 'sdl_audio_beep.cpp'), '-s', 'DISABLE_EXCEPTION_CATCHING=0', '-o', 'page.html']).communicate()
     self.run_browser('page.html', '', '/report_result?1')
 
+  def test_sdl_canvas_size(self):
+    self.btest('sdl_canvas_size.c', reference='screenshot-gray-purple.png', reference_slack=1,
+      args=['-O2', '--minify', '0', '--shell-file', path_from_root('tests', 'sdl_canvas_size.html'), '--preload-file', os.path.join(self.get_dir(), 'screenshot.png') + '@/', '-s', 'LEGACY_GL_EMULATION=1'],
+      message='You should see an image with gray at the top.')
+
   def test_sdl_gl_read(self):
     # SDL, OpenGL, readPixels
     open(os.path.join(self.get_dir(), 'sdl_gl_read.c'), 'w').write(self.with_report_result(open(path_from_root('tests', 'sdl_gl_read.c')).read()))

From 6d125fcc3e6ca573a337b7a5a0897cdc0a638f3c Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 23 Oct 2013 17:53:40 -0700
Subject: [PATCH 02/93] emit emscripten version in emcc -v

---
 emcc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/emcc b/emcc
index 4222caa3db2ae..5b79b411bb120 100755
--- a/emcc
+++ b/emcc
@@ -542,7 +542,7 @@ There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR P
   exit(0)  
 
 elif len(sys.argv) == 2 and sys.argv[1] == '-v': # -v with no inputs
-  print 'emcc (Emscripten GCC-like replacement + linker emulating GNU ld ) 2.0'
+  print 'emcc (Emscripten GCC-like replacement + linker emulating GNU ld ) %s' % shared.EMSCRIPTEN_VERSION
   exit(subprocess.call([shared.CLANG, '-v']))
 
 def is_minus_s_for_emcc(newargs,i):

From 50ee300ffabb6c5e5c6a2d4b4762343822ea1dc2 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 23 Oct 2013 18:36:32 -0700
Subject: [PATCH 03/93] write out html and side js when html output is
 requested, to improve page load times

---
 emcc                              | 29 +++++++++++++++--------------
 src/shell.html                    |  2 +-
 tests/embind/shell.html           |  2 +-
 tests/hello_world_gles_shell.html |  2 +-
 tests/sdl_canvas_size.html        |  2 +-
 5 files changed, 19 insertions(+), 18 deletions(-)

diff --git a/emcc b/emcc
index 5b79b411bb120..3406ff83b554a 100755
--- a/emcc
+++ b/emcc
@@ -397,7 +397,8 @@ Options that are modified or new in %s include:
   --shell-file <path>      The path name to a skeleton HTML file used
                            when generating HTML output. The shell file
                            used needs to have this token inside it:
-                           {{{ SCRIPT_CODE }}}
+                           {{{ SCRIPT }}}
+                           (see src/shell.html for an example)
                            Note that this argument is ignored if a
                            target other than HTML is specified using
                            the -o option.
@@ -501,7 +502,8 @@ The target file, if specified (-o <target>), defines what will
 be generated:
 
   <name>.js                JavaScript
-  <name>.html              HTML with embedded JavaScript
+  <name>.html              HTML + side JavaScript file (<name>.js)
+                             (JS on the side improves page load time)
   <name>.bc                LLVM bitcode (default)
   <name>.o                 LLVM bitcode (same as .bc)
 
@@ -1818,22 +1820,21 @@ try:
   if final_suffix == 'html':
     logging.debug('generating HTML')
     shell = open(shell_path).read()
+    assert '{{{ SCRIPT }}}' in shell, 'HTML shell must contain  {{{ SCRIPT }}}  , see src/shell.html for an example'
     html = open(target, 'w')
+    js_target = unsuffixed(target) + '.js'
+    base_js_target = os.path.basename(js_target)
     if proxy_to_worker:
-      html.write(shell.replace('{{{ SCRIPT_CODE }}}', open(shared.path_from_root('src', 'proxyClient.js')).read().replace('{{{ filename }}}', target_basename)))
-      js_target = unsuffixed(target) + '.js'
-      shutil.copyfile(final, js_target)
+      html.write(shell.replace('{{{ SCRIPT }}}', '<script>' + open(shared.path_from_root('src', 'proxyClient.js')).read().replace('{{{ filename }}}', target_basename) + '</script>'))
+      shutil.move(final, js_target)
     elif not Compression.on:
       if debug_level >= 4:
-        match = re.match('.*?<script[^>]*>{{{ SCRIPT_CODE }}}</script>', shell,
-            re.DOTALL)
-        if match is None:
-          raise RuntimeError('''Could not find script insertion point - make sure you have   <script type='text/javascript'>{{{ SCRIPT_CODE }}}</script>   in your HTML file (with no newlines)''')
-        generate_source_map(target, match.group().count('\n'))
-      html.write(shell.replace('{{{ SCRIPT_CODE }}}', open(final).read()))
+        generate_source_map(target)
+      shutil.move(final, js_target)
+      script_tag = '''<script async type="text/javascript" src="%s"></script>''' % base_js_target
+      html.write(shell.replace('{{{ SCRIPT }}}', script_tag))
     else:
       # Compress the main code
-      js_target = unsuffixed(target) + '.js'
       shutil.move(final, js_target)
       Compression.compress(js_target)
 
@@ -1881,8 +1882,8 @@ try:
           });
         };
         compiledCodeXHR.send(null);
-''' % Compression.compressed_name(js_target)
-      html.write(shell.replace('{{{ SCRIPT_CODE }}}', decoding))
+''' % Compression.compressed_name(base_js_target)
+      html.write(shell.replace('{{{ SCRIPT }}}', '<script>' + decoding + '</script>'))
 
       # Add decompressor with web worker glue code
       decompressor = open('decompress.js', 'w')
diff --git a/src/shell.html b/src/shell.html
index ff5f6e3548a19..a33735d910b15 100644
--- a/src/shell.html
+++ b/src/shell.html
@@ -87,6 +87,6 @@
       };
       Module.setStatus('Downloading...');
     </script>
-    <script async type='text/javascript'>{{{ SCRIPT_CODE }}}</script>
+    {{{ SCRIPT }}}
   </body>
 </html>
diff --git a/tests/embind/shell.html b/tests/embind/shell.html
index c3655e037c691..f0ee10f84301b 100644
--- a/tests/embind/shell.html
+++ b/tests/embind/shell.html
@@ -85,6 +85,6 @@
       };
       Module.setStatus('Downloading...');
     </script>      
-    <script type='text/javascript'>{{{ SCRIPT_CODE }}}</script>
+    {{{ SCRIPT }}}
   </body>
 </html>
diff --git a/tests/hello_world_gles_shell.html b/tests/hello_world_gles_shell.html
index 2459d75549f2b..22ecee7bcf6ac 100644
--- a/tests/hello_world_gles_shell.html
+++ b/tests/hello_world_gles_shell.html
@@ -49,7 +49,7 @@
       Module.postRun = doTest;
 
     </script>
-    <script>{{{ SCRIPT_CODE }}}</script>
+    {{{ SCRIPT }}}
   </body>
 </html>
 
diff --git a/tests/sdl_canvas_size.html b/tests/sdl_canvas_size.html
index 5c70210b9bc13..50495049b0f28 100644
--- a/tests/sdl_canvas_size.html
+++ b/tests/sdl_canvas_size.html
@@ -88,6 +88,6 @@
       };
       Module.setStatus('Downloading...');
     </script>
-    <script async type='text/javascript'>{{{ SCRIPT_CODE }}}</script>
+    {{{ SCRIPT }}}
   </body>
 </html>

From 3263031d4d8abfd11c4173953d942509bc782b81 Mon Sep 17 00:00:00 2001
From: Antoine Lambert <antoine-e.lambert@thalesgroup.com>
Date: Thu, 24 Oct 2013 10:32:41 +0200
Subject: [PATCH 04/93] map depth and stencil buffers activation from GLUT to
 WebGL

---
 src/library_glut.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/library_glut.js b/src/library_glut.js
index 722ea85c066b0..fefe7bd31ff19 100644
--- a/src/library_glut.js
+++ b/src/library_glut.js
@@ -427,7 +427,9 @@ var LibraryGLUT = {
   glutCreateWindow__deps: ['$Browser'],
   glutCreateWindow: function(name) {
     var contextAttributes = {
-      antialias: ((GLUT.initDisplayMode & 0x0080 /*GLUT_MULTISAMPLE*/) != 0)
+      antialias: ((GLUT.initDisplayMode & 0x0080 /*GLUT_MULTISAMPLE*/) != 0),
+      depth: ((GLUT.initDisplayMode & 0x0010 /*GLUT_DEPTH*/) != 0),
+      stencil: ((GLUT.initDisplayMode & 0x0020 /*GLUT_STENCIL*/) != 0)
     };
     Module.ctx = Browser.createContext(Module['canvas'], true, true, contextAttributes);
     return Module.ctx ? 1 /* a new GLUT window ID for the created context */ : 0 /* failure */;

From 125779a983801e63e3d01658c18c73afbbf6945c Mon Sep 17 00:00:00 2001
From: Antoine Lambert <antoine-e.lambert@thalesgroup.com>
Date: Thu, 24 Oct 2013 10:32:56 +0200
Subject: [PATCH 05/93] map depth and stencil buffers activation from SDL to
 WebGL

---
 src/library_sdl.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/library_sdl.js b/src/library_sdl.js
index 857ab7d4b418d..e652dfc879284 100644
--- a/src/library_sdl.js
+++ b/src/library_sdl.js
@@ -254,9 +254,13 @@ var LibrarySDL = {
       }
 
       var webGLContextAttributes = {
-        antialias: ((SDL.glAttributes[13 /*SDL_GL_MULTISAMPLEBUFFERS*/] != 0) && (SDL.glAttributes[14 /*SDL_GL_MULTISAMPLESAMPLES*/] > 1))
+        antialias: ((SDL.glAttributes[13 /*SDL_GL_MULTISAMPLEBUFFERS*/] != 0) && (SDL.glAttributes[14 /*SDL_GL_MULTISAMPLESAMPLES*/] > 1)),
+        depth: (SDL.glAttributes[6 /*SDL_GL_DEPTH_SIZE*/] > 0),
+        stencil: (SDL.glAttributes[7 /*SDL_GL_STENCIL_SIZE*/] > 0)
       };
+      
       var ctx = Browser.createContext(canvas, useWebGL, usePageCanvas, webGLContextAttributes);
+            
       SDL.surfaces[surf] = {
         width: width,
         height: height,

From df2cff1542ecb09258724804b29b2013d9dc641b Mon Sep 17 00:00:00 2001
From: Antoine Lambert <antoine-e.lambert@thalesgroup.com>
Date: Thu, 24 Oct 2013 10:33:11 +0200
Subject: [PATCH 06/93] map depth and stencil buffers activation from GLFW to
 WebGL

---
 src/library_glfw.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/library_glfw.js b/src/library_glfw.js
index b0519e3986c7a..647d4bb622be1 100644
--- a/src/library_glfw.js
+++ b/src/library_glfw.js
@@ -355,7 +355,9 @@ var LibraryGLFW = {
     }
 
     var contextAttributes = {
-      antialias: (GLFW.params[0x00020013] > 1) //GLFW_FSAA_SAMPLES
+      antialias: (GLFW.params[0x00020013] > 1), //GLFW_FSAA_SAMPLES
+      depth: (GLFW.params[0x00020009] > 0), //GLFW_DEPTH_BITS
+      stencil: (GLFW.params[0x0002000A] > 0) //GLFW_STENCIL_BITS
     }
     Module.ctx = Browser.createContext(Module['canvas'], true, true, contextAttributes);
     return 1; //GL_TRUE

From 401a0f394bc901cf955958cb4a0848d03f960239 Mon Sep 17 00:00:00 2001
From: Antoine Lambert <antoine-e.lambert@thalesgroup.com>
Date: Thu, 24 Oct 2013 10:34:32 +0200
Subject: [PATCH 07/93] add tests for WebGL context attributes (antialiasing,
 depth, stencil) when they are enabled or disabled

---
 tests/test_browser.py                        |  48 ++++
 tests/test_webgl_context_attributes_common.c | 257 +++++++++++++++++++
 tests/test_webgl_context_attributes_glfw.c   |  47 ++++
 tests/test_webgl_context_attributes_glut.c   |  42 +++
 tests/test_webgl_context_attributes_sdl.c    |  50 ++++
 5 files changed, 444 insertions(+)
 create mode 100644 tests/test_webgl_context_attributes_common.c
 create mode 100644 tests/test_webgl_context_attributes_glfw.c
 create mode 100644 tests/test_webgl_context_attributes_glut.c
 create mode 100644 tests/test_webgl_context_attributes_sdl.c

diff --git a/tests/test_browser.py b/tests/test_browser.py
index 000dd95ab648e..28a6f1391bd97 100644
--- a/tests/test_browser.py
+++ b/tests/test_browser.py
@@ -869,6 +869,54 @@ def test_glut_touchevents(self):
   def test_glut_wheelevents(self):
     self.btest('glut_wheelevents.c', '1')
 
+  def test_webgl_context_attributes(self):
+    # Javascript code to check the attributes support we want to test in the WebGL implementation 
+    # (request the attribute, create a context and check its value afterwards in the context attributes).
+    # Tests will succeed when an attribute is not supported.
+    open(os.path.join(self.get_dir(), 'check_webgl_attributes_support.js'), 'w').write('''
+      mergeInto(LibraryManager.library, {
+        webglAntialiasSupported: function() {
+          canvas = document.createElement('canvas');
+          context = canvas.getContext('experimental-webgl', {antialias: true});
+          attributes = context.getContextAttributes();
+          return attributes.antialias;
+        }
+      });
+
+      mergeInto(LibraryManager.library, {
+        webglDepthSupported: function() {
+          canvas = document.createElement('canvas');
+          context = canvas.getContext('experimental-webgl', {depth: true});
+          attributes = context.getContextAttributes();
+          return attributes.depth;
+        }
+      });
+
+      mergeInto(LibraryManager.library, {
+        webglStencilSupported: function() {
+          canvas = document.createElement('canvas');
+          context = canvas.getContext('experimental-webgl', {stencil: true});
+          attributes = context.getContextAttributes();
+          return attributes.stencil;
+       }
+      });
+    ''')
+    
+    # Copy common code file to temporary directory
+    filepath = path_from_root('tests/test_webgl_context_attributes_common.c')
+    temp_filepath = os.path.join(self.get_dir(), os.path.basename(filepath))
+    shutil.copyfile(filepath, temp_filepath)
+    
+    # perform tests with attributes activated 
+    self.btest('test_webgl_context_attributes_glut.c', '1', args=['--js-library', 'check_webgl_attributes_support.js', '-DAA_ACTIVATED', '-DDEPTH_ACTIVATED', '-DSTENCIL_ACTIVATED'])
+    self.btest('test_webgl_context_attributes_sdl.c', '1', args=['--js-library', 'check_webgl_attributes_support.js', '-DAA_ACTIVATED', '-DDEPTH_ACTIVATED', '-DSTENCIL_ACTIVATED'])
+    self.btest('test_webgl_context_attributes_glfw.c', '1', args=['--js-library', 'check_webgl_attributes_support.js', '-DAA_ACTIVATED', '-DDEPTH_ACTIVATED', '-DSTENCIL_ACTIVATED'])
+    
+    # perform tests with attributes desactivated
+    self.btest('test_webgl_context_attributes_glut.c', '1', args=['--js-library', 'check_webgl_attributes_support.js'])
+    self.btest('test_webgl_context_attributes_sdl.c', '1', args=['--js-library', 'check_webgl_attributes_support.js'])
+    self.btest('test_webgl_context_attributes_glfw.c', '1', args=['--js-library', 'check_webgl_attributes_support.js'])
+    
   def test_emscripten_get_now(self):
     self.btest('emscripten_get_now.cpp', '1')
 
diff --git a/tests/test_webgl_context_attributes_common.c b/tests/test_webgl_context_attributes_common.c
new file mode 100644
index 0000000000000..80d569ce773a3
--- /dev/null
+++ b/tests/test_webgl_context_attributes_common.c
@@ -0,0 +1,257 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+
+#define BUFFER_OFFSET(i) ((char *)NULL + (i))
+
+static const int WINDOWS_SIZE = 500;
+
+static GLfloat vertices[] = { 0.0f,  250.f, 0.0f, 
+                             -250.f, -250.f, 0.0f,
+                              250.f, -250.f, 0.0f };
+
+static GLfloat vertices2[] = { 0.0f,  250.f, -1.0f, 
+                              -250.f, -250.f, -1.0f,
+                               250.f, -250.f, -1.0f };
+
+static GLuint shaderProgram = 0;		       
+static GLuint verticesVBO = 0;
+static GLuint verticesVBO2 = 0;
+
+static unsigned char backgroundColor[4] = {255, 255, 255, 255};
+static unsigned char triangleColor[4] = {255, 0, 0, 255};
+static unsigned char triangleColor2[4] = {0, 255, 0, 255};
+
+static char vertexShaderSrc[] =
+    "precision highp float;"
+    "precision highp int;"
+
+    "uniform mat4 u_mvpMatrix;"
+    "uniform vec4 u_color;"
+    
+    "attribute vec3 a_position;"
+    
+    "varying vec4 v_color;"
+
+    "void main() {"
+    "   gl_Position = u_mvpMatrix * vec4(a_position, 1.0);"
+    "   v_color = u_color;"
+    "}"
+    ;
+
+static char fragmentShaderSrc[] =
+    "precision highp float;"
+    "precision highp int;"
+
+    "varying vec4 v_color;"
+
+    "void main() {"
+    "  gl_FragColor = v_color;"
+    "}"
+    ;
+
+static GLuint createShader(const char *source, int type) {
+    GLuint shader = glCreateShader(type);
+    glShaderSource(shader, 1, (const GLchar**)(&source), NULL);
+    glCompileShader(shader);
+    return shader;
+}
+
+static GLuint createShaderProgram(const char *vertexShaderSrc, const char *fragmentShaderSrc) {
+    GLuint program = glCreateProgram();
+    glAttachShader(program, createShader(vertexShaderSrc, GL_VERTEX_SHADER));
+    glAttachShader(program, createShader(fragmentShaderSrc, GL_FRAGMENT_SHADER));
+    glLinkProgram(program);
+    return program;
+}
+
+void ortho(float  left,  float  right,  float  bottom,  float  top,  float  nearVal,  float  farVal, GLfloat *projMatrix) {
+    float tx = -(right+left)/(right-left);
+    float ty = -(top+bottom)/(top-bottom);
+    float tz = -(farVal+nearVal)/(farVal-nearVal);
+    memset(projMatrix, 0, 16 * sizeof(GLfloat));
+    projMatrix[0] = 2.0f / (right-left);
+    projMatrix[3] = tx;
+    projMatrix[1*4+1] = 2.0f / (top-bottom);
+    projMatrix[1*4+3] = ty;
+    projMatrix[2*4+2] = -2.0f / (farVal-nearVal);
+    projMatrix[2*4+3] = tz;
+    projMatrix[3*4+3] = 1.0f;
+}
+
+static void initGlObjects() {
+    glGenBuffers(1, &verticesVBO);
+    glBindBuffer(GL_ARRAY_BUFFER, verticesVBO);
+    glBufferData(GL_ARRAY_BUFFER, 9*sizeof(float), vertices, GL_STATIC_DRAW);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    
+    glGenBuffers(1, &verticesVBO2);
+    glBindBuffer(GL_ARRAY_BUFFER, verticesVBO2);
+    glBufferData(GL_ARRAY_BUFFER, 9*sizeof(float), vertices2, GL_STATIC_DRAW);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    
+    shaderProgram = createShaderProgram(vertexShaderSrc, fragmentShaderSrc);
+}
+
+static void drawTriangle(GLuint verticesVBO, unsigned char r, unsigned char g, unsigned char b, unsigned char a) {
+    glUseProgram(shaderProgram);
+    GLuint posLoc = glGetAttribLocation(shaderProgram, "a_position");
+    GLuint mvpLoc = glGetUniformLocation(shaderProgram, "u_mvpMatrix");
+    GLuint colorLoc = glGetUniformLocation(shaderProgram, "u_color");
+    
+    GLfloat mvpMat[16];
+    ortho(-WINDOWS_SIZE/2, WINDOWS_SIZE/2, -WINDOWS_SIZE/2, WINDOWS_SIZE/2, -100, 100, mvpMat);
+    
+    glUniformMatrix4fv(mvpLoc, 1, GL_FALSE, mvpMat);
+    glUniform4f(colorLoc, r/255.f, g/255.f, b/255.f, a/255.f);
+    
+    glBindBuffer(GL_ARRAY_BUFFER, verticesVBO);  
+    glEnableVertexAttribArray(posLoc);
+    glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), BUFFER_OFFSET(0));
+    
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+    
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glUseProgram(0);
+}
+
+// Draw a red triangle on a white background. If antialiasing is disabled, resulting pixels
+// will only have white and red colors. If antialiasing is enabled, there will be pixels
+// whose color is different from red and white.
+static int testAntiAliasing(bool activated) {
+    glViewport(0, 0, WINDOWS_SIZE, WINDOWS_SIZE);
+    glClearColor(backgroundColor[0]/255.f, backgroundColor[1]/255.f, backgroundColor[2]/255.f, backgroundColor[3]/255.f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    
+    drawTriangle(verticesVBO, triangleColor[0], triangleColor[1], triangleColor[2], triangleColor[3]);
+    
+    bool antialiased = false;
+    
+    unsigned char buffer[(WINDOWS_SIZE*WINDOWS_SIZE)*4];
+    glReadPixels(0, 0, WINDOWS_SIZE, WINDOWS_SIZE, GL_RGBA, GL_UNSIGNED_BYTE, &buffer[0]);
+    glFinish();
+    for (unsigned int i = 0 ; i < WINDOWS_SIZE ; ++i) {
+      for (unsigned int j = 0 ; j < WINDOWS_SIZE ; ++j) {
+        unsigned char r = buffer[4*(i*WINDOWS_SIZE+j)];
+        unsigned char g = buffer[4*(i*WINDOWS_SIZE+j)+1];
+        unsigned char b = buffer[4*(i*WINDOWS_SIZE+j)+2];
+        unsigned char a = buffer[4*(i*WINDOWS_SIZE+j)+3];
+        if ((r == backgroundColor[0] && g == backgroundColor[1] && b == backgroundColor[2] && a == backgroundColor[3]) || 
+            (r == triangleColor[0] && g == triangleColor[1] && b == triangleColor[2] && a == triangleColor[3])) {
+          continue;
+        } else {
+          antialiased = true;
+          break;
+        }
+      }
+    }
+    
+    return (activated && antialiased) || (!activated && !antialiased);
+}
+
+// Draw a red triangle with depth equals to 0 then a green triangle whose depth equals -1.
+// If there is an attached depth buffer, the resulting image will be a red triangle. If not,
+// the resulting image will be a green triangle.
+static int testDepth(bool activated) {
+    glViewport(0, 0, WINDOWS_SIZE, WINDOWS_SIZE);
+    glClearColor(backgroundColor[0]/255.f, backgroundColor[1]/255.f, backgroundColor[2]/255.f, backgroundColor[3]/255.f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    
+    glEnable(GL_DEPTH_TEST);
+    glDepthFunc(GL_LEQUAL);
+    
+    drawTriangle(verticesVBO, triangleColor[0], triangleColor[1], triangleColor[2], triangleColor[3]);
+    drawTriangle(verticesVBO2, triangleColor2[0], triangleColor2[1], triangleColor2[2], triangleColor2[3]);
+    
+    glDisable(GL_DEPTH_TEST);
+    
+    // read the pixel at the center of the resulting image.
+    unsigned char buffer[4];
+    glReadPixels(WINDOWS_SIZE/2, WINDOWS_SIZE/2, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &buffer[0]);
+    
+    bool frontTriangleColor = (buffer[0] == triangleColor[0] && buffer[1] == triangleColor[1] &&
+                               buffer[2] == triangleColor[2] && buffer[3] == triangleColor[3]);
+    
+    bool backTriangleColor = (buffer[0] == triangleColor2[0] && buffer[1] == triangleColor2[1] &&
+                              buffer[2] == triangleColor2[2] && buffer[3] == triangleColor2[3]);
+    
+    return (activated && frontTriangleColor) || (!activated && backTriangleColor);
+}
+
+// The stencil function is set to GL_LEQUAL so fragments will be written to the 
+// back buffer only if the ref value is less or equal than the one in the stencil buffer.
+// The content of the stencil buffer is initialized to 0xFF.
+// First draw a red triangle whose stencil ref value is 0x1.
+// Then draw a green triangle whose stencil ref value is 0xFF.
+// If there is an attached stencil buffer, the resulting image will be a red triangle. If not,
+// the resulting image will be a green triangle.
+static int testStencil(bool activated) {
+    glViewport(0, 0, WINDOWS_SIZE, WINDOWS_SIZE);
+    glClearColor(backgroundColor[0]/255.f, backgroundColor[1]/255.f, backgroundColor[2]/255.f, backgroundColor[3]/255.f);
+    glClearStencil(0xFF);
+    glStencilOp(GL_KEEP,GL_KEEP,GL_REPLACE);
+    glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+    
+    glEnable(GL_STENCIL_TEST);
+    
+    glStencilFunc(GL_LEQUAL, 0x1, 0xFF);
+    drawTriangle(verticesVBO, triangleColor[0], triangleColor[1], triangleColor[2], triangleColor[3]);
+    
+    glStencilFunc(GL_LEQUAL, 0xFF, 0xFF);
+    drawTriangle(verticesVBO, triangleColor2[0], triangleColor2[1], triangleColor2[2], triangleColor2[3]);
+    
+    glDisable(GL_STENCIL_TEST);
+    
+    unsigned char buffer[4];
+    glReadPixels(WINDOWS_SIZE/2, WINDOWS_SIZE/2, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &buffer[0]);
+    
+    bool firstTriangleColor = (buffer[0] == triangleColor[0] && buffer[1] == triangleColor[1] &&
+                               buffer[2] == triangleColor[2] && buffer[3] == triangleColor[3]);
+    
+    bool secondTriangleColor = (buffer[0] == triangleColor2[0] && buffer[1] == triangleColor2[1] &&
+                                buffer[2] == triangleColor2[2] && buffer[3] == triangleColor2[3]);
+    
+    return (activated && firstTriangleColor) || (!activated && secondTriangleColor);
+}
+
+static bool antiAliasingActivated = false;
+static bool depthActivated = false;
+static bool stencilActivated = false;
+
+static int result = 0;
+static int resultAA = 0;
+static int resultDepth = 0;
+static int resultStencil = 0;
+
+static void draw() {
+  
+  if (!resultAA) resultAA = testAntiAliasing(antiAliasingActivated);
+   
+  if (!resultDepth) resultDepth = testDepth(depthActivated);
+  
+  if (!resultStencil) resultStencil = testStencil(stencilActivated);
+  
+  result = resultAA && resultDepth && resultStencil;
+ 
+}
+
+extern int webglAntialiasSupported();
+extern int webglDepthSupported();
+extern int webglStencilSupported();
+
+// Check attributes support in the WebGL implementation (see test_webgl_context_attributes function in test_browser.py)
+// Tests will succeed if they are not.
+static void checkContextAttributesSupport() {
+  if (!webglAntialiasSupported()) {
+    resultAA = 1;
+  } 
+  if (!webglDepthSupported()) {
+    resultDepth = 1;
+  } 
+  if (!webglStencilSupported()) {
+    resultStencil = 1;
+  }
+}
+
+
diff --git a/tests/test_webgl_context_attributes_glfw.c b/tests/test_webgl_context_attributes_glfw.c
new file mode 100644
index 0000000000000..694236d0da165
--- /dev/null
+++ b/tests/test_webgl_context_attributes_glfw.c
@@ -0,0 +1,47 @@
+#include <GL/glew.h>
+#include <GL/glfw.h>
+#include <emscripten.h>
+
+#include "test_webgl_context_attributes_common.c"
+
+int nbSamples = 0;
+int nbDepthBits = 0;
+int nbStencilBits = 0;
+
+int main() {
+  
+    checkContextAttributesSupport();
+  
+    glfwInit();
+  
+#ifdef AA_ACTIVATED
+    antiAliasingActivated = true;
+    nbSamples = 4;
+#endif
+  
+#ifdef DEPTH_ACTIVATED
+    depthActivated = true;
+    nbDepthBits = 16;
+#endif  
+  
+#ifdef STENCIL_ACTIVATED
+    stencilActivated = true;  
+    nbStencilBits = 8;
+#endif
+
+    glfwOpenWindowHint(GLFW_FSAA_SAMPLES, nbSamples);
+    glfwOpenWindow(WINDOWS_SIZE, WINDOWS_SIZE, 8, 8, 8, 8, nbDepthBits, nbStencilBits, GLFW_WINDOW);
+  
+    glewInit();
+    initGlObjects();
+
+    draw();
+  
+    glfwTerminate();
+  
+    REPORT_RESULT();
+  
+    return 0;
+
+}
+ 
\ No newline at end of file
diff --git a/tests/test_webgl_context_attributes_glut.c b/tests/test_webgl_context_attributes_glut.c
new file mode 100644
index 0000000000000..3255fc9aea77a
--- /dev/null
+++ b/tests/test_webgl_context_attributes_glut.c
@@ -0,0 +1,42 @@
+#include <GL/glew.h>
+#include <GL/glut.h>
+#include <emscripten.h>
+
+#include "test_webgl_context_attributes_common.c"
+
+int main(int argc, char *argv[]) {
+    
+    checkContextAttributesSupport(); 
+    
+    unsigned int glutDisplayMode = GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA;
+        
+#ifdef AA_ACTIVATED
+    antiAliasingActivated = true;
+    glutDisplayMode |= GLUT_MULTISAMPLE;
+#endif
+    
+#ifdef DEPTH_ACTIVATED
+    depthActivated = true;
+    glutDisplayMode |= GLUT_DEPTH;
+#endif
+    
+#ifdef STENCIL_ACTIVATED
+    stencilActivated = true;
+    glutDisplayMode |= GLUT_STENCIL;
+#endif
+    
+    glutInit(&argc, argv);
+    glutInitWindowSize(WINDOWS_SIZE, WINDOWS_SIZE);
+    glutInitDisplayMode(glutDisplayMode);
+    glutCreateWindow("WebGL");
+    glutDisplayFunc(draw);  
+     
+    glewInit();
+    initGlObjects();
+    
+    draw();
+    
+    REPORT_RESULT();
+    
+    return 0;
+}
diff --git a/tests/test_webgl_context_attributes_sdl.c b/tests/test_webgl_context_attributes_sdl.c
new file mode 100644
index 0000000000000..23ad4378677cd
--- /dev/null
+++ b/tests/test_webgl_context_attributes_sdl.c
@@ -0,0 +1,50 @@
+#include <GL/glew.h>
+#define NO_SDL_GLEXT
+#include <SDL/SDL.h>
+#include <SDL/SDL_opengl.h>
+#include <emscripten.h>
+
+#include "test_webgl_context_attributes_common.c"
+
+int main(int argc, char *argv[]) {
+    
+    checkContextAttributesSupport(); 
+    
+    SDL_Init(SDL_INIT_VIDEO);
+
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+#ifdef AA_ACTIVATED
+    antiAliasingActivated = true;
+    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
+    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
+#else
+    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
+    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
+#endif
+    
+#ifdef DEPTH_ACTIVATED
+    depthActivated = true;
+    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
+#else
+    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
+#endif
+    
+#ifdef STENCIL_ACTIVATED
+    stencilActivated = true;
+    SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
+#else
+    SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
+#endif
+    
+    SDL_Surface *screen = SDL_SetVideoMode(WINDOWS_SIZE, WINDOWS_SIZE, 32, SDL_OPENGL);
+       
+    glewInit();
+    initGlObjects();
+    
+    draw();
+        
+    REPORT_RESULT();
+    
+    return 0;
+}

From 067a60d649a5f8a1af76d4a15dee31c81fe0f384 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Thu, 24 Oct 2013 12:11:44 -0700
Subject: [PATCH 08/93] handle empty inline asms; fixes #1729

---
 src/intertyper.js            | 14 ++++++++------
 tests/cases/emptyasm_le32.ll | 16 ++++++++++++++++
 tests/test_core.py           |  3 +++
 3 files changed, 27 insertions(+), 6 deletions(-)
 create mode 100644 tests/cases/emptyasm_le32.ll

diff --git a/src/intertyper.js b/src/intertyper.js
index 96db696683cea..d36408892ce9f 100644
--- a/src/intertyper.js
+++ b/src/intertyper.js
@@ -672,12 +672,14 @@ function intertyper(lines, sidePass, baseLineNums) {
       assert((item.tokens[5].text.match(/=/g) || []).length <= 1, 'we only support at most 1 exported variable from inline js: ' + item.ident);
       var i = 0;
       var params = [], args = [];
-      splitTokenList(tokensLeft[3].tokens).map(function(element) {
-        var ident = toNiceIdent(element[1].text);
-        var type = element[0].text;
-        params.push('$' + (i++));
-        args.push(ident);
-      });
+      if (tokensLeft[3].tokens) {
+        splitTokenList(tokensLeft[3].tokens).map(function(element) {
+          var ident = toNiceIdent(element[1].text);
+          var type = element[0].text;
+          params.push('$' + (i++));
+          args.push(ident);
+        });
+      }
       if (item.assignTo) item.ident = 'return ' + item.ident;
       item.ident = '(function(' + params + ') { ' + item.ident + ' })(' + args + ');';
       return { forward: null, ret: item, item: item };
diff --git a/tests/cases/emptyasm_le32.ll b/tests/cases/emptyasm_le32.ll
new file mode 100644
index 0000000000000..e123d3d52ef3b
--- /dev/null
+++ b/tests/cases/emptyasm_le32.ll
@@ -0,0 +1,16 @@
+; ModuleID = 'tests/hello_world.bc'
+
+@.str = private unnamed_addr constant [15 x i8] c"hello, world!\0A\00", align 1 ; [#uses=1 type=[15 x i8]*]
+
+; [#uses=0]
+define i32 @main() {
+entry:
+  %retval = alloca i32, align 4                   ; [#uses=1 type=i32*]
+  store i32 0, i32* %retval
+  call void asm sideeffect "", "~{memory}"() nounwind, !srcloc !0
+  %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([15 x i8]* @.str, i32 0, i32 0)) ; [#uses=0 type=i32]
+  ret i32 1
+}
+
+; [#uses=1]
+declare i32 @printf(i8*, ...)
diff --git a/tests/test_core.py b/tests/test_core.py
index 69fb31f37235d..dd5b1e39ad380 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -9044,6 +9044,9 @@ def test_cases(self):
         if '_noasm' in shortname and Settings.ASM_JS:
           print self.skip('case "%s" not relevant for asm.js' % shortname)
           continue
+        if '_le32' in shortname and not self.is_le32():
+          print self.skip('case "%s" not relevant for non-le32 target' % shortname)
+          continue
         self.emcc_args = emcc_args
         if os.path.exists(shortname + '.emcc'):
           if not self.emcc_args: continue

From aaceb254c33adec3903425ff31ba80882f793bb5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Fri, 25 Oct 2013 12:02:21 +0300
Subject: [PATCH 09/93] Added a ChangeLog.

---
 ChangeLog | 373 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 373 insertions(+)
 create mode 100644 ChangeLog

diff --git a/ChangeLog b/ChangeLog
new file mode 100644
index 0000000000000..cca1b83311894
--- /dev/null
+++ b/ChangeLog
@@ -0,0 +1,373 @@
+This document describes changes between tagged Emscripten SDK versions.
+
+Note that in the compiler, version numbering is used as the mechanism to invalidate internal compiler caches,
+so version numbers do not necessarily reflect the amount of changes between versions.
+
+To browse or download snapshots of old tagged versions, visit https://github.com/kripken/emscripten/releases .
+
+Not all changes are documented here. In particular, new features, user-oriented fixes, options, command-line parameters, usage changes, deprecations, significant internal modifications and optimizations etc. generally deserve a mention. To examine the full set of changes between versions, visit the link to full changeset diff at the end of each section.
+
+v1.7.1: 10/24/2013
+------------------
+ - Remove old call to Runtime.warn in file packager code
+ - Fix bug with parsing of empty types.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.7.0...1.7.1
+
+v1.7.0: 10/23/2013
+------------------
+ - Adds mouse wheel events support in GLUT library.
+ - Adds support for a new link parameter -s CASE_INSENSITIVE_VFS=1 to enable Emscripten virtual filesystem to search files ignoring case.
+ - *Numerous* optimizations in both compilation and runtime stages.
+ - Remove unnecessary whitespace, compact postSets function, and other optimizations in compilation output to save on generated file size.
+ - Fixes float parsing from negative zero.
+ - Removes the -s EMIT_GENERATED_FUNCTIONS link parameter as unneeded.
+ - Fixes an issue where updating subranges of GL uniform arrays was not possible.
+ - asm.js heap size (-s TOTAL_MEMORY=x) no longer needs to be a power of 2. As a relaxed rule, choosing any multiple of 16MB is now possible.
+ - O1 optimization no longer runs the 'simplifyExpressions' optimization pass. This is to improve build iteration times when using -O1. Use -O2 to run that pass.
+ - EM_ASM() can now be used even when compiling to asm.js.
+ - All currently specified non-debugging-related WebGL 1 extensions are now enabled by default on startup, no need to ctx.getExtension() manually to enable them.
+ - Improve readability of uncaught JavaScript exceptions that are thrown all the way up to the web console by printing out the stack trace of where the throw occurred.
+ - Fix an issue when renaming a directory to a subdirectory.
+ - Several compiler stability fixes.
+ - Adds a JavaScript implementation of cxa_demangle function for demangling call stack traces at runtime for easier debugging.
+ - GL context MSAA antialising is now DISABLED by default, to make the GL behavior consistent with desktop usage.
+ - Added support to SDL, GLUT and GLFW libraries to specify MSAA on/off at startup.
+ - Implemented glColor4ubv in GL emulation mode.
+ - Fix an issue with LLVM keyword __attribute__ ((__constructor__)) (#1155).
+ - Fix an issue with va_args and -s UNALIGNED_MEMORY=1 (#1705).
+ - Add initial support code for LLVM SIMD constructs and a JavaScript SIMD polyfill implementation from https://github.com/johnmccutchan/ecmascript_simd/ .
+ - Fixed support for node.js native filesystem API NODEFS on Windows.
+ - Optimize application startup times of Emscripten-compiled programs by enabling the virtual filesystem XHR and asm.js compilation to proceed in parallel when opening a page.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.6.4...1.7.0
+
+v1.6.4: 9/30/2013
+------------------
+ - Implements a new preprocessor tool for preparsing C struct definitions (#1554), useful for Emscripten support library implementors.
+ - Fix parsing issue with sscanf (#1668).
+ - Improved the responsiveness of compiler print output on Windows.
+ - Improved compilation times at link stage.
+ - Added support for new "NODEFS" filesystem that directly accesses files on the native filesystem. Only usable with node.js when compiling to JS.
+ - Added support for new IDBFS filesystem for accessing files in IndexedDB storage (#1601.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.6.3...1.6.4
+
+v1.6.3: 9/26/2013
+------------------
+ - Emscripten CMake toolchain now generates archive files with .a suffix when project target type is static library, instead of generatic .bc files (#1648).
+ - Adds iconv library from the musl project to implement wide functions in C library (#1670).
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.6.2...1.6.3
+
+v1.6.2: 9/25/2013
+------------------
+ - Added support for dprintf() function (#1250).
+ - Fixes several compiler stability issues (#1637, #1166, #1661, #1651 and more).
+ - Enables support for WEBGL_depth_texture.
+ - Adds support for new link flag -s GL_ASSERTIONS=1 which can be used to add extra validation layer to the Emscripten GL library to catch code issues.
+ - Adds support to Web Audio API in SDL audio backend so that SDL audio now works in Chrome and new Opera as well.
+ - Fixes an alpha blending issue with SDL_SetAlpha.
+ - Implemented locale-related code in C library.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.6.1...1.6.2
+
+v1.6.1: 9/22/2013
+------------------
+ - Several optimizations to compiler link stage.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.6.0...1.6.1
+
+v1.6.0: 9/21/2013
+------------------
+ - Enable support for %[] pattern in scanf.
+ - Added dependency tracking support to linked .js files in CMake toolchain.
+ - The hex prefix 0x is now properly handled in sscanf (#1632).
+ - Simplify internal compiler operations by removing the internal framework.js. 
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.5.9...1.6.0
+
+v1.5.9: 9/15/2013
+------------------
+ - Add support for SDL_Delay in web workers.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.5.8...1.5.9
+
+v1.5.8: 9/14/2013
+------------------
+ - Add support for the GCC -E compiler flag.
+ - Update Emscripten libc headers to musl-0.9.13.
+ - Added new utility function emscripten_async_load_script() to asynchronously load a new .js script URL.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.5.7...1.5.8
+
+v1.5.7: 8/30/2013
+------------------
+ - The script tag in default shell.html is now marked 'async', which enables loading the JS script code asynchronously in Firefox without making the main thread unresponsive.
+ - Implemented new utility function emscripten_get_canvas_size() which returns the current Module <canvas> element size in pixels.
+ - Optimize code size in compiled side modules.
+ - Optimize startup memory usage by avoiding unnecessary copying of VFS data at startup.
+ - Add support for SDL_WM_ToggleFullScreen().
+ - Add support for emscripten_get_now() when running in SpiderMonkey shell.
+ - Added new environment variable EM_BUILD_VERBOSE=0,1,2,3 to set an extra compiler output verbosity level for debugging.
+ - Added better support for dlopen() to simulate dynamic library loading in JavaScript.
+ - Improved support for BSD sockets and networking.
+ - Added new SOCKFS filesystem, which reads files via a network connection.
+ - Avoid issues with long command line limitations in CMake toolchain by using response files.
+ - Fix issues with client-side vertex data rendering in GL emulation mode.
+ - Improved precision of clock_gettime().
+ - Improve function outlining support.
+ - Added support for using NMake generator with CMake toolchain.
+ - Improved support for flexible arrays in structs (#1602).
+ - Added ability to marshal UTF16 and UTF32 strings between C++ <-> JS code.
+ - Added a new commandline tool validate_asms.py to help automating asm.js validation testing.
+ - Improved stability with inline asm() syntax.
+ - Updated libc headers to new version.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.5.6...1.5.7
+
+v1.5.6: 8/17/2013
+------------------
+ - Improved BSD sockets support.
+ - Added touch events support to GLUT library.
+ - Added new --js-opts=0/1 command line option to control whether JS optimizer is run or not.
+ - Improved OpenAL support.
+ - Added new command line tool tools/find_bigvars.py which can be used on a output file to detect large functions and needs for outlining.
+ - Merged link flags -s FORCE_GL_EMULATION and -s DISABLE_GL_EMULATION to a single opt-in flag -s LEGACY_GL_EMULATION=0/1 to control whether GL emulation is active.
+ - Improved SDL input support.
+ - Several stability-related compiler fixes.
+ - Fixed source mapping generation support on Windows.
+ - Added back the EMSCRIPTEN_KEEPALIVE attribute qualifier to help prevent inlining and to retain symbols in output without dead code elimination occurring.
+ - Fix issues when marshalling UTF8 strings between C<->JS.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.5.5...1.5.6
+
+v1.5.5: 8/9/2013
+------------------
+ - Update libcxx to revision 187959, 2013-08-08.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.5.4...1.5.5
+
+v1.5.4: 8/9/2013
+------------------
+ - Fixed multiple issues with C stdlib support.
+ - Fix audio buffer queueing issues with OpenAL.
+ - Improved BSD sockets support.
+ - Added a new compile+link time command line option -Wno-warn-absolute-paths to hide the emscripten compiler warning when absolute paths are passed into the compiler.
+ - Added new link flag -s STB_IMAGE=0/1 and integrate it to SDL image loading to enable synchronous image loading support with SDL.
+ - Several improvements on function outlining support.
+ - Fix issues with GLES2 interop support.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.5.3...1.5.4
+
+v1.5.3: 6/28/2013
+------------------
+ - Added new optimization level --llvm-lto 3 to run even more aggressive LTO optimizations.
+ - Improve optimizations for libc and other libraries.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.5.2...1.5.3
+
+v1.5.2: 6/27/2013
+------------------
+ - Added support for generating source maps along the built application when -g is specified. This lets the browser show original .cpp sources when debugging.
+ - GLUT and SDL improvements.
+ - Added new link option -g<level> where level=0-4, which allows controlling various levels of debuggability added to the output.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.5.1...1.5.2
+
+v1.5.1: 6/22/2013
+------------------
+ - File packager now skips all directories and files starting with '.', and hidden files on Windows.
+ - Fix issues with strnlen, memmove, LDBL_ constants, va_args, float.h, and others.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.5.0...1.5.1
+
+v1.5.0: 6/17/2013
+------------------
+ - Several compiler optimizations.
+ - Improve SDL key events support.
+ - Increase debug logging when specifying emcc -v.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.4.9...1.5.0
+
+v1.4.9: 6/8/2013
+------------------
+ - Several compiler optimizations.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.4.8...1.4.9
+
+v1.4.8: 6/6/2013
+------------------
+ - Add support for webrtc-based sockets.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.4.7...1.4.8
+
+v1.4.7: 6/2/2013
+------------------
+ - Remove more unneeded break and continue statements in relooper.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.4.6...1.4.7
+
+v1.4.6: 6/2/2013
+------------------
+ - Improve relooper code.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.4.5...1.4.6
+
+v1.4.5: 6/1/2013
+------------------
+ - Improve relooper code.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.4.4...1.4.5
+
+v1.4.4: 6/1/2013
+------------------
+ - Add support for symlinks in source files.
+ - Fix various issues with SDL.
+ - Added -s FORCE_ALIGNED_MEMORY=0/1 link time flag to control whether all loads and stores are assumed to be aligned.
+ - Fix file packager to work with closure.
+ - Major improvements to embind support, and optimizations.
+ - Improve GL emulation.
+ - Optimize VFS usage.
+ - Allow emscripten to compile .m and .mm files.
+ - Added new syntax --preload-file src@dst to file packager command line to allow placing source files to custom destinations in the FS.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.4.3...1.4.4
+
+v1.4.3: 5/8/2013
+------------------
+ - Fix issue with strcat.
+ - Major embind improvements.
+ - Switch to le32-unknown-nacl LLVM target triple as default build option instead of the old i386-pc-linux-gnu target triple.
+ - Improve compiler logging behavior.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.4.2...1.4.3
+
+v1.4.2: 5/3/2013
+------------------
+ - Fix issues with le32-unknown-nacl LLVM target triple.
+ - Add some GLEW support.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.4.1...1.4.2
+
+v1.4.1: 4/28/2013
+------------------
+ - Implement support for le32-unknown-nacl LLVM target triple.
+ - Added new cmdline option -s ERROR_ON_UNDEFINED_SYMBOLS=0/1 to give compile-time error on undefined symbols at link time. Default off.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.3.8...1.4.1
+
+v1.3.8: 4/29/2013
+------------------
+ - Improved 64-bit integer ops codegen.
+ - Added Indexed DB support to vfs.
+ - Improve warning message on dangerous function pointer casts when compiling in asm.js mode.
+ - Added --use-preload-cache command line option to emcc, to be used with the file packager.
+ - Fixes to libcextra.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.3.7...1.3.8
+
+v1.3.7: 4/24/2013
+------------------
+ - Merge IMVU implementation of embind to emscripten trunk. Embind allows high-level C++ <-> JS types interop.
+ - Enable asm.js compilation in -O1 and higher by default. Fix issues when compiling to asm.js.
+ - Improve libc support with Emscripten with the musl libc headers.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.3.6...1.3.7
+
+v1.3.6: 4/2/2013
+------------------
+ - Fix hang issue with strtof.
+ - Update libcxx to upstream r178253 from March 29, 2013.
+ - Fix issues with GL emulation.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.3.5...1.3.6
+
+v1.3.5: 3/25/2013
+------------------
+ - Get exceptions working as they did before.
+ - Remove symbol removing hack.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.3.4...1.3.5
+
+v1.3.4: 3/24/2013
+------------------
+ - Update to new libcxx and libcxxabi versions from upstream.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.3.3...1.3.4
+
+v1.3.3: 3/23/2013
+------------------
+ - Remove unneeded check from relooper.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.3.2...1.3.3
+
+v1.3.2: 3/22/2013
+------------------
+ - Fix issues with fgets. 
+ - Add support for non-fullscreen pointer lock.
+ - Improve OpenAL support.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.3.1...1.3.2
+
+v1.3.1: 3/19/2013
+------------------
+ - Improve SDL audio and mixer support.
+ - Add GLES2 emulation features when -s FULL_ES2=1 is specified.
+ - Add support for OpenAL.
+ - Add new -s OPENAL_DEBUG=0/1 link command line option.
+ - Fixed an issue with mouse coordinate being offset with canvas.
+ - Removed -s UTF_STRING_SUPPORT=0 parameter, this is now always on.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.3.0...1.3.1
+
+v1.3.0: 3/11/2013
+------------------
+ - Improve GLES2 emulation with -s FULL_ES2=1.
+ - Deprecated -s USE_TYPED_ARRAYS=1 and -s QUANTUM_SIZE=1.
+ - Implement a minifier infrastructure when compiling for asm.js.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.2.9...1.3.0
+
+v1.2.9: 3/7/2013
+------------------
+ - Improved canvas behavior when transitioning between fullscreen.
+ - Added support for getopt().
+ - Fixed several libc issues.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.2.8...1.2.9
+
+v1.2.8: 3/6/2013
+------------------
+ - Remove unnecessary recursion in relooper RemoveUnneededFlows.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.2.7...1.2.8
+
+v1.2.7: 3/6/2013
+------------------
+ - Added SDL_Mixer support.
+ - Implemented stubs for several Unix and threading-related functions.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.2.6...1.2.7
+
+v1.2.6: 3/5/2013
+------------------
+ - Relooper updates.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.2.5...1.2.6
+
+v1.2.5: 3/5/2013
+------------------
+ - Greatly improve GL emulation support.
+ - Handle %c in sscanf.
+ - Improve compilation times by optimizing parallel execution in the linker.
+ - Improve several compiler stability issues detected from fuzzing tests.
+ - Implemented emscripten_jcache_printf.
+ - Allow running emscripten.py outside emcc itself.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.2.4...1.2.5
+
+v1.2.4: 2/2/2013
+------------------
+ - Work on adding support for asm.js compilation.
+ - Improve EGL support.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.2.3...1.2.4
+
+v1.2.3: 1/9/2013
+------------------
+ - Work on adding support for asm.js compilation.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.2.2...1.2.3
+
+v1.2.2: 1/8/2013
+------------------
+ - Work on adding support for asm.js compilation.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.2.1...1.2.2
+
+v1.2.1: 1/8/2013
+------------------
+ - Improvements to GLUT, SDL and BSD sockets headers.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.2.0...1.2.1
+
+v1.2.0: 1/1/2013
+------------------
+ - Work on adding support for asm.js compilation.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.1.0...1.2.0
+
+v1.1.0: 12/12/2012
+------------------
+ - Fix several issues with Windows support.
+ - Added a standalone toolchain for CMake.
+ - Added emscripten_run_script_string().
+ - Optimize compilation times via threading.
+ - Update to requiring Clang 3.2. Older versions may no longer work.
+ - Several improvements to emscripten library support headers.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.0.1a...1.1.0
+
+v1.0.1a: 11/11/2012
+------------------
+ - Add relooper code to repository.
+ - Full list of changes: https://github.com/kripken/emscripten/compare/1.0.1...1.0.1a
+
+v1.0.1: 11/11/2012
+------------------
+ - First commit that introduced versioning to the Emscripten compiler.

From 39cb6c0776360c72f3b34e5f8145919e7d794b04 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Fri, 25 Oct 2013 21:03:29 +0300
Subject: [PATCH 10/93] Fix test browser.test_sdl_canvas_size on Linux and OSX.

---
 tests/test_browser.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_browser.py b/tests/test_browser.py
index 000dd95ab648e..be23074ae3d7f 100644
--- a/tests/test_browser.py
+++ b/tests/test_browser.py
@@ -944,7 +944,7 @@ def test_sdl_audio_beeps(self):
 
   def test_sdl_canvas_size(self):
     self.btest('sdl_canvas_size.c', reference='screenshot-gray-purple.png', reference_slack=1,
-      args=['-O2', '--minify', '0', '--shell-file', path_from_root('tests', 'sdl_canvas_size.html'), '--preload-file', os.path.join(self.get_dir(), 'screenshot.png') + '@/', '-s', 'LEGACY_GL_EMULATION=1'],
+      args=['-O2', '--minify', '0', '--shell-file', path_from_root('tests', 'sdl_canvas_size.html'), '--preload-file', path_from_root('tests', 'screenshot.png') + '@/', '-s', 'LEGACY_GL_EMULATION=1'],
       message='You should see an image with gray at the top.')
 
   def test_sdl_gl_read(self):

From 52b97cb9116301bb42f16edc865f807ee920e0ba Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Fri, 25 Oct 2013 11:09:30 -0700
Subject: [PATCH 11/93] handle internal illegal iX fields in
 calculateStructAlignment

---
 src/runtime.js        | 11 +++++++++--
 tests/cases/2xi40.ll  | 40 ++++++++++++++++++++++++++++++++++++++++
 tests/cases/2xi40.txt |  1 +
 3 files changed, 50 insertions(+), 2 deletions(-)
 create mode 100644 tests/cases/2xi40.ll
 create mode 100644 tests/cases/2xi40.txt

diff --git a/src/runtime.js b/src/runtime.js
index fa127fe78b5d8..5d5cb43b47783 100644
--- a/src/runtime.js
+++ b/src/runtime.js
@@ -224,9 +224,16 @@ var Runtime = {
         // bN, large number field, like a [N x i8]
         size = field.substr(1)|0;
         alignSize = 1;
-      } else {
-        assert(field[0] === '<', field); // assumed to be a vector type, if none of the above
+      } else if (field[0] === '<') {
+        // vector type
         size = alignSize = Types.types[field].flatSize; // fully aligned
+      } else if (field[0] === 'i') {
+        // illegal integer field, that could not be legalized because it is an internal structure field
+        // it is ok to have such fields, if we just use them as markers of field size and nothing more complex
+        size = alignSize = parseInt(field.substr(1))/8;
+        assert(size % 1 === 0, 'cannot handle non-byte-size field ' + field);
+      } else {
+        assert(false, 'invalid type for calculateStructAlignment');
       }
       if (type.packed) alignSize = 1;
       type.alignSize = Math.max(type.alignSize, alignSize);
diff --git a/tests/cases/2xi40.ll b/tests/cases/2xi40.ll
new file mode 100644
index 0000000000000..a2c04d22a45c6
--- /dev/null
+++ b/tests/cases/2xi40.ll
@@ -0,0 +1,40 @@
+; ModuleID = '/tmp/tmpe4Pk1F/a.out.bc'
+target datalayout = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-p:32:32:32-v128:32:32"
+target triple = "le32-unknown-nacl"
+
+%struct.pair = type { [5 x i8], [5 x i8] }
+
+@.str = private unnamed_addr constant [6 x i8] c"|%d|\0A\00", align 1
+@.str1 = private unnamed_addr constant [7 x i8] c"%s,%s\0A\00", align 1
+
+define i32 @main() {
+  %1 = alloca i32, align 4
+  %pp = alloca [2 x i40], align 8
+  %p = bitcast [2 x i40]* %pp to %struct.pair*
+  store i32 0, i32* %1
+  %2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([6 x i8]* @.str, i32 0, i32 0), i32 10)
+  %3 = bitcast %struct.pair* %p to i8*
+  call void @llvm.memset.p0i8.i32(i8* %3, i8 120, i32 10, i32 1, i1 false)
+  %4 = getelementptr inbounds %struct.pair* %p, i32 0, i32 0
+  %5 = getelementptr inbounds [5 x i8]* %4, i32 0, i32 2
+  store i8 97, i8* %5, align 1
+  %6 = getelementptr inbounds %struct.pair* %p, i32 0, i32 0
+  %7 = getelementptr inbounds [5 x i8]* %6, i32 0, i32 4
+  store i8 0, i8* %7, align 1
+  %8 = getelementptr inbounds %struct.pair* %p, i32 0, i32 1
+  %9 = getelementptr inbounds [5 x i8]* %8, i32 0, i32 3
+  store i8 98, i8* %9, align 1
+  %10 = getelementptr inbounds %struct.pair* %p, i32 0, i32 1
+  %11 = getelementptr inbounds [5 x i8]* %10, i32 0, i32 4
+  store i8 0, i8* %11, align 1
+  %12 = getelementptr inbounds %struct.pair* %p, i32 0, i32 0
+  %13 = getelementptr inbounds [5 x i8]* %12, i32 0, i32 0
+  %14 = getelementptr inbounds %struct.pair* %p, i32 0, i32 1
+  %15 = getelementptr inbounds [5 x i8]* %14, i32 0, i32 0
+  %16 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([7 x i8]* @.str1, i32 0, i32 0), i8* %13, i8* %15)
+  ret i32 0
+}
+
+declare i32 @printf(i8*, ...)
+
+declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) nounwind
diff --git a/tests/cases/2xi40.txt b/tests/cases/2xi40.txt
new file mode 100644
index 0000000000000..59a1104e328d5
--- /dev/null
+++ b/tests/cases/2xi40.txt
@@ -0,0 +1 @@
+xxax,xxxb

From 84f9bc30e322b878011e866989dfe68619643e16 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Fri, 25 Oct 2013 11:20:42 -0700
Subject: [PATCH 12/93] improve [2 x i40] testcase

---
 tests/cases/2xi40.ll | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/tests/cases/2xi40.ll b/tests/cases/2xi40.ll
index a2c04d22a45c6..592f1ba49fa6b 100644
--- a/tests/cases/2xi40.ll
+++ b/tests/cases/2xi40.ll
@@ -15,8 +15,9 @@ define i32 @main() {
   %2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([6 x i8]* @.str, i32 0, i32 0), i32 10)
   %3 = bitcast %struct.pair* %p to i8*
   call void @llvm.memset.p0i8.i32(i8* %3, i8 120, i32 10, i32 1, i1 false)
-  %4 = getelementptr inbounds %struct.pair* %p, i32 0, i32 0
-  %5 = getelementptr inbounds [5 x i8]* %4, i32 0, i32 2
+  %4 = getelementptr inbounds [2 x i40]* %pp, i32 0, i32 0
+  %b4 = bitcast i40* %4 to [5 x i8]*
+  %5 = getelementptr inbounds [5 x i8]* %b4, i32 0, i32 2
   store i8 97, i8* %5, align 1
   %6 = getelementptr inbounds %struct.pair* %p, i32 0, i32 0
   %7 = getelementptr inbounds [5 x i8]* %6, i32 0, i32 4
@@ -24,8 +25,9 @@ define i32 @main() {
   %8 = getelementptr inbounds %struct.pair* %p, i32 0, i32 1
   %9 = getelementptr inbounds [5 x i8]* %8, i32 0, i32 3
   store i8 98, i8* %9, align 1
-  %10 = getelementptr inbounds %struct.pair* %p, i32 0, i32 1
-  %11 = getelementptr inbounds [5 x i8]* %10, i32 0, i32 4
+  %10 = getelementptr inbounds [2 x i40]* %pp, i32 0, i32 1
+  %b10 = bitcast i40* %10 to [5 x i8]*
+  %11 = getelementptr inbounds [5 x i8]* %b10, i32 0, i32 4
   store i8 0, i8* %11, align 1
   %12 = getelementptr inbounds %struct.pair* %p, i32 0, i32 0
   %13 = getelementptr inbounds [5 x i8]* %12, i32 0, i32 0

From 2403c746bb3387c0716893e01970a25aad68d20d Mon Sep 17 00:00:00 2001
From: icetooth <icetooth333@gmail.com>
Date: Sat, 26 Oct 2013 10:17:38 -0400
Subject: [PATCH 13/93] fixed float read performance in _scanString

---
 src/library.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/library.js b/src/library.js
index 875d8bab1abd0..2b183ea179ff8 100644
--- a/src/library.js
+++ b/src/library.js
@@ -1745,7 +1745,7 @@ LibraryManager.library = {
             type == 'F' || type == 'E' || type == 'G') {
           var last = 0;
           next = get();
-          while (next > 0) {
+          while ( next > 0 && (!(next in __scanString.whiteSpace)) )  {
             buffer.push(String.fromCharCode(next));
             if (__isFloat(buffer.join(''))) {
               last = buffer.length;

From 14c6628d28648cd069a9e0e519cc69513e3d470b Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Sat, 26 Oct 2013 15:35:28 -0700
Subject: [PATCH 14/93] cache string allocations in glGetString and
 eglQueryString

---
 src/library_egl.js | 14 ++++++++++----
 src/library_gl.js  | 12 +++++++++---
 2 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/src/library_egl.js b/src/library_egl.js
index c25dc8ef7ec9f..69902785203e6 100644
--- a/src/library_egl.js
+++ b/src/library_egl.js
@@ -10,6 +10,8 @@ var LibraryEGL = {
   $EGL: {
     // This variable tracks the success status of the most recently invoked EGL function call.
     eglErrorCode: 0x3000 /* EGL_SUCCESS */,
+
+    stringCache: {},
     
     setErrorCode: function(code) {
       EGL.eglErrorCode = code;
@@ -416,15 +418,19 @@ var LibraryEGL = {
     }
     //\todo An EGL_NOT_INITIALIZED error is generated if EGL is not initialized for dpy. 
     EGL.setErrorCode(0x3000 /* EGL_SUCCESS */);
+    if (EGL.stringCache[name]) return EGL.stringCache[name];
+    var ret;
     switch(name) {
-      case 0x3053 /* EGL_VENDOR */: return allocate(intArrayFromString("Emscripten"), 'i8', ALLOC_NORMAL);
-      case 0x3054 /* EGL_VERSION */: return allocate(intArrayFromString("1.4 Emscripten EGL"), 'i8', ALLOC_NORMAL);
-      case 0x3055 /* EGL_EXTENSIONS */:  return allocate(intArrayFromString(""), 'i8', ALLOC_NORMAL); // Currently not supporting any EGL extensions.
-      case 0x308D /* EGL_CLIENT_APIS */: return allocate(intArrayFromString("OpenGL_ES"), 'i8', ALLOC_NORMAL);
+      case 0x3053 /* EGL_VENDOR */: ret = allocate(intArrayFromString("Emscripten"), 'i8', ALLOC_NORMAL);
+      case 0x3054 /* EGL_VERSION */: ret = allocate(intArrayFromString("1.4 Emscripten EGL"), 'i8', ALLOC_NORMAL);
+      case 0x3055 /* EGL_EXTENSIONS */:  ret = allocate(intArrayFromString(""), 'i8', ALLOC_NORMAL); // Currently not supporting any EGL extensions.
+      case 0x308D /* EGL_CLIENT_APIS */: ret = allocate(intArrayFromString("OpenGL_ES"), 'i8', ALLOC_NORMAL);
       default:
         EGL.setErrorCode(0x300C /* EGL_BAD_PARAMETER */);
         return 0;
     }
+    EGL.stringCache[name] = ret;
+    return ret;
   },
   
   // EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api);
diff --git a/src/library_gl.js b/src/library_gl.js
index 1ea8efc21739d..cfdd800dea12d 100644
--- a/src/library_gl.js
+++ b/src/library_gl.js
@@ -42,6 +42,8 @@ var LibraryGL = {
 
     uniformTable: {}, // name => uniform ID. the uID must be identical until relinking, cannot create a new uID each call to glGetUniformLocation
 
+    stringCache: {},
+
     packAlignment: 4,   // default alignment is 4 bytes
     unpackAlignment: 4, // default alignment is 4 bytes
 
@@ -497,11 +499,13 @@ var LibraryGL = {
 
   glGetString__sig: 'ii',
   glGetString: function(name_) {
+    if (GL.stringCache[name_]) return GL.stringCache[name_];
+    var ret; 
     switch(name_) {
       case 0x1F00 /* GL_VENDOR */:
       case 0x1F01 /* GL_RENDERER */:
       case 0x1F02 /* GL_VERSION */:
-        return allocate(intArrayFromString(Module.ctx.getParameter(name_)), 'i8', ALLOC_NORMAL);
+        ret = allocate(intArrayFromString(Module.ctx.getParameter(name_)), 'i8', ALLOC_NORMAL);
       case 0x1F03 /* GL_EXTENSIONS */:
         var exts = Module.ctx.getSupportedExtensions();
         var gl_exts = [];
@@ -509,12 +513,14 @@ var LibraryGL = {
           gl_exts.push(exts[i]);
           gl_exts.push("GL_" + exts[i]);
         }
-        return allocate(intArrayFromString(gl_exts.join(' ')), 'i8', ALLOC_NORMAL); // XXX this leaks! TODO: Cache all results like this in library_gl.js to be clean and nice and avoid leaking.
+        ret = allocate(intArrayFromString(gl_exts.join(' ')), 'i8', ALLOC_NORMAL);
       case 0x8B8C /* GL_SHADING_LANGUAGE_VERSION */:
-        return allocate(intArrayFromString('OpenGL ES GLSL 1.00 (WebGL)'), 'i8', ALLOC_NORMAL);
+        ret = allocate(intArrayFromString('OpenGL ES GLSL 1.00 (WebGL)'), 'i8', ALLOC_NORMAL);
       default:
         throw 'Failure: Invalid glGetString value: ' + name_;
     }
+    GL.stringCache[name_] = ret;
+    return ret;
   },
 
   glGetIntegerv__sig: 'vii',

From 5017df14dbeadcb486a5b8b95533142ee4296fd1 Mon Sep 17 00:00:00 2001
From: Bruce Mitchener <bruce.mitchener@gmail.com>
Date: Sun, 27 Oct 2013 13:02:37 +0700
Subject: [PATCH 15/93] Fix an issue with Boost compilation.

The issue is that when these macros are defined, libcxx
creates inline functions and so we end up with 2 separate
defintions of these functions (one inline in std and one
that is extern "C").

We undef these until libcxx is fixed. Without this,
some things can fail to compile correctly, like
Boost. Fixes issue #1716.
---
 system/include/compat/ctype.h  | 17 +++++++++++++++++
 system/include/compat/wchar.h  | 23 +++++++++++++++++++++++
 system/include/compat/wctype.h | 23 +++++++++++++++++++++++
 tests/test_core.py             | 17 +++++++++++++++++
 4 files changed, 80 insertions(+)
 create mode 100644 system/include/compat/wchar.h
 create mode 100644 system/include/compat/wctype.h

diff --git a/system/include/compat/ctype.h b/system/include/compat/ctype.h
index 891006d95dca7..3f504946937f5 100644
--- a/system/include/compat/ctype.h
+++ b/system/include/compat/ctype.h
@@ -14,4 +14,21 @@
 
 #include_next <ctype.h>
 
+/* We undef these until libcxx is fixed. Without this,
+   some things can fail to compile correctly, like
+   Boost. Issue #1716. */
+
+#undef isalpha
+#undef isblank
+#undef iscntrl
+#undef isdigit
+#undef isgraph
+#undef islower
+#undef isprint
+#undef ispunct
+#undef isspace
+#undef isupper
+#undef isxdigit
+#undef isctype
+
 #endif /* _COMPAT_CTYPE_H_ */
diff --git a/system/include/compat/wchar.h b/system/include/compat/wchar.h
new file mode 100644
index 0000000000000..42f0bcee36c51
--- /dev/null
+++ b/system/include/compat/wchar.h
@@ -0,0 +1,23 @@
+#ifndef  _COMPAT_WCHAR_H_
+#define  _COMPAT_WCHAR_H_
+
+#include_next <wchar.h>
+
+/* We undef these until libcxx is fixed. Without this,
+   some things can fail to compile correctly, like
+   Boost. Issue #1716. */
+
+#undef iswalpha
+#undef iswblank
+#undef iswcntrl
+#undef iswdigit
+#undef iswgraph
+#undef iswlower
+#undef iswprint
+#undef iswpunct
+#undef iswspace
+#undef iswupper
+#undef iswxdigit
+#undef iswctype
+
+#endif /* _COMPAT_WCHAR_H_ */
diff --git a/system/include/compat/wctype.h b/system/include/compat/wctype.h
new file mode 100644
index 0000000000000..0eeaab8b28523
--- /dev/null
+++ b/system/include/compat/wctype.h
@@ -0,0 +1,23 @@
+#ifndef  _COMPAT_WCTYPE_H_
+#define  _COMPAT_WCTYPE_H_
+
+#include_next <wctype.h>
+
+/* We undef these until libcxx is fixed. Without this,
+   some things can fail to compile correctly, like
+   Boost. Issue #1716. */
+
+#undef iswalpha
+#undef iswblank
+#undef iswcntrl
+#undef iswdigit
+#undef iswgraph
+#undef iswlower
+#undef iswprint
+#undef iswpunct
+#undef iswspace
+#undef iswupper
+#undef iswxdigit
+#undef iswctype
+
+#endif /* _COMPAT_WCTYPE_H_ */
diff --git a/tests/test_core.py b/tests/test_core.py
index dd5b1e39ad380..b766ac7447989 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -2949,6 +2949,23 @@ def test_isdigit_l(self):
       '''
       self.do_run(src, '3.14159')
 
+  def test_iswdigit(self):
+      if self.emcc_args is None: return self.skip('no libcxx inclusion without emcc')
+
+      src = '''
+        #include <stdio.h>
+        #include <cctype>
+        #include <cwctype>
+
+        int main() {
+          using namespace std;
+          printf("%d ", isdigit('0'));
+          printf("%d ", iswdigit(L'0'));
+          return 0;
+        }
+      '''
+      self.do_run(src, '1 1')
+
   def test_polymorph(self):
       if self.emcc_args is None: return self.skip('requires emcc')
       src = '''

From cf1411ea51f30cf7f30d27f2eff61cd21b1fc386 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Sun, 27 Oct 2013 12:23:33 -0700
Subject: [PATCH 16/93] show alerts if antialiasing, depth or stencil are
 missing in context attributes test

---
 tests/test_webgl_context_attributes_common.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/tests/test_webgl_context_attributes_common.c b/tests/test_webgl_context_attributes_common.c
index 80d569ce773a3..7131203bffa2a 100644
--- a/tests/test_webgl_context_attributes_common.c
+++ b/tests/test_webgl_context_attributes_common.c
@@ -3,6 +3,8 @@
 #include <string.h>
 #include <stdbool.h>
 
+#include <emscripten.h>
+
 #define BUFFER_OFFSET(i) ((char *)NULL + (i))
 
 static const int WINDOWS_SIZE = 500;
@@ -245,12 +247,15 @@ extern int webglStencilSupported();
 static void checkContextAttributesSupport() {
   if (!webglAntialiasSupported()) {
     resultAA = 1;
-  } 
+    EM_ASM(alert('warning: no antialiasing\n'));
+  }
   if (!webglDepthSupported()) {
     resultDepth = 1;
-  } 
+    EM_ASM(alert('warning: no depth\n'));
+  }
   if (!webglStencilSupported()) {
     resultStencil = 1;
+    EM_ASM(alert('warning: no stencil\n'));
   }
 }
 

From 432c9e5d8cf543dc998026a4923a5a7e7cdc6af6 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Sun, 27 Oct 2013 12:25:18 -0700
Subject: [PATCH 17/93] simplify webgl context attributes test harness code a
 little

---
 tests/test_browser.py | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/tests/test_browser.py b/tests/test_browser.py
index 0fb45124d8517..2ff9106b93232 100644
--- a/tests/test_browser.py
+++ b/tests/test_browser.py
@@ -880,19 +880,13 @@ def test_webgl_context_attributes(self):
           context = canvas.getContext('experimental-webgl', {antialias: true});
           attributes = context.getContextAttributes();
           return attributes.antialias;
-        }
-      });
-
-      mergeInto(LibraryManager.library, {
+        },
         webglDepthSupported: function() {
           canvas = document.createElement('canvas');
           context = canvas.getContext('experimental-webgl', {depth: true});
           attributes = context.getContextAttributes();
           return attributes.depth;
-        }
-      });
-
-      mergeInto(LibraryManager.library, {
+        },
         webglStencilSupported: function() {
           canvas = document.createElement('canvas');
           context = canvas.getContext('experimental-webgl', {stencil: true});

From 7a902d9e4d79e370f44f94a9a7f7ed45ba3dfbb2 Mon Sep 17 00:00:00 2001
From: Fraser Adams <fraser.adams@blueyonder.co.uk>
Date: Sun, 27 Oct 2013 20:30:13 +0000
Subject: [PATCH 18/93] add support for node.js to act as a socket client

---
 src/library_browser.js |  6 +++++-
 src/library_sockfs.js  |  6 ++++--
 tests/test_sockets.py  | 29 ++++++++++++++++++++++++++++-
 3 files changed, 37 insertions(+), 4 deletions(-)

diff --git a/src/library_browser.js b/src/library_browser.js
index 59d2945efa231..5ec02eeea2f41 100644
--- a/src/library_browser.js
+++ b/src/library_browser.js
@@ -782,7 +782,11 @@ mergeInto(LibraryManager.library, {
       }
     } else {
       Browser.mainLoop.scheduler = function() {
-        Browser.requestAnimationFrame(Browser.mainLoop.runner);
+        if (typeof window === 'undefined') { // requestAnimationFrame will fail if window is undefined (e.g. in Node.js)
+          setTimeout(Browser.mainLoop.runner, 1000/60);
+        } else {
+          Browser.requestAnimationFrame(Browser.mainLoop.runner);
+        }
       }
     }
     Browser.mainLoop.scheduler();
diff --git a/src/library_sockfs.js b/src/library_sockfs.js
index af29d11bb6286..0e083bfde9f20 100644
--- a/src/library_sockfs.js
+++ b/src/library_sockfs.js
@@ -138,7 +138,9 @@ mergeInto(LibraryManager.library, {
             console.log('connect: ' + url);
 #endif
             // the node ws library API is slightly different than the browser's
-            var opts = ENVIRONMENT_IS_NODE ? {} : ['binary'];
+            var opts = ENVIRONMENT_IS_NODE ? {headers: {'websocket-protocol': ['binary']}} : ['binary'];
+            // If node we use the ws library.
+            WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : WebSocket;
             ws = new WebSocket(url, opts);
             ws.binaryType = 'arraybuffer';
           } catch (e) {
@@ -573,4 +575,4 @@ mergeInto(LibraryManager.library, {
       }
     }
   }
-});
\ No newline at end of file
+});
diff --git a/tests/test_sockets.py b/tests/test_sockets.py
index d2bc46a24ab12..36e2dfb63c179 100644
--- a/tests/test_sockets.py
+++ b/tests/test_sockets.py
@@ -1,5 +1,5 @@
 import os, multiprocessing, subprocess
-from runner import BrowserCore, path_from_root
+from runner import BrowserCore, RunnerCore, path_from_root
 from tools.shared import *
 
 def clean_pids(pids):
@@ -400,3 +400,30 @@ def test_webrtc(self):
     expected = '1'
     self.run_browser(host_outfile, '.', ['/report_result?' + e for e in expected])
 
+class nodejs_sockets(RunnerCore):
+  def test_sockets_echo(self):
+    # This test checks that sockets work when the client code is run in Node.js
+    # Run with ./runner.py nodejs_sockets.test_sockets_echo
+    if not NODE_JS in JS_ENGINES:
+        return
+
+    sockets_include = '-I'+path_from_root('tests', 'sockets')
+
+    # Websockify-proxied servers can't run dgram tests
+    harnesses = [
+      # Websockify doesn't seem to like ws.WebSocket clients TODO check if this is a ws issue or Websockify issue
+      #(WebsockifyServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include], 49160), 0),
+      (CompiledServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DTEST_DGRAM=0'], 49161), 0),
+      (CompiledServerHarness(os.path.join('sockets', 'test_sockets_echo_server.c'), [sockets_include, '-DTEST_DGRAM=1'], 49162), 1)
+    ]
+
+    for harness, datagram in harnesses:
+      with harness:
+        Popen([PYTHON, EMCC, path_from_root('tests', 'sockets', 'test_sockets_echo_client.c'), '-o', path_from_root('tests', 'sockets', 'client.js'), '-DSOCKK=%d' % harness.listen_port, '-DREPORT_RESULT=int dummy'], stdout=PIPE, stderr=PIPE).communicate()
+
+        self.assertContained('do_msg_read: read 14 bytes', run_js(path_from_root('tests', 'sockets', 'client.js'), engine=NODE_JS))
+
+        # Tidy up files that might have been created by this test.
+        try_delete(path_from_root('tests', 'sockets', 'client.js'))
+        try_delete(path_from_root('tests', 'sockets', 'client.js.map'))
+

From 1368bc453d6f748232125df05f87858396a963d0 Mon Sep 17 00:00:00 2001
From: icetooth <icetooth333@gmail.com>
Date: Mon, 28 Oct 2013 09:26:34 -0400
Subject: [PATCH 19/93] added myself

---
 AUTHORS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/AUTHORS b/AUTHORS
index 5ad3f98dc0acd..18124a6c3e9fb 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -104,4 +104,5 @@ a license to everyone to use it as detailed in LICENSE.)
 * Daniel Aquino <mr.danielaquino@gmail.com>
 * Remi Papillie <remi.papillie@gmail.com>
 * Fraser Adams <fraser.adams@blueyonder.co.uk>
+* Michael Tirado <icetooth333@gmail.com>
 

From b5c2757c7c54b08b4cb5a0524a2b64c11eb7d65d Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 10:23:46 -0700
Subject: [PATCH 20/93] only emit decrunch code when crunch is enabled

---
 tools/file_packager.py | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/tools/file_packager.py b/tools/file_packager.py
index a2349a5722079..30f216ae9fdc8 100644
--- a/tools/file_packager.py
+++ b/tools/file_packager.py
@@ -338,18 +338,9 @@ def was_seen(name):
       send: function() {},
       onload: function() {
         var byteArray = this.byteArray.subarray(this.start, this.end);
-        if (this.crunched) {
-          var ddsHeader = byteArray.subarray(0, 128);
-          var that = this;
-          requestDecrunch(this.name, byteArray.subarray(128), function(ddsData) {
-            byteArray = new Uint8Array(ddsHeader.length + ddsData.length);
-            byteArray.set(ddsHeader, 0);
-            byteArray.set(ddsData, 128);
-            that.finish(byteArray);
-          });
-        } else {
+%s
           this.finish(byteArray);
-        }
+%s
       },
       finish: function(byteArray) {
         var that = this;
@@ -365,7 +356,20 @@ def was_seen(name):
         this.requests[this.name] = null;
       },
     };
-  '''
+  ''' % ('' if not crunch else '''
+        if (this.crunched) {
+          var ddsHeader = byteArray.subarray(0, 128);
+          var that = this;
+          requestDecrunch(this.name, byteArray.subarray(128), function(ddsData) {
+            byteArray = new Uint8Array(ddsHeader.length + ddsData.length);
+            byteArray.set(ddsHeader, 0);
+            byteArray.set(ddsData, 128);
+            that.finish(byteArray);
+          });
+        } else {
+''', '' if not crunch else '''
+        }
+''')
 
 counter = 0
 for file_ in data_files:

From 9e5b0a8bb6ad0222f9a8a328bd36481656b7009f Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 10:40:00 -0700
Subject: [PATCH 21/93] optimize Module.setStatus

---
 src/shell.html | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/shell.html b/src/shell.html
index a33735d910b15..53a4fffba0339 100644
--- a/src/shell.html
+++ b/src/shell.html
@@ -63,8 +63,11 @@
         },
         canvas: document.getElementById('canvas'),
         setStatus: function(text) {
-          if (Module.setStatus.interval) clearInterval(Module.setStatus.interval);
+          if (!Module.setStatus.last) Module.setStatus.last = { time: Date.now(), text: '' };
+          if (text === Module.setStatus.text) return;
           var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/);
+          var now = Date.now();
+          if (m && now - Date.now() < 30) return; // if this is a progress update, skip it if too soon
           var statusElement = document.getElementById('status');
           var progressElement = document.getElementById('progress');
           if (m) {

From 84272ebefa19a65ccb55a853a81e0a87adf9f213 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 10:43:53 -0700
Subject: [PATCH 22/93] only do run dependency tracking when assertions are on

---
 src/preamble.js | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/preamble.js b/src/preamble.js
index ee273f6a36eda..9e72e7b8264f1 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -1107,19 +1107,21 @@ var Math_min = Math.min;
 // it happens right before run - run will be postponed until
 // the dependencies are met.
 var runDependencies = 0;
-var runDependencyTracking = {};
 var runDependencyWatcher = null;
 var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+#if ASSERTIONS
+var runDependencyTracking = {};
+#endif
 
 function addRunDependency(id) {
   runDependencies++;
   if (Module['monitorRunDependencies']) {
     Module['monitorRunDependencies'](runDependencies);
   }
+#if ASSERTIONS
   if (id) {
     assert(!runDependencyTracking[id]);
     runDependencyTracking[id] = 1;
-#if ASSERTIONS
     if (runDependencyWatcher === null && typeof setInterval !== 'undefined') {
       // Check for missing dependencies every few seconds
       runDependencyWatcher = setInterval(function() {
@@ -1136,10 +1138,10 @@ function addRunDependency(id) {
         }
       }, 10000);
     }
-#endif
   } else {
     Module.printErr('warning: run dependency added without ID');
   }
+#endif
 }
 Module['addRunDependency'] = addRunDependency;
 function removeRunDependency(id) {
@@ -1147,12 +1149,14 @@ function removeRunDependency(id) {
   if (Module['monitorRunDependencies']) {
     Module['monitorRunDependencies'](runDependencies);
   }
+#if ASSERTIONS
   if (id) {
     assert(runDependencyTracking[id]);
     delete runDependencyTracking[id];
   } else {
     Module.printErr('warning: run dependency removed without ID');
   }
+#endif
   if (runDependencies == 0) {
     if (runDependencyWatcher !== null) {
       clearInterval(runDependencyWatcher);

From 1844811464c9cfb71bc315e24c61707414db88e6 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 11:42:54 -0700
Subject: [PATCH 23/93] reuse some FS errors in places where overhead is high
 and stack importance is low

---
 src/library_fs.js    | 6 ++++++
 src/library_memfs.js | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/library_fs.js b/src/library_fs.js
index bd1522a87db17..90f5d3b0ffbc8 100644
--- a/src/library_fs.js
+++ b/src/library_fs.js
@@ -28,6 +28,7 @@ mergeInto(LibraryManager.library, {
     ignorePermissions: true,
     
     ErrnoError: null, // set during init
+    genericErrors: {},
 
     handleFSError: function(e) {
       if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
@@ -1079,6 +1080,11 @@ mergeInto(LibraryManager.library, {
       };
       FS.ErrnoError.prototype = new Error();
       FS.ErrnoError.prototype.constructor = FS.ErrnoError;
+      // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
+      [ERRNO_CODES.ENOENT].forEach(function(code) {
+        FS.genericErrors[code] = new FS.ErrnoError(code);
+        FS.genericErrors[code].stack = '<generic error, no stack>';
+      });
     },
     staticInit: function() {
       FS.ensureErrnoError();
diff --git a/src/library_memfs.js b/src/library_memfs.js
index 94fd767e8bb7c..51a8da1640373 100644
--- a/src/library_memfs.js
+++ b/src/library_memfs.js
@@ -117,7 +117,7 @@ mergeInto(LibraryManager.library, {
         }
       },
       lookup: function(parent, name) {
-        throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+        throw FS.genericErrors[ERRNO_CODES.ENOENT];
       },
       mknod: function(parent, name, mode, dev) {
         return MEMFS.createNode(parent, name, mode, dev);

From 50637a70c722ef625bb36b7ede957224a4e54b90 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 12:06:58 -0700
Subject: [PATCH 24/93] reuse node in chmod call from createDataFile

---
 src/library_fs.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/library_fs.js b/src/library_fs.js
index 90f5d3b0ffbc8..7090283453aed 100644
--- a/src/library_fs.js
+++ b/src/library_fs.js
@@ -1215,7 +1215,7 @@ mergeInto(LibraryManager.library, {
           data = arr;
         }
         // make sure we can write to the file
-        FS.chmod(path, mode | {{{ cDefine('S_IWUGO') }}});
+        FS.chmod(node, mode | {{{ cDefine('S_IWUGO') }}});
         var stream = FS.open(path, 'w');
         FS.write(stream, data, 0, data.length, 0, canOwn);
         FS.close(stream);

From 000f6946aa7d0240adbde91e4ace52311849ee0f Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 12:09:13 -0700
Subject: [PATCH 25/93] reuse node in open call from createDataFile

---
 src/library_fs.js | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/src/library_fs.js b/src/library_fs.js
index 7090283453aed..5d9604622996d 100644
--- a/src/library_fs.js
+++ b/src/library_fs.js
@@ -772,7 +772,6 @@ mergeInto(LibraryManager.library, {
       });
     },
     open: function(path, flags, mode, fd_start, fd_end) {
-      path = PATH.normalize(path);
       flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
       mode = typeof mode === 'undefined' ? 0666 : mode;
       if ((flags & {{{ cDefine('O_CREAT') }}})) {
@@ -781,13 +780,18 @@ mergeInto(LibraryManager.library, {
         mode = 0;
       }
       var node;
-      try {
-        var lookup = FS.lookupPath(path, {
-          follow: !(flags & {{{ cDefine('O_NOFOLLOW') }}})
-        });
-        node = lookup.node;
-      } catch (e) {
-        // ignore
+      if (typeof path === 'object') {
+        node = path;
+      } else {
+        path = PATH.normalize(path);
+        try {
+          var lookup = FS.lookupPath(path, {
+            follow: !(flags & {{{ cDefine('O_NOFOLLOW') }}})
+          });
+          node = lookup.node;
+        } catch (e) {
+          // ignore
+        }
       }
       // perhaps we need to create the node
       if ((flags & {{{ cDefine('O_CREAT') }}})) {
@@ -1216,7 +1220,7 @@ mergeInto(LibraryManager.library, {
         }
         // make sure we can write to the file
         FS.chmod(node, mode | {{{ cDefine('S_IWUGO') }}});
-        var stream = FS.open(path, 'w');
+        var stream = FS.open(node, 'w');
         FS.write(stream, data, 0, data.length, 0, canOwn);
         FS.close(stream);
         FS.chmod(path, mode);

From d6a0bd01e179c137b3aa62924d7d824905db2070 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 12:10:28 -0700
Subject: [PATCH 26/93] reuse node in last chmod call from createDataFile

---
 src/library_fs.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/library_fs.js b/src/library_fs.js
index 5d9604622996d..826b64f592dec 100644
--- a/src/library_fs.js
+++ b/src/library_fs.js
@@ -1223,7 +1223,7 @@ mergeInto(LibraryManager.library, {
         var stream = FS.open(node, 'w');
         FS.write(stream, data, 0, data.length, 0, canOwn);
         FS.close(stream);
-        FS.chmod(path, mode);
+        FS.chmod(node, mode);
       }
       return node;
     },

From 5044dd694d064aff6cea7cc48bc81f1f190177ad Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 14:15:06 -0700
Subject: [PATCH 27/93] optimize FS.createNode

---
 src/library_fs.js | 80 +++++++++++++++++++++++++----------------------
 1 file changed, 43 insertions(+), 37 deletions(-)

diff --git a/src/library_fs.js b/src/library_fs.js
index 826b64f592dec..8aac29a439949 100644
--- a/src/library_fs.js
+++ b/src/library_fs.js
@@ -159,44 +159,50 @@ mergeInto(LibraryManager.library, {
       return FS.lookup(parent, name);
     },
     createNode: function(parent, name, mode, rdev) {
-      var node = {
-        id: FS.nextInode++,
-        name: name,
-        mode: mode,
-        node_ops: {},
-        stream_ops: {},
-        rdev: rdev,
-        parent: null,
-        mount: null
-      };
-      if (!parent) {
-        parent = node;  // root node sets parent to itself
+      if (!FS.FSNode) {
+        FS.FSNode = function(parent, name, mode, rdev) {
+          this.id = FS.nextInode++;
+          this.name = name;
+          this.mode = mode;
+          this.node_ops = {};
+          this.stream_ops = {};
+          this.rdev = rdev;
+          this.parent = null;
+          this.mount = null;
+          if (!parent) {
+            parent = this;  // root node sets parent to itself
+          }
+          this.parent = parent;
+          this.mount = parent.mount;
+          FS.hashAddNode(this);
+        };
+
+        // compatibility
+        var readMode = {{{ cDefine('S_IRUGO') }}} | {{{ cDefine('S_IXUGO') }}};
+        var writeMode = {{{ cDefine('S_IWUGO') }}};
+
+        FS.FSNode.prototype = {};
+
+        // NOTE we must use Object.defineProperties instead of individual calls to
+        // Object.defineProperty in order to make closure compiler happy
+        Object.defineProperties(FS.FSNode.prototype, {
+          read: {
+            get: function() { return (this.mode & readMode) === readMode; },
+            set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
+          },
+          write: {
+            get: function() { return (this.mode & writeMode) === writeMode; },
+            set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
+          },
+          isFolder: {
+            get: function() { return FS.isDir(this.mode); },
+          },
+          isDevice: {
+            get: function() { return FS.isChrdev(this.mode); },
+          },
+        });
       }
-      node.parent = parent;
-      node.mount = parent.mount;
-      // compatibility
-      var readMode = {{{ cDefine('S_IRUGO') }}} | {{{ cDefine('S_IXUGO') }}};
-      var writeMode = {{{ cDefine('S_IWUGO') }}};
-      // NOTE we must use Object.defineProperties instead of individual calls to
-      // Object.defineProperty in order to make closure compiler happy
-      Object.defineProperties(node, {
-        read: {
-          get: function() { return (node.mode & readMode) === readMode; },
-          set: function(val) { val ? node.mode |= readMode : node.mode &= ~readMode; }
-        },
-        write: {
-          get: function() { return (node.mode & writeMode) === writeMode; },
-          set: function(val) { val ? node.mode |= writeMode : node.mode &= ~writeMode; }
-        },
-        isFolder: {
-          get: function() { return FS.isDir(node.mode); },
-        },
-        isDevice: {
-          get: function() { return FS.isChrdev(node.mode); },
-        },
-      });
-      FS.hashAddNode(node);
-      return node;
+      return new FS.FSNode(parent, name, mode, rdev);
     },
     destroyNode: function(node) {
       FS.hashRemoveNode(node);

From 03ad4ea44efa450c46405df7b048859841681782 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 14:24:15 -0700
Subject: [PATCH 28/93] remove assertion code from PATH.join

---
 src/library_path.js | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/src/library_path.js b/src/library_path.js
index 09808acd77f89..15086e258c0fb 100644
--- a/src/library_path.js
+++ b/src/library_path.js
@@ -73,12 +73,7 @@ mergeInto(LibraryManager.library, {
     },
     join: function() {
       var paths = Array.prototype.slice.call(arguments, 0);
-      return PATH.normalize(paths.filter(function(p, index) {
-        if (typeof p !== 'string') {
-          throw new TypeError('Arguments to path.join must be strings');
-        }
-        return p;
-      }).join('/'));
+      return PATH.normalize(paths.join('/'));
     },
     resolve: function() {
       var resolvedPath = '',
@@ -134,4 +129,4 @@ mergeInto(LibraryManager.library, {
       return outputParts.join('/');
     }
   }
-});
\ No newline at end of file
+});

From b6342e4cedcdb4fcd8cb61b1879c0aa839e03f52 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 14:30:12 -0700
Subject: [PATCH 29/93] add PATH.join2 as a fast way to join 2 path elements
 without the generic overhead of PATH.join

---
 src/library_fs.js     | 20 ++++++++++----------
 src/library_idbfs.js  |  2 +-
 src/library_nodefs.js | 12 ++++++------
 src/library_path.js   |  3 +++
 4 files changed, 20 insertions(+), 17 deletions(-)

diff --git a/src/library_fs.js b/src/library_fs.js
index 8aac29a439949..409c8afdefc17 100644
--- a/src/library_fs.js
+++ b/src/library_fs.js
@@ -63,7 +63,7 @@ mergeInto(LibraryManager.library, {
         }
 
         current = FS.lookupNode(current, parts[i]);
-        current_path = PATH.join(current_path, parts[i]);
+        current_path = PATH.join2(current_path, parts[i]);
 
         // jump to the mount's root node if this is a mountpoint
         if (FS.isMountpoint(current)) {
@@ -95,9 +95,9 @@ mergeInto(LibraryManager.library, {
       var path;
       while (true) {
         if (FS.isRoot(node)) {
-          return path ? PATH.join(node.mount.mountpoint, path) : node.mount.mountpoint;
+          return path ? PATH.join2(node.mount.mountpoint, path) : node.mount.mountpoint;
         }
-        path = path ? PATH.join(node.name, path) : node.name;
+        path = path ? PATH.join2(node.name, path) : node.name;
         node = node.parent;
       }
     },
@@ -1189,7 +1189,7 @@ mergeInto(LibraryManager.library, {
       return ret;
     },
     createFolder: function(parent, name, canRead, canWrite) {
-      var path = PATH.join(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+      var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
       var mode = FS.getMode(canRead, canWrite);
       return FS.mkdir(path, mode);
     },
@@ -1199,7 +1199,7 @@ mergeInto(LibraryManager.library, {
       while (parts.length) {
         var part = parts.pop();
         if (!part) continue;
-        var current = PATH.join(parent, part);
+        var current = PATH.join2(parent, part);
         try {
           FS.mkdir(current);
         } catch (e) {
@@ -1210,12 +1210,12 @@ mergeInto(LibraryManager.library, {
       return current;
     },
     createFile: function(parent, name, properties, canRead, canWrite) {
-      var path = PATH.join(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+      var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
       var mode = FS.getMode(canRead, canWrite);
       return FS.create(path, mode);
     },
     createDataFile: function(parent, name, data, canRead, canWrite, canOwn) {
-      var path = name ? PATH.join(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
+      var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
       var mode = FS.getMode(canRead, canWrite);
       var node = FS.create(path, mode);
       if (data) {
@@ -1234,7 +1234,7 @@ mergeInto(LibraryManager.library, {
       return node;
     },
     createDevice: function(parent, name, input, output) {
-      var path = PATH.join(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+      var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
       var mode = FS.getMode(!!input, !!output);
       if (!FS.createDevice.major) FS.createDevice.major = 64;
       var dev = FS.makedev(FS.createDevice.major++, 0);
@@ -1288,7 +1288,7 @@ mergeInto(LibraryManager.library, {
       return FS.mkdev(path, mode, dev);
     },
     createLink: function(parent, name, target, canRead, canWrite) {
-      var path = PATH.join(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+      var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
       return FS.symlink(target, path);
     },
     // Makes sure a file's contents are loaded. Returns whether the file has
@@ -1478,7 +1478,7 @@ mergeInto(LibraryManager.library, {
       Browser.init();
       // TODO we should allow people to just pass in a complete filename instead
       // of parent and name being that we just join them anyways
-      var fullname = name ? PATH.resolve(PATH.join(parent, name)) : parent;
+      var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent;
       function processData(byteArray) {
         function finish(byteArray) {
           if (!dontCreateFile) {
diff --git a/src/library_idbfs.js b/src/library_idbfs.js
index 9031bad819729..ab55673ffc26c 100644
--- a/src/library_idbfs.js
+++ b/src/library_idbfs.js
@@ -130,7 +130,7 @@ mergeInto(LibraryManager.library, {
       };
       var toAbsolute = function(root) {
         return function(p) {
-          return PATH.join(root, p);
+          return PATH.join2(root, p);
         }
       };
 
diff --git a/src/library_nodefs.js b/src/library_nodefs.js
index 2be540769039b..7686f3f2861e0 100644
--- a/src/library_nodefs.js
+++ b/src/library_nodefs.js
@@ -134,7 +134,7 @@ mergeInto(LibraryManager.library, {
         }
       },
       lookup: function (parent, name) {
-        var path = PATH.join(NODEFS.realPath(parent), name);
+        var path = PATH.join2(NODEFS.realPath(parent), name);
         var mode = NODEFS.getMode(path);
         return NODEFS.createNode(parent, name, mode);
       },
@@ -156,7 +156,7 @@ mergeInto(LibraryManager.library, {
       },
       rename: function (oldNode, newDir, newName) {
         var oldPath = NODEFS.realPath(oldNode);
-        var newPath = PATH.join(NODEFS.realPath(newDir), newName);
+        var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
         try {
           fs.renameSync(oldPath, newPath);
         } catch (e) {
@@ -165,7 +165,7 @@ mergeInto(LibraryManager.library, {
         }
       },
       unlink: function(parent, name) {
-        var path = PATH.join(NODEFS.realPath(parent), name);
+        var path = PATH.join2(NODEFS.realPath(parent), name);
         try {
           fs.unlinkSync(path);
         } catch (e) {
@@ -174,7 +174,7 @@ mergeInto(LibraryManager.library, {
         }
       },
       rmdir: function(parent, name) {
-        var path = PATH.join(NODEFS.realPath(parent), name);
+        var path = PATH.join2(NODEFS.realPath(parent), name);
         try {
           fs.rmdirSync(path);
         } catch (e) {
@@ -192,7 +192,7 @@ mergeInto(LibraryManager.library, {
         }
       },
       symlink: function(parent, newName, oldPath) {
-        var newPath = PATH.join(NODEFS.realPath(parent), newName);
+        var newPath = PATH.join2(NODEFS.realPath(parent), newName);
         try {
           fs.symlinkSync(oldPath, newPath);
         } catch (e) {
@@ -283,4 +283,4 @@ mergeInto(LibraryManager.library, {
       }
     }
   }
-});
\ No newline at end of file
+});
diff --git a/src/library_path.js b/src/library_path.js
index 15086e258c0fb..4c96a07f0ac26 100644
--- a/src/library_path.js
+++ b/src/library_path.js
@@ -75,6 +75,9 @@ mergeInto(LibraryManager.library, {
       var paths = Array.prototype.slice.call(arguments, 0);
       return PATH.normalize(paths.join('/'));
     },
+    join2: function(l, r) {
+      return PATH.normalize(l + '/' + r);
+    },
     resolve: function() {
       var resolvedPath = '',
         resolvedAbsolute = false;

From 3b0856f2c69ea68f1771cce1772ad37eecf5deb5 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 14:40:40 -0700
Subject: [PATCH 30/93] avoid constant path normalization in getPath

---
 src/library_fs.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/library_fs.js b/src/library_fs.js
index 409c8afdefc17..a263714af0c57 100644
--- a/src/library_fs.js
+++ b/src/library_fs.js
@@ -97,7 +97,7 @@ mergeInto(LibraryManager.library, {
         if (FS.isRoot(node)) {
           return path ? PATH.join2(node.mount.mountpoint, path) : node.mount.mountpoint;
         }
-        path = path ? PATH.join2(node.name, path) : node.name;
+        path = path ? node.name + '/' + path : node.name;
         node = node.parent;
       }
     },

From 24a2894d567469a1c44430b4c6f43b5bbec41821 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 14:48:53 -0700
Subject: [PATCH 31/93] remove unused (by us) second parameter from
 PATH.basename

---
 src/library_path.js | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/library_path.js b/src/library_path.js
index 4c96a07f0ac26..01476e8d4651f 100644
--- a/src/library_path.js
+++ b/src/library_path.js
@@ -59,14 +59,10 @@ mergeInto(LibraryManager.library, {
       }
       return root + dir;
     },
-    basename: function(path, ext) {
+    basename: function(path) {
       // EMSCRIPTEN return '/'' for '/', not an empty string
       if (path === '/') return '/';
-      var f = PATH.splitPath(path)[2];
-      if (ext && f.substr(-1 * ext.length) === ext) {
-        f = f.substr(0, f.length - ext.length);
-      }
-      return f;
+      return PATH.splitPath(path)[2];
     },
     extname: function(path) {
       return PATH.splitPath(path)[3];

From b98b583f93c557ff3396cf1cc13146f9f878a9b0 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 14:51:32 -0700
Subject: [PATCH 32/93] optimize PATH.basename

---
 src/library_path.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/library_path.js b/src/library_path.js
index 01476e8d4651f..f00a75860fba3 100644
--- a/src/library_path.js
+++ b/src/library_path.js
@@ -62,7 +62,9 @@ mergeInto(LibraryManager.library, {
     basename: function(path) {
       // EMSCRIPTEN return '/'' for '/', not an empty string
       if (path === '/') return '/';
-      return PATH.splitPath(path)[2];
+      var lastSlash = path.lastIndexOf('/');
+      if (lastSlash === -1) return path;
+      return path.substr(lastSlash+1);
     },
     extname: function(path) {
       return PATH.splitPath(path)[3];

From 2788d671c2a0ba52fab142fa51a7191f1728c7e6 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 15:16:16 -0700
Subject: [PATCH 33/93] do not normalize in getPath, since our paths elements
 are already ok

---
 src/library_fs.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/library_fs.js b/src/library_fs.js
index a263714af0c57..53d0d3f1e6003 100644
--- a/src/library_fs.js
+++ b/src/library_fs.js
@@ -95,7 +95,7 @@ mergeInto(LibraryManager.library, {
       var path;
       while (true) {
         if (FS.isRoot(node)) {
-          return path ? PATH.join2(node.mount.mountpoint, path) : node.mount.mountpoint;
+          return path ? node.mount.mountpoint + '/' + path : node.mount.mountpoint;
         }
         path = path ? node.name + '/' + path : node.name;
         node = node.parent;

From b86319f81859110e100666dac71bddf107de13e1 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 15:36:12 -0700
Subject: [PATCH 34/93] reuse ops objects in MEMFS.createNode

---
 src/library_memfs.js | 96 +++++++++++++++++++++++++++-----------------
 1 file changed, 59 insertions(+), 37 deletions(-)

diff --git a/src/library_memfs.js b/src/library_memfs.js
index 51a8da1640373..588bbabd5b0e2 100644
--- a/src/library_memfs.js
+++ b/src/library_memfs.js
@@ -1,6 +1,8 @@
 mergeInto(LibraryManager.library, {
   $MEMFS__deps: ['$FS'],
   $MEMFS: {
+    ops_table: null,
+
     // content modes
     CONTENT_OWNING: 1, // contains a subarray into the heap, and we own it, without copying (note: someone else needs to free() it, if that is necessary)
     CONTENT_FLEXIBLE: 2, // has been modified or never set to anything, and is a flexible js array that can grow/shrink
@@ -13,51 +15,71 @@ mergeInto(LibraryManager.library, {
         // no supported
         throw new FS.ErrnoError(ERRNO_CODES.EPERM);
       }
+      if (!MEMFS.ops_table) {
+        MEMFS.ops_table = {
+          dir: {
+            node: {
+              getattr: MEMFS.node_ops.getattr,
+              setattr: MEMFS.node_ops.setattr,
+              lookup: MEMFS.node_ops.lookup,
+              mknod: MEMFS.node_ops.mknod,
+              mknod: MEMFS.node_ops.mknod,
+              rename: MEMFS.node_ops.rename,
+              unlink: MEMFS.node_ops.unlink,
+              rmdir: MEMFS.node_ops.rmdir,
+              readdir: MEMFS.node_ops.readdir,
+              symlink: MEMFS.node_ops.symlink
+            },
+            stream: {
+              llseek: MEMFS.stream_ops.llseek
+            }
+          },
+          file: {
+            node: {
+              getattr: MEMFS.node_ops.getattr,
+              setattr: MEMFS.node_ops.setattr
+            },
+            stream: {
+              llseek: MEMFS.stream_ops.llseek,
+              read: MEMFS.stream_ops.read,
+              write: MEMFS.stream_ops.write,
+              allocate: MEMFS.stream_ops.allocate,
+              mmap: MEMFS.stream_ops.mmap
+            }
+          },
+          link: {
+            node: {
+              getattr: MEMFS.node_ops.getattr,
+              setattr: MEMFS.node_ops.setattr,
+              readlink: MEMFS.node_ops.readlink
+            },
+            stream: {}
+          },
+          chrdev: {
+            node: {
+              getattr: MEMFS.node_ops.getattr,
+              setattr: MEMFS.node_ops.setattr
+            },
+            stream: FS.chrdev_stream_ops
+          },
+        };
+      }
       var node = FS.createNode(parent, name, mode, dev);
       if (FS.isDir(node.mode)) {
-        node.node_ops = {
-          getattr: MEMFS.node_ops.getattr,
-          setattr: MEMFS.node_ops.setattr,
-          lookup: MEMFS.node_ops.lookup,
-          mknod: MEMFS.node_ops.mknod,
-          mknod: MEMFS.node_ops.mknod,
-          rename: MEMFS.node_ops.rename,
-          unlink: MEMFS.node_ops.unlink,
-          rmdir: MEMFS.node_ops.rmdir,
-          readdir: MEMFS.node_ops.readdir,
-          symlink: MEMFS.node_ops.symlink
-        };
-        node.stream_ops = {
-          llseek: MEMFS.stream_ops.llseek
-        };
+        node.node_ops = MEMFS.ops_table.dir.node;
+        node.stream_ops = MEMFS.ops_table.dir.stream;
         node.contents = {};
       } else if (FS.isFile(node.mode)) {
-        node.node_ops = {
-          getattr: MEMFS.node_ops.getattr,
-          setattr: MEMFS.node_ops.setattr
-        };
-        node.stream_ops = {
-          llseek: MEMFS.stream_ops.llseek,
-          read: MEMFS.stream_ops.read,
-          write: MEMFS.stream_ops.write,
-          allocate: MEMFS.stream_ops.allocate,
-          mmap: MEMFS.stream_ops.mmap
-        };
+        node.node_ops = MEMFS.ops_table.file.node;
+        node.stream_ops = MEMFS.ops_table.file.stream;
         node.contents = [];
         node.contentMode = MEMFS.CONTENT_FLEXIBLE;
       } else if (FS.isLink(node.mode)) {
-        node.node_ops = {
-          getattr: MEMFS.node_ops.getattr,
-          setattr: MEMFS.node_ops.setattr,
-          readlink: MEMFS.node_ops.readlink
-        };
-        node.stream_ops = {};
+        node.node_ops = MEMFS.ops_table.link.node;
+        node.stream_ops = MEMFS.ops_table.link.stream;
       } else if (FS.isChrdev(node.mode)) {
-        node.node_ops = {
-          getattr: MEMFS.node_ops.getattr,
-          setattr: MEMFS.node_ops.setattr
-        };
-        node.stream_ops = FS.chrdev_stream_ops;
+        node.node_ops = MEMFS.ops_table.chrdev.node;
+        node.stream_ops = MEMFS.ops_table.chrdev.stream;
       }
       node.timestamp = Date.now();
       // add the new node to the parent

From b405ba1b1337b03be2804354b9ef26aac9d98728 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 16:10:54 -0700
Subject: [PATCH 35/93] fix handling of generating path with a mountpoint
 ending with '/'

---
 src/library_fs.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/library_fs.js b/src/library_fs.js
index 53d0d3f1e6003..0e16343a7c6be 100644
--- a/src/library_fs.js
+++ b/src/library_fs.js
@@ -95,7 +95,9 @@ mergeInto(LibraryManager.library, {
       var path;
       while (true) {
         if (FS.isRoot(node)) {
-          return path ? node.mount.mountpoint + '/' + path : node.mount.mountpoint;
+          var mount = node.mount.mountpoint;
+          if (!path) return mount;
+          return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
         }
         path = path ? node.name + '/' + path : node.name;
         node = node.parent;

From 34ebaf94125130376d44bc7c3e5cebd11c7a08c5 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 16:21:08 -0700
Subject: [PATCH 36/93] optimize createStream

---
 src/library_fs.js | 36 ++++++++++++++++++++----------------
 1 file changed, 20 insertions(+), 16 deletions(-)

diff --git a/src/library_fs.js b/src/library_fs.js
index 0e16343a7c6be..aece2664359e7 100644
--- a/src/library_fs.js
+++ b/src/library_fs.js
@@ -360,24 +360,28 @@ mergeInto(LibraryManager.library, {
     // object isn't directly passed in. not possible until
     // SOCKFS is completed.
     createStream: function(stream, fd_start, fd_end) {
+      if (!FS.FSStream) {
+        FS.FSStream = {};
+        // compatibility
+        Object.defineProperties(FS.FSStream, {
+          object: {
+            get: function() { return this.node; },
+            set: function(val) { this.node = val; }
+          },
+          isRead: {
+            get: function() { return (this.flags & {{{ cDefine('O_ACCMODE') }}}) !== {{{ cDefine('O_WRONLY') }}}; }
+          },
+          isWrite: {
+            get: function() { return (this.flags & {{{ cDefine('O_ACCMODE') }}}) !== {{{ cDefine('O_RDONLY') }}}; }
+          },
+          isAppend: {
+            get: function() { return (this.flags & {{{ cDefine('O_APPEND') }}}); }
+          }
+        });
+      }
+      stream.prototype = FS.FSStream;
       var fd = FS.nextfd(fd_start, fd_end);
       stream.fd = fd;
-      // compatibility
-      Object.defineProperties(stream, {
-        object: {
-          get: function() { return stream.node; },
-          set: function(val) { stream.node = val; }
-        },
-        isRead: {
-          get: function() { return (stream.flags & {{{ cDefine('O_ACCMODE') }}}) !== {{{ cDefine('O_WRONLY') }}}; }
-        },
-        isWrite: {
-          get: function() { return (stream.flags & {{{ cDefine('O_ACCMODE') }}}) !== {{{ cDefine('O_RDONLY') }}}; }
-        },
-        isAppend: {
-          get: function() { return (stream.flags & {{{ cDefine('O_APPEND') }}}); }
-        }
-      });
       FS.streams[fd] = stream;
       return stream;
     },

From 2884e1826c8908b195422c2c422be6166a06cf79 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 16:46:19 -0700
Subject: [PATCH 37/93] fix progress shown when multiple asset packages are
 downloaded

---
 tools/file_packager.py | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/tools/file_packager.py b/tools/file_packager.py
index 30f216ae9fdc8..1d0ec447e4a87 100644
--- a/tools/file_packager.py
+++ b/tools/file_packager.py
@@ -134,6 +134,11 @@
 ret = '''
 var Module;
 if (typeof Module === 'undefined') Module = eval('(function() { try { return Module || {} } catch(e) { return {} } })()');
+if (!Module.expectedDataFileDownloads) {
+  Module.expectedDataFileDownloads = 0;
+  Module.finishedDataFileDownloads = 0;
+}
+Module.expectedDataFileDownloads++;
 (function() {
 '''
 
@@ -431,12 +436,6 @@ def was_seen(name):
   package_uuid = uuid.uuid4();
   remote_package_name = os.path.basename(Compression.compressed_name(data_target) if Compression.on else data_target)
   code += r'''
-    if (!Module.expectedDataFileDownloads) {
-      Module.expectedDataFileDownloads = 0;
-      Module.finishedDataFileDownloads = 0;
-    }
-    Module.expectedDataFileDownloads++;
-
     var PACKAGE_PATH = window['encodeURIComponent'](window.location.pathname.toString().substring(0, window.location.pathname.toString().lastIndexOf('/')) + '/');
     var PACKAGE_NAME = '%s';
     var REMOTE_PACKAGE_NAME = '%s';

From 58281d10e847d62ad10ba56d65aea4c2fb8f4aa0 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 17:02:38 -0700
Subject: [PATCH 38/93] fix glGetString and eglQueryString, and optimize
 emulated glGetString

---
 src/library_egl.js | 8 ++++----
 src/library_gl.js  | 8 +++++++-
 tests/aniso.c      | 3 +++
 3 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/src/library_egl.js b/src/library_egl.js
index 69902785203e6..cc702fece92f6 100644
--- a/src/library_egl.js
+++ b/src/library_egl.js
@@ -421,10 +421,10 @@ var LibraryEGL = {
     if (EGL.stringCache[name]) return EGL.stringCache[name];
     var ret;
     switch(name) {
-      case 0x3053 /* EGL_VENDOR */: ret = allocate(intArrayFromString("Emscripten"), 'i8', ALLOC_NORMAL);
-      case 0x3054 /* EGL_VERSION */: ret = allocate(intArrayFromString("1.4 Emscripten EGL"), 'i8', ALLOC_NORMAL);
-      case 0x3055 /* EGL_EXTENSIONS */:  ret = allocate(intArrayFromString(""), 'i8', ALLOC_NORMAL); // Currently not supporting any EGL extensions.
-      case 0x308D /* EGL_CLIENT_APIS */: ret = allocate(intArrayFromString("OpenGL_ES"), 'i8', ALLOC_NORMAL);
+      case 0x3053 /* EGL_VENDOR */: ret = allocate(intArrayFromString("Emscripten"), 'i8', ALLOC_NORMAL); break;
+      case 0x3054 /* EGL_VERSION */: ret = allocate(intArrayFromString("1.4 Emscripten EGL"), 'i8', ALLOC_NORMAL); break;
+      case 0x3055 /* EGL_EXTENSIONS */:  ret = allocate(intArrayFromString(""), 'i8', ALLOC_NORMAL); break; // Currently not supporting any EGL extensions.
+      case 0x308D /* EGL_CLIENT_APIS */: ret = allocate(intArrayFromString("OpenGL_ES"), 'i8', ALLOC_NORMAL); break;
       default:
         EGL.setErrorCode(0x300C /* EGL_BAD_PARAMETER */);
         return 0;
diff --git a/src/library_gl.js b/src/library_gl.js
index cfdd800dea12d..544a33db07c1c 100644
--- a/src/library_gl.js
+++ b/src/library_gl.js
@@ -506,6 +506,7 @@ var LibraryGL = {
       case 0x1F01 /* GL_RENDERER */:
       case 0x1F02 /* GL_VERSION */:
         ret = allocate(intArrayFromString(Module.ctx.getParameter(name_)), 'i8', ALLOC_NORMAL);
+        break;
       case 0x1F03 /* GL_EXTENSIONS */:
         var exts = Module.ctx.getSupportedExtensions();
         var gl_exts = [];
@@ -514,8 +515,10 @@ var LibraryGL = {
           gl_exts.push("GL_" + exts[i]);
         }
         ret = allocate(intArrayFromString(gl_exts.join(' ')), 'i8', ALLOC_NORMAL);
+        break;
       case 0x8B8C /* GL_SHADING_LANGUAGE_VERSION */:
         ret = allocate(intArrayFromString('OpenGL ES GLSL 1.00 (WebGL)'), 'i8', ALLOC_NORMAL);
+        break;
       default:
         throw 'Failure: Invalid glGetString value: ' + name_;
     }
@@ -1800,13 +1803,16 @@ var LibraryGL = {
 
       var glGetString = _glGetString;
       _glGetString = function(name_) {
+        if (GL.stringCache[name_]) return GL.stringCache[name_];
         switch(name_) {
           case 0x1F03 /* GL_EXTENSIONS */: // Add various extensions that we can support
-            return allocate(intArrayFromString(Module.ctx.getSupportedExtensions().join(' ') +
+            var ret = allocate(intArrayFromString(Module.ctx.getSupportedExtensions().join(' ') +
                    ' GL_EXT_texture_env_combine GL_ARB_texture_env_crossbar GL_ATI_texture_env_combine3 GL_NV_texture_env_combine4 GL_EXT_texture_env_dot3 GL_ARB_multitexture GL_ARB_vertex_buffer_object GL_EXT_framebuffer_object GL_ARB_vertex_program GL_ARB_fragment_program GL_ARB_shading_language_100 GL_ARB_shader_objects GL_ARB_vertex_shader GL_ARB_fragment_shader GL_ARB_texture_cube_map GL_EXT_draw_range_elements' +
                    (GL.compressionExt ? ' GL_ARB_texture_compression GL_EXT_texture_compression_s3tc' : '') +
                    (GL.anisotropicExt ? ' GL_EXT_texture_filter_anisotropic' : '')
             ), 'i8', ALLOC_NORMAL);
+            GL.stringCache[name_] = ret;
+            return ret;
         }
         return glGetString(name_);
       };
diff --git a/tests/aniso.c b/tests/aniso.c
index e8d7bd3fa1374..f1674cad24952 100644
--- a/tests/aniso.c
+++ b/tests/aniso.c
@@ -66,6 +66,9 @@ int main(int argc, char *argv[])
     const char *exts = (const char *)glGetString(GL_EXTENSIONS);
     assert(hasext(exts, "GL_EXT_texture_filter_anisotropic"));
 
+    const char *vendor = (const char *)glGetString(GL_VENDOR);
+    printf("vendor: %s\n", vendor);
+
     GLint aniso;
     glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &aniso);
     printf("Max anisotropy: %d (using that)\n", aniso);

From 2aa4f47666aa63bcad5c9ad1af626ec0d3d28dce Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 28 Oct 2013 17:51:07 -0700
Subject: [PATCH 39/93] small whitespace style fix

---
 src/library.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/library.js b/src/library.js
index 2b183ea179ff8..a2d3244e38c1a 100644
--- a/src/library.js
+++ b/src/library.js
@@ -1745,7 +1745,7 @@ LibraryManager.library = {
             type == 'F' || type == 'E' || type == 'G') {
           var last = 0;
           next = get();
-          while ( next > 0 && (!(next in __scanString.whiteSpace)) )  {
+          while (next > 0 && (!(next in __scanString.whiteSpace)))  {
             buffer.push(String.fromCharCode(next));
             if (__isFloat(buffer.join(''))) {
               last = buffer.length;

From 7c354898f5ba3db8f5eec12115a929db16ed0ac8 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 29 Oct 2013 11:02:58 -0700
Subject: [PATCH 40/93] put assertions in performance-sensitive code behind
 ASSERTIONS flag

---
 src/library_gl.js    | 42 +++++++++++++++++++++++++++++++++++++-----
 src/library_memfs.js |  2 ++
 2 files changed, 39 insertions(+), 5 deletions(-)

diff --git a/src/library_gl.js b/src/library_gl.js
index 544a33db07c1c..6f145e91e03e3 100644
--- a/src/library_gl.js
+++ b/src/library_gl.js
@@ -242,7 +242,9 @@ var LibraryGL = {
           sizePerPixel = 2;
           break;
         case 0x1406 /* GL_FLOAT */:
+#if ASSERTIONS
           assert(GL.floatExt, 'Must have OES_texture_float to use float textures');
+#endif
           switch (format) {
             case 0x1907 /* GL_RGB */:
               sizePerPixel = 3*4;
@@ -689,7 +691,9 @@ var LibraryGL = {
 
   glCompressedTexImage2D__sig: 'viiiiiiii',
   glCompressedTexImage2D: function(target, level, internalFormat, width, height, border, imageSize, data) {
+#if ASSERTIONS
     assert(GL.compressionExt);
+#endif
     if (data) {
       data = {{{ makeHEAPView('U8', 'data', 'data+imageSize') }}};
     } else {
@@ -700,7 +704,9 @@ var LibraryGL = {
 
   glCompressedTexSubImage2D__sig: 'viiiiiiiii',
   glCompressedTexSubImage2D: function(target, level, xoffset, yoffset, width, height, format, imageSize, data) {
+#if ASSERTIONS
     assert(GL.compressionExt);
+#endif
     if (data) {
       data = {{{ makeHEAPView('U8', 'data', 'data+imageSize') }}};
     } else {
@@ -734,7 +740,9 @@ var LibraryGL = {
 
   glReadPixels__sig: 'viiiiiii',
   glReadPixels: function(x, y, width, height, format, type, pixels) {
+#if ASSERTIONS
     assert(type == 0x1401 /* GL_UNSIGNED_BYTE */);
+#endif
     var sizePerPixel;
     switch (format) {
       case 0x1907 /* GL_RGB */:
@@ -1366,7 +1374,9 @@ var LibraryGL = {
     {{{ makeSetValue('count', '0', 'len', 'i32') }}};
     for (var i = 0; i < len; ++i) {
       var id = GL.shaders.indexOf(result[i]);
+#if ASSERTIONS
       assert(id !== -1, 'shader not bound to local id');
+#endif
       {{{ makeSetValue('shaders', 'i*4', 'id', 'i32') }}};
     }
   },
@@ -2025,7 +2035,9 @@ var LibraryGL = {
         glBindBuffer(target, buffer);
         if (target == Module.ctx.ARRAY_BUFFER) {
           if (GLEmulation.currentVao) {
+#if ASSERTIONS
             assert(GLEmulation.currentVao.arrayBuffer == buffer || GLEmulation.currentVao.arrayBuffer == 0 || buffer == 0, 'TODO: support for multiple array buffers in vao');
+#endif
             GLEmulation.currentVao.arrayBuffer = buffer;
           }
         } else if (target == Module.ctx.ELEMENT_ARRAY_BUFFER) {
@@ -2165,7 +2177,9 @@ var LibraryGL = {
 
   glBindProgram__sig: 'vii',
   glBindProgram: function(type, id) {
+#if ASSERTIONS
     assert(id == 0);
+#endif
   },
 
   glGetPointerv: function(name, p) {
@@ -2844,9 +2858,9 @@ var LibraryGL = {
           } else if (gl) {
             maxTexUnits = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
           }
-
+#if ASSERTIONS
           assert(maxTexUnits > 0);
-
+#endif
           s_texUnits = [];
           for (var i = 0; i < maxTexUnits; i++) {
             s_texUnits.push(new CTexUnit());
@@ -2905,9 +2919,10 @@ var LibraryGL = {
         },
 
         getTexUnitType: function(texUnitID) {
+#if ASSERTIONS
           assert(texUnitID >= 0 &&
                  texUnitID < s_texUnits.length);
-
+#endif
           return s_texUnits[texUnitID].getTexType();
         },
 
@@ -3210,9 +3225,11 @@ var LibraryGL = {
         if (!GL.immediate.enabledClientAttributes[texAttribName])
           continue;
 
+#if ASSERTIONS
         if (!useCurrProgram) {
           assert(GL.immediate.TexEnvJIT.getTexUnitType(i) != 0, "GL_TEXTURE" + i + " coords are supplied, but that texture unit is disabled in the fixed-function pipeline.");
         }
+#endif
 
         textureSizes[i] = GL.immediate.clientAttributes[texAttribName].size;
         textureTypes[i] = GL.immediate.clientAttributes[texAttribName].type;
@@ -3429,7 +3446,9 @@ var LibraryGL = {
           if (!GL.currArrayBuffer) {
             var start = GL.immediate.firstVertex*GL.immediate.stride;
             var end = GL.immediate.lastVertex*GL.immediate.stride;
+#if ASSERTIONS
             assert(end <= GL.MAX_TEMP_BUFFER_SIZE, 'too much vertex data');
+#endif
             arrayBuffer = GL.tempVertexBuffers[GL.tempBufferIndexLookup[end]];
             // TODO: consider using the last buffer we bound, if it was larger. downside is larger buffer, but we might avoid rebinding and preparing
           } else {
@@ -3598,10 +3617,10 @@ var LibraryGL = {
           Module.ctx.drawElements(mode, count, type, indices);
           return;
         }
+#if ASSERTIONS
         if (!GL.currElementArrayBuffer) {
           assert(type == Module.ctx.UNSIGNED_SHORT); // We can only emulate buffers of this kind, for now
         }
-#if ASSERTIONS
         console.log("DrawElements doesn't actually prepareClientAttributes properly.");
 #endif
         GL.immediate.prepareClientAttributes(count, false);
@@ -3809,13 +3828,17 @@ var LibraryGL = {
           if (!attribute) break;
           attribute.offset = attribute.pointer - start;
           if (attribute.offset > bytes) { // ensure we start where we should
+#if ASSERTIONS
             assert((attribute.offset - bytes)%4 == 0); // XXX assuming 4-alignment
+#endif
             bytes += attribute.offset - bytes;
           }
           bytes += attribute.size * GL.byteSizeByType[attribute.type - GL.byteSizeByTypeRoot];
           if (bytes % 4 != 0) bytes += 4 - (bytes % 4); // XXX assuming 4-alignment
         }
+#if ASSERTIONS
         assert(beginEnd || bytes <= stride); // if not begin-end, explicit stride should make sense with total byte size
+#endif
         if (bytes < stride) { // ensure the size is that of the stride
           bytes = stride;
         }
@@ -3842,18 +3865,21 @@ var LibraryGL = {
 
       // Generate index data in a format suitable for GLES 2.0/WebGL
       var numVertexes = 4 * this.vertexCounter / GL.immediate.stride;
+#if ASSERTIONS
       assert(numVertexes % 1 == 0, "`numVertexes` must be an integer.");
-
+#endif
       var emulatedElementArrayBuffer = false;
       var numIndexes = 0;
       if (numProvidedIndexes) {
         numIndexes = numProvidedIndexes;
         if (!GL.currArrayBuffer && GL.immediate.firstVertex > GL.immediate.lastVertex) {
           // Figure out the first and last vertex from the index data
+#if ASSERTIONS
           assert(!GL.currElementArrayBuffer); // If we are going to upload array buffer data, we need to find which range to
                                               // upload based on the indices. If they are in a buffer on the GPU, that is very
                                               // inconvenient! So if you do not have an array buffer, you should also not have
                                               // an element array buffer. But best is to use both buffers!
+#endif
           for (var i = 0; i < numProvidedIndexes; i++) {
             var currIndex = {{{ makeGetValue('ptr', 'i*2', 'i16', null, 1) }}};
             GL.immediate.firstVertex = Math.min(GL.immediate.firstVertex, currIndex);
@@ -3862,7 +3888,9 @@ var LibraryGL = {
         }
         if (!GL.currElementArrayBuffer) {
           // If no element array buffer is bound, then indices is a literal pointer to clientside data
+#if ASSERTIONS
           assert(numProvidedIndexes << 1 <= GL.MAX_TEMP_BUFFER_SIZE, 'too many immediate mode indexes (a)');
+#endif
           var indexBuffer = GL.tempIndexBuffers[GL.tempBufferIndexLookup[numProvidedIndexes << 1]];
           Module.ctx.bindBuffer(Module.ctx.ELEMENT_ARRAY_BUFFER, indexBuffer);
           Module.ctx.bufferSubData(Module.ctx.ELEMENT_ARRAY_BUFFER, 0, {{{ makeHEAPView('U16', 'ptr', 'ptr + (numProvidedIndexes << 1)') }}});
@@ -3874,11 +3902,15 @@ var LibraryGL = {
         // GL.immediate.firstVertex is the first vertex we want. Quad indexes are in the pattern
         // 0 1 2, 0 2 3, 4 5 6, 4 6 7, so we need to look at index firstVertex * 1.5 to see it.
         // Then since indexes are 2 bytes each, that means 3
+#if ASSERTIONS
         assert(GL.immediate.firstVertex % 4 == 0);
+#endif
         ptr = GL.immediate.firstVertex*3;
         var numQuads = numVertexes / 4;
         numIndexes = numQuads * 6; // 0 1 2, 0 2 3 pattern
+#if ASSERTIONS
         assert(ptr + (numIndexes << 1) <= GL.MAX_TEMP_BUFFER_SIZE, 'too many immediate mode indexes (b)');
+#endif
         Module.ctx.bindBuffer(Module.ctx.ELEMENT_ARRAY_BUFFER, GL.tempQuadIndexBuffer);
         emulatedElementArrayBuffer = true;
       }
diff --git a/src/library_memfs.js b/src/library_memfs.js
index 588bbabd5b0e2..9f528108c038d 100644
--- a/src/library_memfs.js
+++ b/src/library_memfs.js
@@ -222,7 +222,9 @@ mergeInto(LibraryManager.library, {
 #if USE_TYPED_ARRAYS == 2
         if (length && contents.length === 0 && position === 0 && buffer.subarray) {
           // just replace it with the new data
+#if ASSERTIONS
           assert(buffer.length);
+#endif
           if (canOwn && buffer.buffer === HEAP8.buffer && offset === 0) {
             node.contents = buffer; // this is a subarray of the heap, and we can own it
             node.contentMode = MEMFS.CONTENT_OWNING;

From 2db1ec46f5a259e03c7866374086f11af30ff7da Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 29 Oct 2013 11:28:28 -0700
Subject: [PATCH 41/93] optimize scanString to not run the regex more than once

---
 src/library.js     | 12 +++++-------
 tests/test_core.py | 12 ++++++++++++
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/src/library.js b/src/library.js
index a2d3244e38c1a..6eab2587fcd9d 100644
--- a/src/library.js
+++ b/src/library.js
@@ -1579,12 +1579,12 @@ LibraryManager.library = {
   // stdio.h
   // ==========================================================================
 
-  _isFloat: function(text) {
-    return !!(/^[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?$/.exec(text));
+  _getFloat: function(text) {
+    return /^[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?/.exec(text);
   },
 
   // TODO: Document.
-  _scanString__deps: ['_isFloat'],
+  _scanString__deps: ['_getFloat'],
   _scanString: function(format, get, unget, varargs) {
     if (!__scanString.whiteSpace) {
       __scanString.whiteSpace = {};
@@ -1743,15 +1743,13 @@ LibraryManager.library = {
         // Read characters according to the format. floats are trickier, they may be in an unfloat state in the middle, then be a valid float later
         if (type == 'f' || type == 'e' || type == 'g' ||
             type == 'F' || type == 'E' || type == 'G') {
-          var last = 0;
           next = get();
           while (next > 0 && (!(next in __scanString.whiteSpace)))  {
             buffer.push(String.fromCharCode(next));
-            if (__isFloat(buffer.join(''))) {
-              last = buffer.length;
-            }
             next = get();
           }
+          var m = __getFloat(buffer.join(''));
+          var last = m ? m[0].length : 0;
           for (var i = 0; i < buffer.length - last + 1; i++) {
             unget();
           }
diff --git a/tests/test_core.py b/tests/test_core.py
index b766ac7447989..189da2bc71b60 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -7285,6 +7285,18 @@ def test_sscanf_hex(self):
     '''
     self.do_run(src, '4779 4779')
 
+  def test_sscanf_float(self):
+    src = r'''
+      #include "stdio.h"
+
+      int main(){
+        float f1, f2, f3, f4, f5, f6, f7, f8, f9;
+        sscanf("0.512 0.250x5.129_-9.98 1.12*+54.32E3 +54.32E3^87.5E-3 87.5E-3$", "%f %fx%f_%f %f*%f %f^%f %f$", &f1, &f2, &f3, &f4, &f5, &f6, &f7, &f8, &f9);
+        printf("\n%f, %f, %f, %f, %f, %f, %f, %f, %f\n", f1, f2, f3, f4, f5, f6, f7, f8, f9);
+      }
+    '''
+    self.do_run(src, '\n0.512000, 0.250000, 5.129000, -9.980000, 1.120000, 54320.000000, 54320.000000, 0.087500, 0.087500\n')
+
   def test_langinfo(self):
     src = open(path_from_root('tests', 'langinfo', 'test.c'), 'r').read()
     expected = open(path_from_root('tests', 'langinfo', 'output.txt'), 'r').read()

From 7be5a908230091693fc68514ccef7dfb6bb65896 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 29 Oct 2013 12:30:30 -0700
Subject: [PATCH 42/93] bump js minifier name limit, and optimize to not create
 all the names on smaller inputs

---
 tools/js_optimizer.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tools/js_optimizer.py b/tools/js_optimizer.py
index d6f8921c9bb21..dcc9cd5f825a0 100644
--- a/tools/js_optimizer.py
+++ b/tools/js_optimizer.py
@@ -29,13 +29,13 @@ class Minifier:
     during registerize perform minification of locals.
   '''
 
-  def __init__(self, js, js_engine):
+  def __init__(self, js, js_engine, MAX_NAMES):
     self.js = js
     self.js_engine = js_engine
+    MAX_NAMES = min(MAX_NAMES, 120000)
 
     # Create list of valid short names
 
-    MAX_NAMES = 80000
     INVALID_2 = set(['do', 'if', 'in'])
     INVALID_3 = set(['for', 'new', 'try', 'var', 'env', 'let'])
 
@@ -56,7 +56,6 @@ def __init__(self, js, js_engine):
           if len(self.names) >= MAX_NAMES: break
           curr = a + b + c
           if curr not in INVALID_3: self.names.append(curr)
-    #print >> sys.stderr, self.names
 
   def minify_shell(self, shell, minify_whitespace, source_map=False):
     #print >> sys.stderr, "MINIFY SHELL 1111111111", shell, "\n222222222222222"
@@ -187,7 +186,8 @@ def process(line):
 ''' + js[end_funcs + len(end_funcs_marker):end_asm + len(end_asm_marker)]
       js = js[start_funcs + len(start_funcs_marker):end_funcs]
 
-      minifier = Minifier(js, js_engine)
+      # we assume there is a maximum of one new name per line
+      minifier = Minifier(js, js_engine, js.count('\n') + asm_shell.count('\n'))
       asm_shell_pre, asm_shell_post = minifier.minify_shell(asm_shell, 'minifyWhitespace' in passes, source_map).split('EMSCRIPTEN_FUNCS();');
       asm_shell_post = asm_shell_post.replace('});', '})');
       pre += asm_shell_pre + '\n' + start_funcs_marker

From e37d142969386b92616383cf8616e3ca2d92c3af Mon Sep 17 00:00:00 2001
From: Fraser Adams <fraser.adams@blueyonder.co.uk>
Date: Tue, 29 Oct 2013 20:53:51 +0000
Subject: [PATCH 43/93] updated library_sockfs.js to make WebSocket a local var
 and updated library_browser.js to modify requestAnimationFrame to provide a
 fallback to setTimeout if window is undefined

---
 src/library_browser.js | 26 +++++++++++++-------------
 src/library_sockfs.js  |  2 +-
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/library_browser.js b/src/library_browser.js
index 5ec02eeea2f41..0d5bf6dbf5531 100644
--- a/src/library_browser.js
+++ b/src/library_browser.js
@@ -360,15 +360,19 @@ mergeInto(LibraryManager.library, {
     },
 
     requestAnimationFrame: function(func) {
-      if (!window.requestAnimationFrame) {
-        window.requestAnimationFrame = window['requestAnimationFrame'] ||
-                                       window['mozRequestAnimationFrame'] ||
-                                       window['webkitRequestAnimationFrame'] ||
-                                       window['msRequestAnimationFrame'] ||
-                                       window['oRequestAnimationFrame'] ||
-                                       window['setTimeout'];
+      if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
+        setTimeout(func, 1000/60);
+      } else {
+        if (!window.requestAnimationFrame) {
+          window.requestAnimationFrame = window['requestAnimationFrame'] ||
+                                         window['mozRequestAnimationFrame'] ||
+                                         window['webkitRequestAnimationFrame'] ||
+                                         window['msRequestAnimationFrame'] ||
+                                         window['oRequestAnimationFrame'] ||
+                                         window['setTimeout'];
+        }
+        window.requestAnimationFrame(func);
       }
-      window.requestAnimationFrame(func);
     },
 
     // generic abort-aware wrapper for an async callback
@@ -782,11 +786,7 @@ mergeInto(LibraryManager.library, {
       }
     } else {
       Browser.mainLoop.scheduler = function() {
-        if (typeof window === 'undefined') { // requestAnimationFrame will fail if window is undefined (e.g. in Node.js)
-          setTimeout(Browser.mainLoop.runner, 1000/60);
-        } else {
-          Browser.requestAnimationFrame(Browser.mainLoop.runner);
-        }
+        Browser.requestAnimationFrame(Browser.mainLoop.runner);
       }
     }
     Browser.mainLoop.scheduler();
diff --git a/src/library_sockfs.js b/src/library_sockfs.js
index 0e083bfde9f20..c79661d897620 100644
--- a/src/library_sockfs.js
+++ b/src/library_sockfs.js
@@ -140,7 +140,7 @@ mergeInto(LibraryManager.library, {
             // the node ws library API is slightly different than the browser's
             var opts = ENVIRONMENT_IS_NODE ? {headers: {'websocket-protocol': ['binary']}} : ['binary'];
             // If node we use the ws library.
-            WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : WebSocket;
+            var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window.WebSocket;
             ws = new WebSocket(url, opts);
             ws.binaryType = 'arraybuffer';
           } catch (e) {

From 4af62232d03bd71db0f1ec907ff2a52ecef2f5d9 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 29 Oct 2013 17:17:52 -0700
Subject: [PATCH 44/93] handle vector types in calcAllocatedSize

---
 src/parseTools.js | 8 +++-----
 src/runtime.js    | 4 +++-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/parseTools.js b/src/parseTools.js
index dae386f179a57..223adbbfa6e6c 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -1009,11 +1009,9 @@ function getOldLabel(label) {
 }
 
 function calcAllocatedSize(type) {
-  if (pointingLevels(type) == 0 && isStructType(type)) {
-    return Types.types[type].flatSize; // makeEmptyStruct(item.allocatedType).length;
-  } else {
-    return Runtime.getNativeTypeSize(type); // We can really get away with '1', though, at least on the stack...
-  }
+  var ret = Runtime.getNativeTypeSize(type);
+  if (ret) return ret;
+  return Types.types[type].flatSize; // known type
 }
 
 // Generates the type signature for a structure, for each byte, the type that is there.
diff --git a/src/runtime.js b/src/runtime.js
index 5d5cb43b47783..ca2304daf90e5 100644
--- a/src/runtime.js
+++ b/src/runtime.js
@@ -145,7 +145,7 @@ var Runtime = {
   //! @param type The type, by name.
   getNativeTypeSize: function(type) {
 #if QUANTUM_SIZE == 1
-     return 1;
+    return 1;
 #else
     switch (type) {
       case 'i1': case 'i8': return 1;
@@ -161,6 +161,8 @@ var Runtime = {
           var bits = parseInt(type.substr(1));
           assert(bits % 8 === 0);
           return bits/8;
+        } else {
+          return 0;
         }
       }
     }

From c45cd7c72a019f54b0f6ee873641200ecb043a25 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 29 Oct 2013 17:58:09 -0700
Subject: [PATCH 45/93] clean up simd code, fix uint32x4 heap offsets, and add
 testing

---
 src/jsifier.js      | 22 ++++++++++++----------
 src/parseTools.js   | 21 +++++++++++----------
 tests/test_other.py | 39 ++++++++++++++++++++++++++++-----------
 3 files changed, 51 insertions(+), 31 deletions(-)

diff --git a/src/jsifier.js b/src/jsifier.js
index b36e11ed0d3cb..ec7ad1c2ce6f8 100644
--- a/src/jsifier.js
+++ b/src/jsifier.js
@@ -948,11 +948,12 @@ function JSify(data, functionsOnly, givenFunctions) {
     }
     if (item.valueType[item.valueType.length-1] === '>') {
       // vector store TODO: move to makeSetValue?
-      var base = getVectorBaseType(item.valueType);
-      return '(' + makeSetValue(item.ident,  0, value + '.x', base, 0, 0, item.align) + ',' +
-                   makeSetValue(item.ident,  4, value + '.y', base, 0, 0, item.align) + ',' +
-                   makeSetValue(item.ident,  8, value + '.z', base, 0, 0, item.align) + ',' +
-                   makeSetValue(item.ident, 12, value + '.w', base, 0, 0, item.align) + ')';
+      var native = getVectorNativeType(item.valueType);
+      var base = getSIMDName(native);
+      return '(' + makeSetValue(item.ident,  0, value + '.x', native, 0, 0, item.align) + ',' +
+                   makeSetValue(item.ident,  4, value + '.y', native, 0, 0, item.align) + ',' +
+                   makeSetValue(item.ident,  8, value + '.z', native, 0, 0, item.align) + ',' +
+                   makeSetValue(item.ident, 12, value + '.w', native, 0, 0, item.align) + ')';
     }
     switch (impl) {
       case VAR_NATIVIZED:
@@ -1323,11 +1324,12 @@ function JSify(data, functionsOnly, givenFunctions) {
     var value = finalizeLLVMParameter(item.pointer);
     if (item.valueType[item.valueType.length-1] === '>') {
       // vector load
-      var base = getVectorBaseType(item.valueType);
-      return base + '32x4(' + makeGetValue(value,  0, base, 0, item.unsigned, 0, item.align) + ',' +
-                              makeGetValue(value,  4, base, 0, item.unsigned, 0, item.align) + ',' +
-                              makeGetValue(value,  8, base, 0, item.unsigned, 0, item.align) + ',' +
-                              makeGetValue(value, 12, base, 0, item.unsigned, 0, item.align) + ')';
+      var native = getVectorNativeType(item.valueType);
+      var base = getSIMDName(native);
+      return base + '32x4(' + makeGetValue(value,  0, native, 0, item.unsigned, 0, item.align) + ',' +
+                              makeGetValue(value,  4, native, 0, item.unsigned, 0, item.align) + ',' +
+                              makeGetValue(value,  8, native, 0, item.unsigned, 0, item.align) + ',' +
+                              makeGetValue(value, 12, native, 0, item.unsigned, 0, item.align) + ')';
     }
     var impl = item.ident ? getVarImpl(item.funcData, item.ident) : VAR_EMULATED;
     switch (impl) {
diff --git a/src/parseTools.js b/src/parseTools.js
index 223adbbfa6e6c..16f4058c6fa24 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -328,28 +328,29 @@ function getVectorSize(type) {
   return parseInt(type.substring(1, type.indexOf(' ')));
 }
 
-function getVectorBaseType(type) {
+function getVectorNativeType(type) {
   Types.usesSIMD = true;
   switch (type) {
     case '<2 x float>':
     case '<4 x float>': return 'float';
     case '<2 x i32>':
-    case '<4 x i32>': return 'uint';
+    case '<4 x i32>': return 'i32';
     default: throw 'unknown vector type ' + type;
   }
 }
 
-function getVectorNativeType(type) {
-  Types.usesSIMD = true;
+function getSIMDName(type) {
   switch (type) {
-    case '<2 x float>':
-    case '<4 x float>': return 'float';
-    case '<2 x i32>':
-    case '<4 x i32>': return 'i32';
-    default: throw 'unknown vector type ' + type;
+    case 'i32': return 'uint';
+    case 'float': return 'float';
+    default: throw 'getSIMDName ' + type;
   }
 }
 
+function getVectorBaseType(type) {
+  return getSIMDName(getVectorNativeType(type));
+}
+
 function addIdent(token) {
   token.ident = token.text;
   return token;
@@ -1807,7 +1808,7 @@ function makeGetSlabs(ptr, type, allowMultiple, unsigned) {
     switch(type) {
       case 'i1': case 'i8': return [unsigned ? 'HEAPU8' : 'HEAP8']; break;
       case 'i16': return [unsigned ? 'HEAPU16' : 'HEAP16']; break;
-      case '<4 x i32>': case 'uint':
+      case '<4 x i32>':
       case 'i32': case 'i64': return [unsigned ? 'HEAPU32' : 'HEAP32']; break;
       case 'double': {
         if (TARGET_LE32) return ['HEAPF64']; // in le32, we do have the ability to assume 64-bit alignment
diff --git a/tests/test_other.py b/tests/test_other.py
index e251da5deac77..185e83d1deb0d 100644
--- a/tests/test_other.py
+++ b/tests/test_other.py
@@ -2022,6 +2022,12 @@ def test_simd2(self):
 
 #include <emscripten/vector.h>
 
+static inline float32x4 __attribute__((always_inline))
+_mm_set_ps(const float __Z, const float __Y, const float __X, const float __W)
+{
+  return (float32x4){ __W, __X, __Y, __Z };
+}
+
 int main(int argc, char **argv) {
   float data[8];
   for (int i = 0; i < 32; i++) data[i] = (1+i+argc)*(2+i+argc*argc);
@@ -2031,11 +2037,11 @@ def test_simd2(self):
     float32x4 c, d;
     c = *a;
     d = *b;
-    printf("floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
+    printf("1floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
     c = c+d;
-    printf("floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
+    printf("2floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
     d = c*d;
-    printf("floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
+    printf("3floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
   }
   {
     uint32x4 *a = (uint32x4*)&data[0];
@@ -2043,19 +2049,30 @@ def test_simd2(self):
     uint32x4 c, d, e, f;
     c = *a;
     d = *b;
-    printf("uints! %d, %d, %d, %d   %d, %d, %d, %d\n", c[0], c[1], c[2], c[3], d[0], d[1], d[2], d[3]);
+    printf("4uints! %d, %d, %d, %d   %d, %d, %d, %d\n", c[0], c[1], c[2], c[3], d[0], d[1], d[2], d[3]);
     e = c+d;
     f = c-d;
-    printf("uints! %d, %d, %d, %d   %d, %d, %d, %d\n", e[0], e[1], e[2], e[3], f[0], f[1], f[2], f[3]);
+    printf("5uints! %d, %d, %d, %d   %d, %d, %d, %d\n", e[0], e[1], e[2], e[3], f[0], f[1], f[2], f[3]);
+  }
+  {
+    float32x4 c, d, e, f;
+    c = _mm_set_ps(9.0, 4.0, 0, -9.0);
+    d = _mm_set_ps(10.0, 14.0, -12, -2.0);
+    printf("6floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
   }
+
   return 0;
 }
     ''')
-    Popen([PYTHON, EMCC, 'src.cpp', '-O2']).communicate()
-    self.assertContained('''floats! 6, 12, 20, 30   42, 56, 72, 90
-floats! 48, 68, 92, 120   42, 56, 72, 90
-floats! 48, 68, 92, 120   2016, 3808, 6624, 10800
-uints! 1086324736, 1094713344, 1101004800, 1106247680   1109917696, 1113587712, 1116733440, 1119092736
-uints! -2098724864, -2086666240, -2077229056, -2069626880   -23592960, -18874368, -15728640, -12845056
+
+    for opts in [[], ['-O1'], ['-O2']]:
+      print opts
+      Popen([PYTHON, EMCC, 'src.cpp'] + opts).communicate()
+      self.assertContained('''1floats! 6, 12, 20, 30   42, 56, 72, 90
+2floats! 48, 68, 92, 120   42, 56, 72, 90
+3floats! 48, 68, 92, 120   2016, 3808, 6624, 10800
+4uints! 1086324736, 1094713344, 1101004800, 1106247680   1109917696, 1113587712, 1116733440, 1119092736
+5uints! -2098724864, -2086666240, -2077229056, -2069626880   -23592960, -18874368, -15728640, -12845056
+6floats! -9, 0, 4, 9   -2, -12, 14, 10
 ''', run_js('a.out.js'))
 

From 2247ff845fa862a35fc9d1acf8150eb7e56f41ac Mon Sep 17 00:00:00 2001
From: Aleksander Guryanov <caiiiycuk@gmail.com>
Date: Wed, 30 Oct 2013 18:18:29 +0700
Subject: [PATCH 46/93] Fix SDL_SetColors && SDL_envets

---
 src/library_sdl.js              | 8 ++++----
 system/include/SDL/SDL_events.h | 1 +
 tests/sdl_canvas_palette.c      | 2 +-
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/library_sdl.js b/src/library_sdl.js
index e652dfc879284..024f0c3551be3 100644
--- a/src/library_sdl.js
+++ b/src/library_sdl.js
@@ -1231,11 +1231,11 @@ var LibrarySDL = {
       surfData.colors = new Uint8Array(256 * 3); //256 RGB colors
     } 
 
-    for (var i = firstColor; i < firstColor + nColors; i++) {
-      var index = i *3;
+    for (var i = 0; i < nColors; ++i) {
+      var index = (firstColor + i) * 3;
       surfData.colors[index] = {{{ makeGetValue('colors', 'i*4', 'i8', null, true) }}};
-      surfData.colors[index +1] = {{{ makeGetValue('colors', 'i*4 +1', 'i8', null, true) }}};
-      surfData.colors[index +2] = {{{ makeGetValue('colors', 'i*4 +2', 'i8', null, true) }}};
+      surfData.colors[index + 1] = {{{ makeGetValue('colors', 'i*4 + 1', 'i8', null, true) }}};
+      surfData.colors[index + 2] = {{{ makeGetValue('colors', 'i*4 + 2', 'i8', null, true) }}};
     }
 
     return 1;
diff --git a/system/include/SDL/SDL_events.h b/system/include/SDL/SDL_events.h
index 804ac57e7edca..8be00ceb32b64 100644
--- a/system/include/SDL/SDL_events.h
+++ b/system/include/SDL/SDL_events.h
@@ -55,6 +55,7 @@ extern "C" {
  */
 typedef enum
 {
+    SDL_NOEVENT        = 0,
     SDL_FIRSTEVENT     = 0,     /**< Unused (do not remove) */
 
     /* Application events */
diff --git a/tests/sdl_canvas_palette.c b/tests/sdl_canvas_palette.c
index 316aa44a6eb6c..361f71a6dd155 100644
--- a/tests/sdl_canvas_palette.c
+++ b/tests/sdl_canvas_palette.c
@@ -42,7 +42,7 @@ int main() {
   //changing green color
   //to yellow
   pal[1].r = 255;
-  SDL_SetColors(screen, pal, 1, 1);
+  SDL_SetColors(screen, &pal[1], 1, 1);
 
   {
     SDL_Rect rect = { 300, 200, 300, 200 };

From 82c96614ab469777da35013e698fa0c8873c231e Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 10:27:02 -0700
Subject: [PATCH 47/93] fix missing semicolons on simd load and store

---
 src/jsifier.js     |  4 ++--
 tests/test_core.py | 47 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 49 insertions(+), 2 deletions(-)

diff --git a/src/jsifier.js b/src/jsifier.js
index ec7ad1c2ce6f8..adcb38eef6f81 100644
--- a/src/jsifier.js
+++ b/src/jsifier.js
@@ -953,7 +953,7 @@ function JSify(data, functionsOnly, givenFunctions) {
       return '(' + makeSetValue(item.ident,  0, value + '.x', native, 0, 0, item.align) + ',' +
                    makeSetValue(item.ident,  4, value + '.y', native, 0, 0, item.align) + ',' +
                    makeSetValue(item.ident,  8, value + '.z', native, 0, 0, item.align) + ',' +
-                   makeSetValue(item.ident, 12, value + '.w', native, 0, 0, item.align) + ')';
+                   makeSetValue(item.ident, 12, value + '.w', native, 0, 0, item.align) + ');';
     }
     switch (impl) {
       case VAR_NATIVIZED:
@@ -1329,7 +1329,7 @@ function JSify(data, functionsOnly, givenFunctions) {
       return base + '32x4(' + makeGetValue(value,  0, native, 0, item.unsigned, 0, item.align) + ',' +
                               makeGetValue(value,  4, native, 0, item.unsigned, 0, item.align) + ',' +
                               makeGetValue(value,  8, native, 0, item.unsigned, 0, item.align) + ',' +
-                              makeGetValue(value, 12, native, 0, item.unsigned, 0, item.align) + ')';
+                              makeGetValue(value, 12, native, 0, item.unsigned, 0, item.align) + ');';
     }
     var impl = item.ident ? getVarImpl(item.funcData, item.ident) : VAR_EMULATED;
     switch (impl) {
diff --git a/tests/test_core.py b/tests/test_core.py
index 189da2bc71b60..bed451dd0bd54 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -8660,6 +8660,53 @@ def test_cubescript(self):
       main = main[:main.find('\n}')]
       assert main.count('\n') == 7, 'must not emit too many postSets: %d' % main.count('\n')
 
+  def test_simd3(self):
+    if Settings.ASM_JS: Settings.ASM_JS = 2 # does not validate
+
+    self.do_run(r'''
+      #include <stdio.h>
+
+      typedef float __m128 __attribute__ ((__vector_size__ (16)));
+
+      static inline __m128 __attribute__((always_inline))
+      _mm_set_ps(const float __Z, const float __Y, const float __X, const float __W)
+      {
+        return (__m128){ __W, __X, __Y, __Z };
+      }
+
+      static inline void __attribute__((always_inline))
+      _mm_store_ps(float *__P, __m128 __A)
+      {
+        *(__m128 *)__P = __A;
+      }
+
+      static inline __m128 __attribute__((always_inline))
+      _mm_add_ps(__m128 __A, __m128 __B)
+      {
+        return __A + __B;
+      }
+
+      using namespace std;
+
+      int main(int argc, char ** argv) {
+          float __attribute__((__aligned__(16))) ar[4];
+          __m128 v1 = _mm_set_ps(9.0, 4.0, 0, -9.0);
+          __m128 v2 = _mm_set_ps(7.0, 3.0, 2.5, 1.0);
+          __m128 v3 = _mm_add_ps(v1, v2);
+          _mm_store_ps(ar, v3);
+          
+          for (int i = 0; i < 4; i++) {
+              printf("%f\n", ar[i]);
+          }
+          
+          return 0;
+      }
+      ''', '''-8.000000
+2.500000
+7.000000
+16.000000
+''')
+
   def test_gcc_unmangler(self):
     Settings.NAMED_GLOBALS = 1 # test coverage for this
 

From 97f20af483140174e96385f142df43d7251cfccb Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 10:33:14 -0700
Subject: [PATCH 48/93] improve simd tests

---
 tests/test_core.py  | 61 ++++++++++++++++++++++++++++++++++++++++++++-
 tests/test_other.py | 61 ---------------------------------------------
 2 files changed, 60 insertions(+), 62 deletions(-)

diff --git a/tests/test_core.py b/tests/test_core.py
index bed451dd0bd54..b421659c87b51 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -8660,7 +8660,66 @@ def test_cubescript(self):
       main = main[:main.find('\n}')]
       assert main.count('\n') == 7, 'must not emit too many postSets: %d' % main.count('\n')
 
-  def test_simd3(self):
+  def test_simd(self):
+    if Settings.USE_TYPED_ARRAYS != 2: return self.skip('needs ta2')
+    if Settings.ASM_JS: Settings.ASM_JS = 2 # does not validate
+    src = r'''
+#include <stdio.h>
+
+#include <emscripten/vector.h>
+
+static inline float32x4 __attribute__((always_inline))
+_mm_set_ps(const float __Z, const float __Y, const float __X, const float __W)
+{
+  return (float32x4){ __W, __X, __Y, __Z };
+}
+
+int main(int argc, char **argv) {
+  float data[8];
+  for (int i = 0; i < 32; i++) data[i] = (1+i+argc)*(2+i+argc*argc);
+  {
+    float32x4 *a = (float32x4*)&data[0];
+    float32x4 *b = (float32x4*)&data[4];
+    float32x4 c, d;
+    c = *a;
+    d = *b;
+    printf("1floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
+    c = c+d;
+    printf("2floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
+    d = c*d;
+    printf("3floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
+  }
+  {
+    uint32x4 *a = (uint32x4*)&data[0];
+    uint32x4 *b = (uint32x4*)&data[4];
+    uint32x4 c, d, e, f;
+    c = *a;
+    d = *b;
+    printf("4uints! %d, %d, %d, %d   %d, %d, %d, %d\n", c[0], c[1], c[2], c[3], d[0], d[1], d[2], d[3]);
+    e = c+d;
+    f = c-d;
+    printf("5uints! %d, %d, %d, %d   %d, %d, %d, %d\n", e[0], e[1], e[2], e[3], f[0], f[1], f[2], f[3]);
+  }
+  {
+    float32x4 c, d, e, f;
+    c = _mm_set_ps(9.0, 4.0, 0, -9.0);
+    d = _mm_set_ps(10.0, 14.0, -12, -2.0);
+    printf("6floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
+  }
+
+  return 0;
+}
+    '''
+
+    self.do_run(src, '''1floats! 6, 12, 20, 30   42, 56, 72, 90
+2floats! 48, 68, 92, 120   42, 56, 72, 90
+3floats! 48, 68, 92, 120   2016, 3808, 6624, 10800
+4uints! 1086324736, 1094713344, 1101004800, 1106247680   1109917696, 1113587712, 1116733440, 1119092736
+5uints! -2098724864, -2086666240, -2077229056, -2069626880   -23592960, -18874368, -15728640, -12845056
+6floats! -9, 0, 4, 9   -2, -12, 14, 10
+''')
+
+  def test_simd2(self):
     if Settings.ASM_JS: Settings.ASM_JS = 2 # does not validate
 
     self.do_run(r'''
diff --git a/tests/test_other.py b/tests/test_other.py
index 185e83d1deb0d..86e0eadfecd95 100644
--- a/tests/test_other.py
+++ b/tests/test_other.py
@@ -2015,64 +2015,3 @@ def test_simd(self):
     Popen([PYTHON, EMCC, path_from_root('tests', 'linpack.c'), '-O2', '-DSP', '--llvm-opts', '''['-O3', '-vectorize', '-vectorize-loops', '-bb-vectorize-vector-bits=128', '-force-vector-width=4']''']).communicate()
     self.assertContained('Unrolled Single  Precision', run_js('a.out.js'))
 
-  def test_simd2(self):
-    self.clear()
-    open('src.cpp', 'w').write(r'''
-#include <stdio.h>
-
-#include <emscripten/vector.h>
-
-static inline float32x4 __attribute__((always_inline))
-_mm_set_ps(const float __Z, const float __Y, const float __X, const float __W)
-{
-  return (float32x4){ __W, __X, __Y, __Z };
-}
-
-int main(int argc, char **argv) {
-  float data[8];
-  for (int i = 0; i < 32; i++) data[i] = (1+i+argc)*(2+i+argc*argc);
-  {
-    float32x4 *a = (float32x4*)&data[0];
-    float32x4 *b = (float32x4*)&data[4];
-    float32x4 c, d;
-    c = *a;
-    d = *b;
-    printf("1floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
-    c = c+d;
-    printf("2floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
-    d = c*d;
-    printf("3floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
-  }
-  {
-    uint32x4 *a = (uint32x4*)&data[0];
-    uint32x4 *b = (uint32x4*)&data[4];
-    uint32x4 c, d, e, f;
-    c = *a;
-    d = *b;
-    printf("4uints! %d, %d, %d, %d   %d, %d, %d, %d\n", c[0], c[1], c[2], c[3], d[0], d[1], d[2], d[3]);
-    e = c+d;
-    f = c-d;
-    printf("5uints! %d, %d, %d, %d   %d, %d, %d, %d\n", e[0], e[1], e[2], e[3], f[0], f[1], f[2], f[3]);
-  }
-  {
-    float32x4 c, d, e, f;
-    c = _mm_set_ps(9.0, 4.0, 0, -9.0);
-    d = _mm_set_ps(10.0, 14.0, -12, -2.0);
-    printf("6floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
-  }
-
-  return 0;
-}
-    ''')
-
-    for opts in [[], ['-O1'], ['-O2']]:
-      print opts
-      Popen([PYTHON, EMCC, 'src.cpp'] + opts).communicate()
-      self.assertContained('''1floats! 6, 12, 20, 30   42, 56, 72, 90
-2floats! 48, 68, 92, 120   42, 56, 72, 90
-3floats! 48, 68, 92, 120   2016, 3808, 6624, 10800
-4uints! 1086324736, 1094713344, 1101004800, 1106247680   1109917696, 1113587712, 1116733440, 1119092736
-5uints! -2098724864, -2086666240, -2077229056, -2069626880   -23592960, -18874368, -15728640, -12845056
-6floats! -9, 0, 4, 9   -2, -12, 14, 10
-''', run_js('a.out.js'))
-

From 70c48271202c78763fdf818111376b2e214e8c41 Mon Sep 17 00:00:00 2001
From: Fraser Adams <fraser.adams@blueyonder.co.uk>
Date: Wed, 30 Oct 2013 18:04:05 +0000
Subject: [PATCH 49/93] replace window.WebSocket with window['WebSocket'] to
 avoid closure compiler issues

---
 src/library_sockfs.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/library_sockfs.js b/src/library_sockfs.js
index c79661d897620..78fc382fbecca 100644
--- a/src/library_sockfs.js
+++ b/src/library_sockfs.js
@@ -140,7 +140,7 @@ mergeInto(LibraryManager.library, {
             // the node ws library API is slightly different than the browser's
             var opts = ENVIRONMENT_IS_NODE ? {headers: {'websocket-protocol': ['binary']}} : ['binary'];
             // If node we use the ws library.
-            var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window.WebSocket;
+            var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window['WebSocket'];
             ws = new WebSocket(url, opts);
             ws.binaryType = 'arraybuffer';
           } catch (e) {

From a4b5ac5a0b7b705d89def4fb447f36cbe04d5789 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 13:14:26 -0700
Subject: [PATCH 50/93] begin to add emscripten_float32x4_signmask

---
 src/library.js                     |  8 ++++++++
 system/include/emscripten/vector.h | 10 ++++++++++
 tests/test_core.py                 |  1 +
 3 files changed, 19 insertions(+)

diff --git a/src/library.js b/src/library.js
index 6eab2587fcd9d..bcd6d7dce1d8c 100644
--- a/src/library.js
+++ b/src/library.js
@@ -8620,6 +8620,14 @@ LibraryManager.library = {
     return func();
   },
 
+  //============================
+  // emscripten vector ops
+  //============================
+
+  emscripten_float32x4_signmask__inline: function(x) {
+    return x + '.signMask()';
+  },
+
   //============================
   // i64 math
   //============================
diff --git a/system/include/emscripten/vector.h b/system/include/emscripten/vector.h
index ea148f0d27d3f..938f23692cf99 100644
--- a/system/include/emscripten/vector.h
+++ b/system/include/emscripten/vector.h
@@ -4,3 +4,13 @@
 typedef float float32x4 __attribute__((__vector_size__(16)));
 typedef unsigned int uint32x4 __attribute__((__vector_size__(16)));
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+unsigned int emscripten_float32x4_signmask(float32x4 x);
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/tests/test_core.py b/tests/test_core.py
index b421659c87b51..6857d8034d184 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -8705,6 +8705,7 @@ def test_simd(self):
     c = _mm_set_ps(9.0, 4.0, 0, -9.0);
     d = _mm_set_ps(10.0, 14.0, -12, -2.0);
     printf("6floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
+    //printf("7calcs: %d\n", emscripten_float32x4_signmask(c));
   }
 
   return 0;

From 5182542126a5ad3c40d958b0b72cfa16f4e8bd25 Mon Sep 17 00:00:00 2001
From: Ben Noordhuis <info@bnoordhuis.nl>
Date: Tue, 29 Oct 2013 16:21:41 +0100
Subject: [PATCH 51/93] tools: parse pre-release node.js version numbers

`node` binaries built from upstream git have a "-pre" suffix attached
to the version number.  Fix the version parser to handle those.
---
 AUTHORS              | 2 +-
 tests/test_sanity.py | 6 +++++-
 tools/shared.py      | 2 +-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/AUTHORS b/AUTHORS
index 5ad3f98dc0acd..75f38f15b661c 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -104,4 +104,4 @@ a license to everyone to use it as detailed in LICENSE.)
 * Daniel Aquino <mr.danielaquino@gmail.com>
 * Remi Papillie <remi.papillie@gmail.com>
 * Fraser Adams <fraser.adams@blueyonder.co.uk>
-
+* Ben Noordhuis <info@bnoordhuis.nl>
diff --git a/tests/test_sanity.py b/tests/test_sanity.py
index a0fff252066a9..a405c3a3ed1f5 100644
--- a/tests/test_sanity.py
+++ b/tests/test_sanity.py
@@ -217,7 +217,11 @@ def test_node(self):
 
     try:
       os.environ['EM_IGNORE_SANITY'] = '1'
-      for version, succeed in [('v0.7.9', False), ('v0.8.0', True), ('v0.8.1', True), ('cheez', False)]:
+      for version, succeed in [('v0.7.9', False),
+                               ('v0.8.0', True),
+                               ('v0.8.1', True),
+                               ('v0.10.21-pre', True),
+                               ('cheez', False)]:
         f = open(path_from_root('tests', 'fake', 'nodejs'), 'w')
         f.write('#!/bin/sh\n')
         f.write('''if [ $1 = "--version" ]; then
diff --git a/tools/shared.py b/tools/shared.py
index 108a48a48087e..f6c0cc95b8637 100644
--- a/tools/shared.py
+++ b/tools/shared.py
@@ -284,7 +284,7 @@ def check_node_version():
   try:
     node = listify(NODE_JS)
     actual = Popen(node + ['--version'], stdout=PIPE).communicate()[0].strip()
-    version = tuple(map(int, actual.replace('v', '').split('.')))
+    version = tuple(map(int, actual.replace('v', '').replace('-pre', '').split('.')))
     if version >= EXPECTED_NODE_VERSION:
       return True
     logging.warning('node version appears too old (seeing "%s", expected "%s")' % (actual, 'v' + ('.'.join(map(str, EXPECTED_NODE_VERSION)))))

From 51ee6a403e82b1e38c2baebb80985590c333d5e0 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 14:36:01 -0700
Subject: [PATCH 52/93] remove stale forwarding code in intertyper

---
 src/intertyper.js | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/intertyper.js b/src/intertyper.js
index d36408892ce9f..fceeb38d92b4a 100644
--- a/src/intertyper.js
+++ b/src/intertyper.js
@@ -682,7 +682,7 @@ function intertyper(lines, sidePass, baseLineNums) {
       }
       if (item.assignTo) item.ident = 'return ' + item.ident;
       item.ident = '(function(' + params + ') { ' + item.ident + ' })(' + args + ');';
-      return { forward: null, ret: item, item: item };
+      return { ret: item, item: item };
     } 
     if (item.ident.substr(-2) == '()') {
       // See comment in isStructType()
@@ -705,13 +705,12 @@ function intertyper(lines, sidePass, baseLineNums) {
     if (item.indent == 2) {
       // standalone call - not in assign
       item.standalone = true;
-      return { forward: null, ret: item, item: item };
+      return { ret: item, item: item };
     }
-    return { forward: item, ret: null, item: item };
+    return { ret: null, item: item };
   }
   function callHandler(item) {
     var result = makeCall.call(this, item, 'call');
-    if (result.forward) this.forwardItem(result.forward, 'Reintegrator');
     return result.ret;
   }
   function invokeHandler(item) {
@@ -721,10 +720,9 @@ function intertyper(lines, sidePass, baseLineNums) {
       finalResults.push({
         intertype: 'branch',
         label: result.item.toLabel,
-        lineNum: (result.forward ? item.parentLineNum : item.lineNum) + 0.5
+        lineNum: item.lineNum + 0.5
       });
     }
-    if (result.forward) this.forwardItem(result.forward, 'Reintegrator');
     return result.ret;
   }
   function atomicHandler(item) {

From e6b20d6caaf60b3ae8c7a053154777bdbb249036 Mon Sep 17 00:00:00 2001
From: Bruce Mitchener <bruce.mitchener@gmail.com>
Date: Thu, 31 Oct 2013 06:24:10 +0700
Subject: [PATCH 53/93] Fix handling of backspace SDL scancode.

Fixes #1749.
---
 src/library_sdl.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/library_sdl.js b/src/library_sdl.js
index e652dfc879284..4620035e51807 100644
--- a/src/library_sdl.js
+++ b/src/library_sdl.js
@@ -167,6 +167,7 @@ var LibrarySDL = {
       57: 38, // 9
       48: 39, // 0
       13: 40, // return
+      8: 42, // backspace
       9: 43, // tab
       27: 41, // escape
       32: 44, // space

From 822df0890f15d2162d1cd1064fac749efcd1601c Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 16:34:46 -0700
Subject: [PATCH 54/93] fix call legalization temp types

---
 src/analyzer.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/analyzer.js b/src/analyzer.js
index 2b74a83ff0ae1..253c5505f4e32 100644
--- a/src/analyzer.js
+++ b/src/analyzer.js
@@ -418,7 +418,7 @@ function analyzer(data, sidePass) {
                     toAdd.push({
                       intertype: 'value',
                       assignTo: element.ident,
-                      type: element.bits,
+                      type: 'i' + element.bits,
                       ident: 'tempRet' + (j - 1)
                     });
                     assert(j<10); // TODO: dynamically create more than 10 tempRet-s

From 5252554297cc5fca5cc96d1d2e71da00412a0e18 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 16:37:53 -0700
Subject: [PATCH 55/93] fix tests/cases/caall.ll

---
 tests/cases/caall.ll | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/cases/caall.ll b/tests/cases/caall.ll
index 313116e69d704..5b8f7f29ad853 100644
--- a/tests/cases/caall.ll
+++ b/tests/cases/caall.ll
@@ -18,7 +18,7 @@ entry:
 define (i32*)** @_ZNSt3__13mapINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPFvP6ObjectENS_4lessIS6_EENS4_INS_4pairIKS6_SA_EEEEEixERSE_(i32 %x) {
 entry:
   %ret = inttoptr i32 0 to (i32*)**
-  ret %ret
+  ret (i32*)** %ret
 }
 
 ; [#uses=1]

From 233f79bafda245925bd39b82e45b1dfa5a75a73f Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 16:39:44 -0700
Subject: [PATCH 56/93] optimize isIllegalType

---
 src/parseTools.js | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/parseTools.js b/src/parseTools.js
index 16f4058c6fa24..314c5ffbeb08c 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -215,8 +215,22 @@ function isIdenticallyImplemented(type1, type2) {
 }
 
 function isIllegalType(type) {
-  var bits = getBits(type);
-  return bits > 0 && (bits >= 64 || !isPowerOfTwo(bits));
+  switch (type) {
+    case 'i1':
+    case 'i8':
+    case 'i16':
+    case 'i32':
+    case 'float':
+    case 'double':
+    case 'rawJS':
+    case '<2 x float>':
+    case '<4 x float>':
+    case '<2 x i32>':
+    case '<4 x i32>':
+    case 'void': return false;
+  }
+  if (!type || type[type.length-1] === '*') return false;
+  return true;
 }
 
 function isVoidType(type) {

From ec784ebc61671843c44f341c84b4c008ef0982f0 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 17:35:11 -0700
Subject: [PATCH 57/93] handle more return types in getReturnType

---
 src/parseTools.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/parseTools.js b/src/parseTools.js
index 314c5ffbeb08c..de80eb07445b1 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -301,6 +301,9 @@ function getReturnType(type) {
   if (pointingLevels(type) > 1) return '*'; // the type of a call can be either the return value, or the entire function. ** or more means it is a return value
   var lastOpen = type.lastIndexOf('(');
   if (lastOpen > 0) {
+    // handle things like   void (i32)* (i32, void (i32)*)*
+    var closeStar = type.indexOf(')*');
+    if (closeStar > 0 && closeStar < type.length-2) lastOpen = closeStar+3;
     return type.substr(0, lastOpen-1);
   }
   return type;

From 367968d73d46595522d271ffb9d003a3be0ec12d Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 16:53:35 -0700
Subject: [PATCH 58/93] make parseParamTokens use parseLLVMSegment

---
 src/parseTools.js | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/src/parseTools.js b/src/parseTools.js
index de80eb07445b1..33b389379792c 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -493,16 +493,10 @@ function parseParamTokens(params) {
       if (segment[2] && segment[2].text == 'to') { // part of bitcast params
         segment = segment.slice(0, 2);
       }
-      while (segment.length > 2) {
-        segment[0].text += segment[1].text;
-        segment.splice(1, 1); // TODO: merge tokens nicely
-      }
-      ret.push({
-        intertype: 'value',
-        type: segment[0].text,
-        ident: toNiceIdent(parseNumerical(segment[1].text, segment[0].text))
-      });
-      Types.needAnalysis[removeAllPointing(ret[ret.length-1].type)] = 0;
+      var parsed = parseLLVMSegment(segment);
+      if (parsed.intertype === 'value' && !isIllegalType(parsed.type)) parsed.ident = parseNumerical(parsed.ident);
+      ret.push(parsed);
+      Types.needAnalysis[removeAllPointing(parsed.type)] = 0;
     }
     ret[ret.length-1].byVal = byVal;
   }

From 27fc24141afdff04c44a3d7536588ed19038fb71 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 17:44:38 -0700
Subject: [PATCH 59/93] simplify parseParamTokens now that it uses
 parseLLVMSegment

---
 src/parseTools.js | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/src/parseTools.js b/src/parseTools.js
index 33b389379792c..86adaf19ae49e 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -483,12 +483,6 @@ function parseParamTokens(params) {
         Types.needAnalysis[ret[ret.length-1].type] = 0;
         anonymousIndex ++;
       }
-    } else if (segment[1].text in PARSABLE_LLVM_FUNCTIONS) {
-      ret.push(parseLLVMFunctionCall(segment));
-    } else if (segment[1].text === 'blockaddress') {
-      ret.push(parseBlockAddress(segment));
-    } else if (segment[1].type && segment[1].type == '{') {
-      ret.push(parseLLVMSegment(segment));
     } else {
       if (segment[2] && segment[2].text == 'to') { // part of bitcast params
         segment = segment.slice(0, 2);
@@ -496,7 +490,6 @@ function parseParamTokens(params) {
       var parsed = parseLLVMSegment(segment);
       if (parsed.intertype === 'value' && !isIllegalType(parsed.type)) parsed.ident = parseNumerical(parsed.ident);
       ret.push(parsed);
-      Types.needAnalysis[removeAllPointing(parsed.type)] = 0;
     }
     ret[ret.length-1].byVal = byVal;
   }

From b5b84c93e5eededcd6a704c4580fef5c574a9718 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 17:48:49 -0700
Subject: [PATCH 60/93] make sure the eval in emscripten_run_script_string
 emits a string

---
 src/library.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/library.js b/src/library.js
index bcd6d7dce1d8c..e3cdc7c33c399 100644
--- a/src/library.js
+++ b/src/library.js
@@ -8578,7 +8578,7 @@ LibraryManager.library = {
   },
 
   emscripten_run_script_string: function(ptr) {
-    var s = eval(Pointer_stringify(ptr));
+    var s = eval(Pointer_stringify(ptr)) + '';
     var me = _emscripten_run_script_string;
     if (!me.bufferSize || me.bufferSize < s.length+1) {
       if (me.bufferSize) _free(me.buffer);

From ffde799134ebed5a4e2309d3d3fc791d36fd79f6 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 18:40:50 -0700
Subject: [PATCH 61/93] fix negative zero handling

---
 src/parseTools.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/parseTools.js b/src/parseTools.js
index 86adaf19ae49e..238b6bd5cf8f3 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -488,7 +488,7 @@ function parseParamTokens(params) {
         segment = segment.slice(0, 2);
       }
       var parsed = parseLLVMSegment(segment);
-      if (parsed.intertype === 'value' && !isIllegalType(parsed.type)) parsed.ident = parseNumerical(parsed.ident);
+      if (parsed.intertype === 'value' && !isIllegalType(parsed.type)) parsed.ident = parseNumerical(parsed.ident, parsed.type);
       ret.push(parsed);
     }
     ret[ret.length-1].byVal = byVal;

From 1e4eddb702888b30cc0f1b1136f2732b2a5a4dbb Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 20:09:51 -0700
Subject: [PATCH 62/93] add some more sdl scancodes

---
 src/library_sdl.js | 43 ++++++++++++++++++++++++-------------------
 1 file changed, 24 insertions(+), 19 deletions(-)

diff --git a/src/library_sdl.js b/src/library_sdl.js
index 4620035e51807..04a663511dbab 100644
--- a/src/library_sdl.js
+++ b/src/library_sdl.js
@@ -153,25 +153,30 @@ var LibrarySDL = {
       120: 27,
       121: 28,
       122: 29, // Z
-      44: 54, // comma
-      46: 55, // period
-      47: 56, // slash
-      49: 30, // 1
-      50: 31,
-      51: 32,
-      52: 33,
-      53: 34,
-      54: 35,
-      55: 36,
-      56: 37,
-      57: 38, // 9
-      48: 39, // 0
-      13: 40, // return
-      8: 42, // backspace
-      9: 43, // tab
-      27: 41, // escape
-      32: 44, // space
-      92: 49, // backslash
+       49: 30, // 1
+       50: 31,
+       51: 32,
+       52: 33,
+       53: 34,
+       54: 35,
+       55: 36,
+       56: 37,
+       57: 38, // 9
+       48: 39, // 0
+       13: 40, // return
+       27: 41, // escape
+        8: 42, // backspace
+        9: 43, // tab
+       32: 44, // space
+       61: 46, // equals
+       91: 47, // left bracket
+       93: 48, // right bracket
+       92: 49, // backslash
+       59: 51, // ;
+       96: 52, // apostrophe
+       44: 54, // comma
+       46: 55, // period
+       47: 56, // slash
       305: 224, // ctrl
       308: 226, // alt
     },

From 5dfe077ac92295cae2396fa06866b366defa8b23 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 21:06:54 -0700
Subject: [PATCH 63/93] use proper base type when finalizing vectors

---
 src/parseTools.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/parseTools.js b/src/parseTools.js
index 238b6bd5cf8f3..fb3b9652636a3 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -2027,7 +2027,7 @@ function finalizeLLVMParameter(param, noIndexizeFunctions) {
   } else if (param.intertype == 'mathop') {
     return processMathop(param);
   } else if (param.intertype === 'vector') {
-    return 'float32x4(' + param.idents.join(',') + ')';
+    return getVectorBaseType(param.type) + '32x4(' + param.idents.join(',') + ')';
   } else {
     throw 'invalid llvm parameter: ' + param.intertype;
   }

From 819c105c234a89e2d0936c1d7218612db43dd56c Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 21:11:06 -0700
Subject: [PATCH 64/93] remove finalizeParam and properly use
 finalizeLLVMParameter everywhere

---
 src/jsifier.js     |  2 +-
 src/parseTools.js  | 19 -------------------
 tests/test_core.py |  2 +-
 3 files changed, 2 insertions(+), 21 deletions(-)

diff --git a/src/jsifier.js b/src/jsifier.js
index adcb38eef6f81..0da48a8c5b51d 100644
--- a/src/jsifier.js
+++ b/src/jsifier.js
@@ -1491,7 +1491,7 @@ function JSify(data, functionsOnly, givenFunctions) {
     }
 
     params.forEach(function(param, i) {
-      var val = finalizeParam(param);
+      var val = finalizeLLVMParameter(param);
       if (!hasVarArgs || useJSArgs || i < normalArgs) {
         args.push(val);
         argsTypes.push(param.type);
diff --git a/src/parseTools.js b/src/parseTools.js
index fb3b9652636a3..75ba6fd284423 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -563,25 +563,6 @@ function sortGlobals(globals) {
   });
 }
 
-function finalizeParam(param) {
-  if (param.intertype in PARSABLE_LLVM_FUNCTIONS) {
-    return finalizeLLVMFunctionCall(param);
-  } else if (param.intertype === 'blockaddress') {
-    return finalizeBlockAddress(param);
-  } else if (param.intertype === 'jsvalue') {
-    return param.ident;
-  } else {
-    if (param.type == 'i64' && USE_TYPED_ARRAYS == 2) {
-      return parseI64Constant(param.ident);
-    }
-    var ret = toNiceIdent(param.ident);
-    if (ret in Variables.globals) {
-      ret = makeGlobalUse(ret);
-    }
-    return ret;
-  }
-}
-
 // Segment ==> Parameter
 function parseLLVMSegment(segment) {
   var type;
diff --git a/tests/test_core.py b/tests/test_core.py
index 6857d8034d184..68f5bef720806 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -8705,7 +8705,7 @@ def test_simd(self):
     c = _mm_set_ps(9.0, 4.0, 0, -9.0);
     d = _mm_set_ps(10.0, 14.0, -12, -2.0);
     printf("6floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
-    //printf("7calcs: %d\n", emscripten_float32x4_signmask(c));
+    printf("7calcs: %d\n", emscripten_float32x4_signmask(c)); // TODO: just not just compilation but output as well
   }
 
   return 0;

From 2e4bc80c40d31dfe975ae11067d423a0bce33bb5 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Wed, 30 Oct 2013 22:09:17 -0700
Subject: [PATCH 65/93] handle vector zeroinitializers

---
 src/parseTools.js  | 6 ++++++
 tests/test_core.py | 9 +++++++++
 2 files changed, 15 insertions(+)

diff --git a/src/parseTools.js b/src/parseTools.js
index 75ba6fd284423..ec907a41b4182 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -157,6 +157,10 @@ function isStructType(type) {
   return type[0] == '%';
 }
 
+function isVectorType(type) {
+  return type[type.length-1] === '>';
+}
+
 function isStructuralType(type) {
   return /^{ ?[^}]* ?}$/.test(type); // { i32, i8 } etc. - anonymous struct types
 }
@@ -1986,6 +1990,8 @@ function finalizeLLVMParameter(param, noIndexizeFunctions) {
   } else if (param.ident == 'zeroinitializer') {
     if (isStructType(param.type)) {
       return makeLLVMStruct(zeros(Types.types[param.type].fields.length));
+    } else if (isVectorType(param.type)) {
+      return ensureVector(0, getVectorBaseType(param.type));
     } else {
       return '0';
     }
diff --git a/tests/test_core.py b/tests/test_core.py
index 68f5bef720806..c196adf3181f6 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -8674,6 +8674,12 @@ def test_simd(self):
   return (float32x4){ __W, __X, __Y, __Z };
 }
 
+static __inline__ float32x4 __attribute__((__always_inline__))
+_mm_setzero_ps(void)
+{
+  return (float32x4){ 0.0, 0.0, 0.0, 0.0 };
+}
+
 int main(int argc, char **argv) {
   float data[8];
   for (int i = 0; i < 32; i++) data[i] = (1+i+argc)*(2+i+argc*argc);
@@ -8688,6 +8694,8 @@ def test_simd(self):
     printf("2floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
     d = c*d;
     printf("3floats! %d, %d, %d, %d   %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3], (int)d[0], (int)d[1], (int)d[2], (int)d[3]);
+    c = _mm_setzero_ps();
+    printf("zeros %d, %d, %d, %d\n", (int)c[0], (int)c[1], (int)c[2], (int)c[3]);
   }
   {
     uint32x4 *a = (uint32x4*)&data[0];
@@ -8715,6 +8723,7 @@ def test_simd(self):
     self.do_run(src, '''1floats! 6, 12, 20, 30   42, 56, 72, 90
 2floats! 48, 68, 92, 120   42, 56, 72, 90
 3floats! 48, 68, 92, 120   2016, 3808, 6624, 10800
+zeros 0, 0, 0, 0
 4uints! 1086324736, 1094713344, 1101004800, 1106247680   1109917696, 1113587712, 1116733440, 1119092736
 5uints! -2098724864, -2086666240, -2077229056, -2069626880   -23592960, -18874368, -15728640, -12845056
 6floats! -9, 0, 4, 9   -2, -12, 14, 10

From 92f9f71cba2781b72cf25a9c6e9dcb5e860a2dd9 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Thu, 31 Oct 2013 12:56:42 -0700
Subject: [PATCH 66/93] change getTexUnitType assertion to warnOnce

---
 src/library_gl.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/library_gl.js b/src/library_gl.js
index 6f145e91e03e3..76501111a2e96 100644
--- a/src/library_gl.js
+++ b/src/library_gl.js
@@ -3227,7 +3227,9 @@ var LibraryGL = {
 
 #if ASSERTIONS
         if (!useCurrProgram) {
-          assert(GL.immediate.TexEnvJIT.getTexUnitType(i) != 0, "GL_TEXTURE" + i + " coords are supplied, but that texture unit is disabled in the fixed-function pipeline.");
+          if (GL.immediate.TexEnvJIT.getTexUnitType(i) == 0) {
+             Runtime.warnOnce("GL_TEXTURE" + i + " coords are supplied, but that texture unit is disabled in the fixed-function pipeline.");
+          }
         }
 #endif
 

From 504683b8ecabf0c73c06444dd0f103bc461a52b6 Mon Sep 17 00:00:00 2001
From: "Michael J. Bishop" <mbtyke@gmail.com>
Date: Fri, 1 Nov 2013 13:52:49 -0400
Subject: [PATCH 67/93] Adds to a test case verifying glGetIntegerv returns
 correct results when the current texture id is not TEXTURE0 and fixes
 library_gl.js so that it returns correct results.

---
 src/library_gl.js | 8 ++++----
 tests/cubegeom.c  | 6 ++++++
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/src/library_gl.js b/src/library_gl.js
index 76501111a2e96..6ae20185490a9 100644
--- a/src/library_gl.js
+++ b/src/library_gl.js
@@ -1793,17 +1793,17 @@ var LibraryGL = {
             return;
           }
           case 0x8088: { // GL_TEXTURE_COORD_ARRAY_SIZE
-            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0];
+            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0 + GLImmediate.clientActiveTexture];
             {{{ makeSetValue('params', '0', 'attribute ? attribute.size : 0', 'i32') }}};
             return;
           }
           case 0x8089: { // GL_TEXTURE_COORD_ARRAY_TYPE
-            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0];
+            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0 + GLImmediate.clientActiveTexture];
             {{{ makeSetValue('params', '0', 'attribute ? attribute.type : 0', 'i32') }}};
             return;
           }
           case 0x808A: { // GL_TEXTURE_COORD_ARRAY_STRIDE
-            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0];
+            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0 + GLImmediate.clientActiveTexture];
             {{{ makeSetValue('params', '0', 'attribute ? attribute.stride : 0', 'i32') }}};
             return;
           }
@@ -2190,7 +2190,7 @@ var LibraryGL = {
       case 0x8090: // GL_COLOR_ARRAY_POINTER
         attribute = GLImmediate.clientAttributes[GLImmediate.COLOR]; break;
       case 0x8092: // GL_TEXTURE_COORD_ARRAY_POINTER
-        attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0]; break;
+        attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0 + GLImmediate.clientActiveTexture]; break;
       default: throw 'TODO: glGetPointerv for ' + name;
     }
     {{{ makeSetValue('p', '0', 'attribute ? attribute.pointer : 0', 'i32') }}};
diff --git a/tests/cubegeom.c b/tests/cubegeom.c
index fac0da2be259f..96d56339447ac 100644
--- a/tests/cubegeom.c
+++ b/tests/cubegeom.c
@@ -194,8 +194,14 @@ int main(int argc, char *argv[])
     // sauer vertex data is apparently 0-12: V3F, 12: N1B, 16-24: T2F, 24-28: T2S, 28-32: C4B
     glVertexPointer(3, GL_FLOAT, 32, (void*)0); // all these apply to the ARRAY_BUFFER that is bound
     glTexCoordPointer(2, GL_FLOAT, 32, (void*)16);
+
     glClientActiveTexture(GL_TEXTURE1); // XXX seems to be ignored in native build
     glTexCoordPointer(2, GL_SHORT, 32, (void*)24);
+    glGetIntegerv(GL_TEXTURE_COORD_ARRAY_SIZE, &tempInt); assert(tempInt == 2);
+    glGetIntegerv(GL_TEXTURE_COORD_ARRAY_TYPE, &tempInt); assert(tempInt == GL_SHORT);
+    glGetIntegerv(GL_TEXTURE_COORD_ARRAY_STRIDE, &tempInt); assert(tempInt == 32);
+    glGetPointerv(GL_TEXTURE_COORD_ARRAY_POINTER, &tempPtr); assert(tempPtr == (void *)24);
+
     glClientActiveTexture(GL_TEXTURE0); // likely not needed, it is a cleanup
     glNormalPointer(GL_BYTE, 32, (void*)12);
     glColorPointer(4, GL_UNSIGNED_BYTE, 32, (void*)28);

From 2faaa225c97252baadeb4c8750d8decd2fd04e57 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Fri, 1 Nov 2013 16:26:52 -0700
Subject: [PATCH 68/93] add vector support for and, or and xor

---
 src/parseTools.js  | 3 +++
 tests/test_core.py | 8 +++++++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/parseTools.js b/src/parseTools.js
index ec907a41b4182..db95d71f920f7 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -2374,6 +2374,9 @@ function processMathop(item) {
           return 'SIMD.uint32x4BitsToFloat32x4(' + idents[0] + ')';
         }
       }
+      case 'and': return 'SIMD.and(' + idents[0] + ',' + idents[1] + ')';
+      case 'or': return 'SIMD.or(' + idents[0] + ',' + idents[1] + ')';
+      case 'xor': return 'SIMD.xor(' + idents[0] + ',' + idents[1] + ')';
       default: throw 'vector op todo: ' + dump(item);
     }
   }
diff --git a/tests/test_core.py b/tests/test_core.py
index c196adf3181f6..a4fcd0e6fce31 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -8682,7 +8682,7 @@ def test_simd(self):
 
 int main(int argc, char **argv) {
   float data[8];
-  for (int i = 0; i < 32; i++) data[i] = (1+i+argc)*(2+i+argc*argc);
+  for (int i = 0; i < 32; i++) data[i] = (1+i+argc)*(2+i+argc*argc); // confuse optimizer
   {
     float32x4 *a = (float32x4*)&data[0];
     float32x4 *b = (float32x4*)&data[4];
@@ -8707,6 +8707,11 @@ def test_simd(self):
     e = c+d;
     f = c-d;
     printf("5uints! %d, %d, %d, %d   %d, %d, %d, %d\n", e[0], e[1], e[2], e[3], f[0], f[1], f[2], f[3]);
+    e = c&d;
+    f = c|d;
+    e = ~c&d;
+    f = c^d;
+    printf("5uintops! %d, %d, %d, %d   %d, %d, %d, %d\n", e[0], e[1], e[2], e[3], f[0], f[1], f[2], f[3]);
   }
   {
     float32x4 c, d, e, f;
@@ -8726,6 +8731,7 @@ def test_simd(self):
 zeros 0, 0, 0, 0
 4uints! 1086324736, 1094713344, 1101004800, 1106247680   1109917696, 1113587712, 1116733440, 1119092736
 5uints! -2098724864, -2086666240, -2077229056, -2069626880   -23592960, -18874368, -15728640, -12845056
+5uintops! 36175872, 35651584, 34603008, 33816576   48758784, 52428800, 53477376, 54788096
 6floats! -9, 0, 4, 9   -2, -12, 14, 10
 ''')
 

From cb3fe2bb6f6d348d3da7ea8c71af909748ff8d71 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Sat, 2 Nov 2013 01:12:26 +0200
Subject: [PATCH 69/93] Add command line parameter --no-heap-copy that
 optimizes for small memory footprint and fread() performance over the default
 behavior that copied VFS to HEAP, that is designed for mmap() performance.

Adjust MEMFS node contentMode enum to reflect whether content is off the main HEAP or not. Note that this enum is not much used, so this has little effect. Add browser tests to check that fread() and mmap() work with and without --no-heap-copy.
---
 emcc                   |  6 ++++++
 src/library_memfs.js   |  6 +++---
 tests/mmap_file.c      | 27 +++++++++++++++++++++++++++
 tests/test_browser.py  | 11 ++++++++++-
 tests/test_core.py     | 27 +++++----------------------
 tools/file_packager.py | 23 ++++++++++++++++++++---
 6 files changed, 71 insertions(+), 29 deletions(-)
 create mode 100644 tests/mmap_file.c

diff --git a/emcc b/emcc
index 3406ff83b554a..8f8ad4aada7c6 100755
--- a/emcc
+++ b/emcc
@@ -777,6 +777,7 @@ try:
   save_bc = False
   memory_init_file = False
   use_preload_cache = False
+  no_heap_copy = False
   proxy_to_worker = False
 
   if use_cxx:
@@ -897,6 +898,9 @@ try:
     elif newargs[i].startswith('--use-preload-cache'):
       use_preload_cache = True
       newargs[i] = ''
+    elif newargs[i].startswith('--no-heap-copy'):
+      no_heap_copy = True
+      newargs[i] = ''
     elif newargs[i] == '--ignore-dynamic-linking':
       ignore_dynamic_linking = True
       newargs[i] = ''
@@ -1667,6 +1671,8 @@ try:
       file_args += ['--compress', Compression.encoder, Compression.decoder, Compression.js_name]
     if use_preload_cache:
       file_args.append('--use-preload-cache')
+    if no_heap_copy:
+      file_args.append('--no-heap-copy')
     file_code = execute([shared.PYTHON, shared.FILE_PACKAGER, unsuffixed(target) + '.data'] + file_args, stdout=PIPE)[0]
     pre_js = file_code + pre_js
 
diff --git a/src/library_memfs.js b/src/library_memfs.js
index 9f528108c038d..d3148d8be4c93 100644
--- a/src/library_memfs.js
+++ b/src/library_memfs.js
@@ -225,9 +225,9 @@ mergeInto(LibraryManager.library, {
 #if ASSERTIONS
           assert(buffer.length);
 #endif
-          if (canOwn && buffer.buffer === HEAP8.buffer && offset === 0) {
-            node.contents = buffer; // this is a subarray of the heap, and we can own it
-            node.contentMode = MEMFS.CONTENT_OWNING;
+          if (canOwn && offset === 0) {
+            node.contents = buffer; // this could be a subarray of Emscripten HEAP, or allocated from some other source.
+            node.contentMode = (buffer.buffer === HEAP8.buffer) ? MEMFS.CONTENT_OWNING : MEMFS.CONTENT_FIXED;
           } else {
             node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
             node.contentMode = MEMFS.CONTENT_FIXED;
diff --git a/tests/mmap_file.c b/tests/mmap_file.c
new file mode 100644
index 0000000000000..6eed95e01526c
--- /dev/null
+++ b/tests/mmap_file.c
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <sys/mman.h>
+#include <emscripten.h>
+#include <string.h>
+#include <assert.h>
+
+int main() {
+    printf("*\n");
+    FILE *f = fopen("data.dat", "r");
+    char *m;
+    m = (char*)mmap(NULL, 9000, PROT_READ, MAP_PRIVATE, fileno(f), 0);
+    for (int i = 0; i < 20; i++) putchar(m[i]);
+    assert(!strncmp(m, "data from the file .", 20));
+    munmap(m, 9000);
+    printf("\n");
+    m = (char*)mmap(NULL, 9000, PROT_READ, MAP_PRIVATE, fileno(f), 5);
+    for (int i = 0; i < 20; i++) putchar(m[i]);
+    assert(!strncmp(m, "from the file ......", 20));
+    munmap(m, 9000);
+    printf("\n*\n");
+
+#ifdef REPORT_RESULT
+    int result = 1;
+    REPORT_RESULT();
+#endif
+    return 0;
+}
diff --git a/tests/test_browser.py b/tests/test_browser.py
index 2ff9106b93232..d52f109f478d1 100644
--- a/tests/test_browser.py
+++ b/tests/test_browser.py
@@ -338,7 +338,7 @@ def make_main(path):
       ("somefile.txt@/directory/file.txt", "/directory/file.txt"),
       ("somefile.txt@/directory/file.txt", "directory/file.txt"),
       (absolute_src_path + "@/directory/file.txt", "directory/file.txt")]
-    
+
     for test in test_cases:
       (srcpath, dstpath) = test
       print 'Testing', srcpath, dstpath
@@ -346,6 +346,11 @@ def make_main(path):
       Popen([PYTHON, EMCC, os.path.join(self.get_dir(), 'main.cpp'), '--preload-file', srcpath, '-o', 'page.html']).communicate()
       self.run_browser('page.html', 'You should see |load me right before|.', '/report_result?1')
 
+    # Test that '--no-heap-copy' works.
+    make_main('somefile.txt')
+    Popen([PYTHON, EMCC, os.path.join(self.get_dir(), 'main.cpp'), '--preload-file', 'somefile.txt', '--no-heap-copy', '-o', 'page.html']).communicate()
+    self.run_browser('page.html', 'You should see |load me right before|.', '/report_result?1')
+
     # By absolute path
 
     make_main('somefile.txt') # absolute becomes relative
@@ -1566,3 +1571,7 @@ def test_module(self):
     Popen([PYTHON, EMCC, path_from_root('tests', 'browser_module.cpp'), '-o', 'module.js', '-O2', '-s', 'SIDE_MODULE=1', '-s', 'DLOPEN_SUPPORT=1', '-s', 'EXPORTED_FUNCTIONS=["_one", "_two"]']).communicate()
     self.btest('browser_main.cpp', args=['-O2', '-s', 'MAIN_MODULE=1', '-s', 'DLOPEN_SUPPORT=1'], expected='8')
 
+  def test_mmap_file(self):
+    open(self.in_dir('data.dat'), 'w').write('data from the file ' + ('.' * 9000))
+    for extra_args in [[], ['--no-heap-copy']]:
+      self.btest(path_from_root('tests', 'mmap_file.c'), expected='1', args=['--preload-file', 'data.dat'] + extra_args)
diff --git a/tests/test_core.py b/tests/test_core.py
index b421659c87b51..89dd725f76112 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -8594,30 +8594,13 @@ def test_mmap(self):
 
   def test_mmap_file(self):
     if self.emcc_args is None: return self.skip('requires emcc')
-    self.emcc_args += ['--embed-file', 'data.dat']
+    for extra_args in [[], ['--no-heap-copy']]:
+      self.emcc_args += ['--embed-file', 'data.dat'] + extra_args
 
-    open(self.in_dir('data.dat'), 'w').write('data from the file ' + ('.' * 9000))
+      open(self.in_dir('data.dat'), 'w').write('data from the file ' + ('.' * 9000))
 
-    src = r'''
-      #include <stdio.h>
-      #include <sys/mman.h>
-
-      int main() {
-        printf("*\n");
-        FILE *f = fopen("data.dat", "r");
-        char *m;
-        m = (char*)mmap(NULL, 9000, PROT_READ, MAP_PRIVATE, fileno(f), 0);
-        for (int i = 0; i < 20; i++) putchar(m[i]);
-        munmap(m, 9000);
-        printf("\n");
-        m = (char*)mmap(NULL, 9000, PROT_READ, MAP_PRIVATE, fileno(f), 5);
-        for (int i = 0; i < 20; i++) putchar(m[i]);
-        munmap(m, 9000);
-        printf("\n*\n");
-        return 0;
-      }
-    '''
-    self.do_run(src, '*\ndata from the file .\nfrom the file ......\n*\n')
+      src = open(path_from_root('tests', 'mmap_file.c')).read()
+      self.do_run(src, '*\ndata from the file .\nfrom the file ......\n*\n')
 
   def test_cubescript(self):
     if self.emcc_args is None: return self.skip('requires emcc')
diff --git a/tools/file_packager.py b/tools/file_packager.py
index 1d0ec447e4a87..3ba5b23f4e9dd 100644
--- a/tools/file_packager.py
+++ b/tools/file_packager.py
@@ -11,7 +11,7 @@
 
 Usage:
 
-  file_packager.py TARGET [--preload A [B..]] [--embed C [D..]] [--compress COMPRESSION_DATA] [--crunch[=X]] [--js-output=OUTPUT.js] [--no-force]
+  file_packager.py TARGET [--preload A [B..]] [--embed C [D..]] [--compress COMPRESSION_DATA] [--crunch[=X]] [--js-output=OUTPUT.js] [--no-force] [--use-preload-cache] [--no-heap-copy]
 
   --crunch=X Will compress dxt files to crn with quality level X. The crunch commandline tool must be present
              and CRUNCH should be defined in ~/.emscripten that points to it. JS crunch decompressing code will
@@ -27,6 +27,10 @@
 
   --use-preload-cache Stores package in IndexedDB so that subsequent loads don't need to do XHR. Checks package version.
 
+  --no-heap-copy If specified, the preloaded filesystem is not copied inside the Emscripten HEAP, but kept in a separate typed array outside it.
+                 The default, if this is not specified, is to embed the VFS inside the HEAP, so that mmap()ing files in it is a no-op.
+                 Passing this flag optimizes for fread() usage, omitting it optimizes for mmap() usage.
+
 Notes:
 
   * The file packager generates unix-style file paths. So if you are on windows and a file is accessed at
@@ -43,7 +47,7 @@
 from subprocess import Popen, PIPE, STDOUT
 
 if len(sys.argv) == 1:
-  print '''Usage: file_packager.py TARGET [--preload A...] [--embed B...] [--compress COMPRESSION_DATA] [--crunch[=X]] [--js-output=OUTPUT.js] [--no-force] [--use-preload-cache]
+  print '''Usage: file_packager.py TARGET [--preload A...] [--embed B...] [--compress COMPRESSION_DATA] [--crunch[=X]] [--js-output=OUTPUT.js] [--no-force] [--use-preload-cache] [--no-heap-copy]
 See the source for more details.'''
   sys.exit(0)
 
@@ -70,7 +74,12 @@
 plugins = []
 jsoutput = None
 force = True
+# If set to True, IndexedDB (IDBFS in library_idbfs.js) is used to locally cache VFS XHR so that subsequent 
+# page loads can read the data from the offline cache instead.
 use_preload_cache = False
+# If set to True, the blob received from XHR is moved to the Emscripten HEAP, optimizing for mmap() performance.
+# If set to False, the XHR blob is kept intact, and fread()s etc. are performed directly to that data. This optimizes for minimal memory usage and fread() performance.
+no_heap_copy = True
 
 for arg in sys.argv[1:]:
   if arg == '--preload':
@@ -91,6 +100,8 @@
     force = False
   elif arg == '--use-preload-cache':
     use_preload_cache = True
+  elif arg == '--no-heap-copy':
+    no_heap_copy = False
   elif arg.startswith('--js-output'):
     jsoutput = arg.split('=')[1] if '=' in arg else None
   elif arg.startswith('--crunch'):
@@ -414,11 +425,17 @@ def was_seen(name):
 
 if has_preloaded:
   # Get the big archive and split it up
-  use_data = '''
+  if no_heap_copy:
+    use_data = '''
       // copy the entire loaded file into a spot in the heap. Files will refer to slices in that. They cannot be freed though.
       var ptr = Module['_malloc'](byteArray.length);
       Module['HEAPU8'].set(byteArray, ptr);
       DataRequest.prototype.byteArray = Module['HEAPU8'].subarray(ptr, ptr+byteArray.length);
+'''
+  else:
+    use_data = '''
+      // Reuse the bytearray from the XHR as the source for file reads.
+      DataRequest.prototype.byteArray = byteArray;
 '''
   for file_ in data_files:
     if file_['mode'] == 'preload':

From 398408b7b5c2bf7956aa57c45f623646b039efea Mon Sep 17 00:00:00 2001
From: Fraser Adams <fraser.adams@blueyonder.co.uk>
Date: Sat, 2 Nov 2013 11:51:44 +0000
Subject: [PATCH 70/93] moved nodejs client test case into main sockets test
 class as requested. Run with ./runner.py sockets.test_nodejs_sockets_echo

---
 tests/test_sockets.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tests/test_sockets.py b/tests/test_sockets.py
index 36e2dfb63c179..6701f6be76f4d 100644
--- a/tests/test_sockets.py
+++ b/tests/test_sockets.py
@@ -400,10 +400,9 @@ def test_webrtc(self):
     expected = '1'
     self.run_browser(host_outfile, '.', ['/report_result?' + e for e in expected])
 
-class nodejs_sockets(RunnerCore):
-  def test_sockets_echo(self):
+  def test_nodejs_sockets_echo(self):
     # This test checks that sockets work when the client code is run in Node.js
-    # Run with ./runner.py nodejs_sockets.test_sockets_echo
+    # Run with ./runner.py sockets.test_nodejs_sockets_echo
     if not NODE_JS in JS_ENGINES:
         return
 

From a9ef49d8c97dcaed3cc7778acf61de978efdd5ff Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Sun, 3 Nov 2013 16:55:11 -0800
Subject: [PATCH 71/93] CONTRIBUTING.markdown

---
 CONTRIBUTING.markdown | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 CONTRIBUTING.markdown

diff --git a/CONTRIBUTING.markdown b/CONTRIBUTING.markdown
new file mode 100644
index 0000000000000..ceea873534234
--- /dev/null
+++ b/CONTRIBUTING.markdown
@@ -0,0 +1,5 @@
+
+See our wiki for information about contributing to Emscripten:
+
+[Contribution section on wiki](https://github.com/kripken/emscripten/wiki#contributing)
+

From 66d585fcd3fa6a17ae889b82aee1e95d420f82c0 Mon Sep 17 00:00:00 2001
From: Pierre Renaux <pierre@talansoft.com>
Date: Mon, 4 Nov 2013 19:27:11 +0800
Subject: [PATCH 72/93] [em++]: Removed unnecessary warning about the PYTHON
 variable ;

---
 em++ | 2 --
 1 file changed, 2 deletions(-)

diff --git a/em++ b/em++
index 810b7aec07a75..ba09e1a2d472d 100755
--- a/em++
+++ b/em++
@@ -8,7 +8,5 @@ import os, subprocess, sys
 from tools import shared
 
 os.environ['EMMAKEN_CXX'] = '1'
-if not os.path.exists(shared.PYTHON):
-  print >> sys.stderr, 'warning: PYTHON does not seem to be defined properly in ~/.emscripten (%s)' % shared.PYTHON
 exit(subprocess.call([shared.PYTHON, shared.EMCC] + sys.argv[1:]))
 

From 8a419cd95dad82f649f16d339dbbe3de3bb0db32 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Mon, 4 Nov 2013 14:07:02 +0200
Subject: [PATCH 73/93] Give names to most manually assigned functions in the
 .js files, in form "var x = function()" -> "function x()" so that error stack
 traces and profiling stack traces are more informative and do not contain
 anonymous functions.

---
 src/library.js         |  56 +++++++++++-----------
 src/library_browser.js |  50 +++++++++----------
 src/library_fs.js      |  28 +++++------
 src/library_gl.js      | 106 ++++++++++++++++++++---------------------
 src/library_glut.js    |   2 +-
 src/library_idbfs.js   |  26 +++++-----
 src/library_sdl.js     |  12 ++---
 src/library_sockfs.js  |   4 +-
 src/preamble.js        |   6 +--
 src/proxyClient.js     |   2 +-
 src/proxyWorker.js     |  20 ++++----
 src/runtime.js         |   4 +-
 src/shell.js           |  22 ++++-----
 13 files changed, 169 insertions(+), 169 deletions(-)

diff --git a/src/library.js b/src/library.js
index e3cdc7c33c399..106c4f740748f 100644
--- a/src/library.js
+++ b/src/library.js
@@ -1602,12 +1602,12 @@ LibraryManager.library = {
     if (format.indexOf('%n') >= 0) {
       // need to track soFar
       var _get = get;
-      get = function() {
+      get = function get() {
         soFar++;
         return _get();
       }
       var _unget = unget;
-      unget = function() {
+      unget = function unget() {
         soFar--;
         return _unget();
       }
@@ -2755,12 +2755,12 @@ LibraryManager.library = {
       return -1;
     }
     var buffer = [];
-    var get = function() {
+    function get() {
       var c = _fgetc(stream);
       buffer.push(c);
       return c;
     };
-    var unget = function() {
+    function unget() {
       _ungetc(buffer.pop(), stream);
     };
     return __scanString(format, get, unget, varargs);
@@ -2777,8 +2777,8 @@ LibraryManager.library = {
     // int sscanf(const char *restrict s, const char *restrict format, ... );
     // http://pubs.opengroup.org/onlinepubs/000095399/functions/scanf.html
     var index = 0;
-    var get = function() { return {{{ makeGetValue('s', 'index++', 'i8') }}}; };
-    var unget = function() { index--; };
+    function get() { return {{{ makeGetValue('s', 'index++', 'i8') }}}; };
+    function unget() { index--; };
     return __scanString(format, get, unget, varargs);
   },
   snprintf__deps: ['_formatString'],
@@ -3040,7 +3040,7 @@ LibraryManager.library = {
   },
 
   bsearch: function(key, base, num, size, compar) {
-    var cmp = function(x, y) {
+    function cmp(x, y) {
 #if ASM_JS
       return Module['dynCall_iii'](compar, x, y);
 #else
@@ -5108,7 +5108,7 @@ LibraryManager.library = {
         table[from + i] = {};
         sigs.forEach(function(sig) { // TODO: new Function etc.
           var full = 'dynCall_' + sig;
-          table[from + i][sig] = function() {
+          table[from + i][sig] = function dynCall_sig() {
             arguments[0] -= from;
             return asm[full].apply(null, arguments);
           }
@@ -5132,7 +5132,7 @@ LibraryManager.library = {
 
       // patch js module dynCall_* to use functionTable
       sigs.forEach(function(sig) {
-        jsModule['dynCall_' + sig] = function() {
+        jsModule['dynCall_' + sig] = function dynCall_sig() {
           return table[arguments[0]][sig].apply(null, arguments);
         };
       });
@@ -5596,7 +5596,7 @@ LibraryManager.library = {
     var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
     var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
 
-    var leadingSomething = function(value, digits, character) {
+    function leadingSomething(value, digits, character) {
       var str = typeof value === 'number' ? value.toString() : (value || '');
       while (str.length < digits) {
         str = character[0]+str;
@@ -5604,12 +5604,12 @@ LibraryManager.library = {
       return str;
     };
 
-    var leadingNulls = function(value, digits) {
+    function leadingNulls(value, digits) {
       return leadingSomething(value, digits, '0');
     };
 
-    var compareByDay = function(date1, date2) {
-      var sgn = function(value) {
+    function compareByDay(date1, date2) {
+      function sgn(value) {
         return value < 0 ? -1 : (value > 0 ? 1 : 0);
       };
 
@@ -5622,7 +5622,7 @@ LibraryManager.library = {
       return compare;
     };
 
-    var getFirstWeekStartDate = function(janFourth) {
+    function getFirstWeekStartDate(janFourth) {
         switch (janFourth.getDay()) {
           case 0: // Sunday
             return new Date(janFourth.getFullYear()-1, 11, 29);
@@ -5641,7 +5641,7 @@ LibraryManager.library = {
         }
     };
 
-    var getWeekBasedYear = function(date) {
+    function getWeekBasedYear(date) {
         var thisDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday);
 
         var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
@@ -5928,8 +5928,8 @@ LibraryManager.library = {
     var matches = new RegExp('^'+pattern).exec(Pointer_stringify(buf))
     // Module['print'](Pointer_stringify(buf)+ ' is matched by '+((new RegExp('^'+pattern)).source)+' into: '+JSON.stringify(matches));
 
-    var initDate = function() {
-      var fixup = function(value, min, max) {
+    function initDate() {
+      function fixup(value, min, max) {
         return (typeof value !== 'number' || isNaN(value)) ? min : (value>=min ? (value<=max ? value: max): min);
       };
       return {
@@ -5946,7 +5946,7 @@ LibraryManager.library = {
       var date = initDate();
       var value;
 
-      var getMatch = function(symbol) {
+      function getMatch(symbol) {
         var pos = capture.indexOf(symbol);
         // check if symbol appears in regexp
         if (pos >= 0) {
@@ -7681,7 +7681,7 @@ LibraryManager.library = {
       var session = Module['webrtc']['session'];
       var peer = new Peer(broker);
       var listenOptions = Module['webrtc']['hostOptions'] || {};
-      peer.onconnection = function(connection) {
+      peer.onconnection = function peer_onconnection(connection) {
         console.log('connected');
         var addr;
         /* If this peer is connecting to the host, assign 10.0.0.1 to the host so it can be
@@ -7695,7 +7695,7 @@ LibraryManager.library = {
         }
         connection['addr'] = addr;
         Sockets.connections[addr] = connection;
-        connection.ondisconnect = function() {
+        connection.ondisconnect = function connection_ondisconnect() {
           console.log('disconnect');
           // Don't return the host address (10.0.0.1) to the pool
           if (!(session && session === Sockets.connections[addr]['route'])) {
@@ -7707,12 +7707,12 @@ LibraryManager.library = {
             Module['webrtc']['ondisconnect'](peer);
           }
         };
-        connection.onerror = function(error) {
+        connection.onerror = function connection_onerror(error) {
           if (Module['webrtc']['onerror'] && 'function' === typeof Module['webrtc']['onerror']) {
             Module['webrtc']['onerror'](error);
           }
         };
-        connection.onmessage = function(label, message) {
+        connection.onmessage = function connection_onmessage(label, message) {
           if ('unreliable' === label) {
             handleMessage(addr, message.data);
           }
@@ -7722,13 +7722,13 @@ LibraryManager.library = {
           Module['webrtc']['onconnect'](peer);
         }
       };
-      peer.onpending = function(pending) {
+      peer.onpending = function peer_onpending(pending) {
         console.log('pending from: ', pending['route'], '; initiated by: ', (pending['incoming']) ? 'remote' : 'local');
       };
-      peer.onerror = function(error) {
+      peer.onerror = function peer_onerror(error) {
         console.error(error);
       };
-      peer.onroute = function(route) {
+      peer.onroute = function peer_onroute(route) {
         if (Module['webrtc']['onpeer'] && 'function' === typeof Module['webrtc']['onpeer']) {
           Module['webrtc']['onpeer'](peer, route);
         }
@@ -7744,7 +7744,7 @@ LibraryManager.library = {
           console.log("unable to deliver message: ", addr, header[1], message);
         }
       }
-      window.onbeforeunload = function() {
+      window.onbeforeunload = function window_onbeforeunload() {
         var ids = Object.keys(Sockets.connections);
         ids.forEach(function(id) {
           Sockets.connections[id].close();
@@ -7813,7 +7813,7 @@ LibraryManager.library = {
     }
     info.addr = Sockets.localAddr; // 10.0.0.254
     info.host = __inet_ntop4_raw(info.addr);
-    info.close = function() {
+    info.close = function info_close() {
       Sockets.portmap[info.port] = undefined;
     }
     Sockets.portmap[info.port] = info;
@@ -8724,6 +8724,6 @@ function autoAddDeps(object, name) {
 
 // Add aborting stubs for various libc stuff needed by libc++
 ['pthread_cond_signal', 'pthread_equal', 'wcstol', 'wcstoll', 'wcstoul', 'wcstoull', 'wcstof', 'wcstod', 'wcstold', 'pthread_join', 'pthread_detach', 'catgets', 'catopen', 'catclose', 'fputwc', '__lockfile', '__unlockfile'].forEach(function(aborter) {
-  LibraryManager.library[aborter] = function() { throw 'TODO: ' + aborter };
+  LibraryManager.library[aborter] = function aborting_stub() { throw 'TODO: ' + aborter };
 });
 
diff --git a/src/library_browser.js b/src/library_browser.js
index 59d2945efa231..7192374386362 100644
--- a/src/library_browser.js
+++ b/src/library_browser.js
@@ -4,12 +4,12 @@
 
 mergeInto(LibraryManager.library, {
   $Browser__deps: ['$PATH'],
-  $Browser__postset: 'Module["requestFullScreen"] = function(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };\n' + // exports
-                     'Module["requestAnimationFrame"] = function(func) { Browser.requestAnimationFrame(func) };\n' +
-                     'Module["setCanvasSize"] = function(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };\n' +
-                     'Module["pauseMainLoop"] = function() { Browser.mainLoop.pause() };\n' +
-                     'Module["resumeMainLoop"] = function() { Browser.mainLoop.resume() };\n' +
-                     'Module["getUserMedia"] = function() { Browser.getUserMedia() }',
+  $Browser__postset: 'Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };\n' + // exports
+                     'Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };\n' +
+                     'Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };\n' +
+                     'Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };\n' +
+                     'Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };\n' +
+                     'Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }',
   $Browser: {
     mainLoop: {
       scheduler: null,
@@ -77,10 +77,10 @@ mergeInto(LibraryManager.library, {
       // might create some side data structure for use later (like an Image element, etc.).
 
       var imagePlugin = {};
-      imagePlugin['canHandle'] = function(name) {
+      imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
         return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
       };
-      imagePlugin['handle'] = function(byteArray, name, onload, onerror) {
+      imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
         var b = null;
         if (Browser.hasBlobConstructor) {
           try {
@@ -103,7 +103,7 @@ mergeInto(LibraryManager.library, {
         assert(typeof url == 'string', 'createObjectURL must return a url as a string');
 #endif
         var img = new Image();
-        img.onload = function() {
+        img.onload = function img_onload() {
           assert(img.complete, 'Image ' + name + ' could not be decoded');
           var canvas = document.createElement('canvas');
           canvas.width = img.width;
@@ -114,7 +114,7 @@ mergeInto(LibraryManager.library, {
           Browser.URLObject.revokeObjectURL(url);
           if (onload) onload(byteArray);
         };
-        img.onerror = function(event) {
+        img.onerror = function img_onerror(event) {
           console.log('Image ' + url + ' could not be decoded');
           if (onerror) onerror();
         };
@@ -123,10 +123,10 @@ mergeInto(LibraryManager.library, {
       Module['preloadPlugins'].push(imagePlugin);
 
       var audioPlugin = {};
-      audioPlugin['canHandle'] = function(name) {
+      audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
         return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
       };
-      audioPlugin['handle'] = function(byteArray, name, onload, onerror) {
+      audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
         var done = false;
         function finish(audio) {
           if (done) return;
@@ -152,7 +152,7 @@ mergeInto(LibraryManager.library, {
 #endif
           var audio = new Audio();
           audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
-          audio.onerror = function(event) {
+          audio.onerror = function audio_onerror(event) {
             if (done) return;
             console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
             function encode64(data) {
@@ -268,7 +268,7 @@ mergeInto(LibraryManager.library, {
           (function(prop) {
             switch (typeof tempCtx[prop]) {
               case 'function': {
-                wrapper[prop] = function() {
+                wrapper[prop] = function gl_wrapper() {
                   if (GL.debug) {
                     var printArgs = Array.prototype.slice.call(arguments).map(Runtime.prettyPrint);
                     Module.printErr('[gl_f:' + prop + ':' + printArgs + ']');
@@ -497,7 +497,7 @@ mergeInto(LibraryManager.library, {
       var xhr = new XMLHttpRequest();
       xhr.open('GET', url, true);
       xhr.responseType = 'arraybuffer';
-      xhr.onload = function() {
+      xhr.onload = function xhr_onload() {
         if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
           onload(xhr.response);
         } else {
@@ -610,7 +610,7 @@ mergeInto(LibraryManager.library, {
     http.responseType = 'arraybuffer';
 
     // LOAD
-    http.onload = function(e) {
+    http.onload = function http_onload(e) {
       if (http.status == 200) {
         FS.createDataFile( _file.substr(0, index), _file.substr(index + 1), new Uint8Array(http.response), true, true);
         if (onload) Runtime.dynCall('vii', onload, [arg, file]);
@@ -620,12 +620,12 @@ mergeInto(LibraryManager.library, {
     };
 
     // ERROR
-    http.onerror = function(e) {
+    http.onerror = function http_onerror(e) {
       if (onerror) Runtime.dynCall('vii', onerror, [arg, http.status]);
     };
 
     // PROGRESS
-    http.onprogress = function(e) {
+    http.onprogress = function http_onprogress(e) {
       var percentComplete = (e.position / e.totalSize)*100;
       if (onprogress) Runtime.dynCall('vii', onprogress, [arg, percentComplete]);
     };
@@ -705,7 +705,7 @@ mergeInto(LibraryManager.library, {
 
     assert(runDependencies === 0, 'async_load_script must be run when no other dependencies are active');
     var script = document.createElement('script');
-    script.onload = function() {
+    script.onload = function script_onload() {
       if (runDependencies > 0) {
         dependenciesFulfilled = onload;
       } else {
@@ -720,7 +720,7 @@ mergeInto(LibraryManager.library, {
   emscripten_set_main_loop: function(func, fps, simulateInfiniteLoop) {
     Module['noExitRuntime'] = true;
 
-    Browser.mainLoop.runner = function() {
+    Browser.mainLoop.runner = function Browser_mainLoop_runner() {
       if (ABORT) return;
       if (Browser.mainLoop.queue.length > 0) {
         var start = Date.now();
@@ -777,11 +777,11 @@ mergeInto(LibraryManager.library, {
       Browser.mainLoop.scheduler();
     }
     if (fps && fps > 0) {
-      Browser.mainLoop.scheduler = function() {
+      Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler() {
         setTimeout(Browser.mainLoop.runner, 1000/fps); // doing this each time means that on exception, we stop
       }
     } else {
-      Browser.mainLoop.scheduler = function() {
+      Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler() {
         Browser.requestAnimationFrame(Browser.mainLoop.runner);
       }
     }
@@ -870,14 +870,14 @@ mergeInto(LibraryManager.library, {
   emscripten_get_now: function() {
     if (!_emscripten_get_now.actual) {
       if (ENVIRONMENT_IS_NODE) {
-          _emscripten_get_now.actual = function() {
+          _emscripten_get_now.actual = function _emscripten_get_now_actual() {
             var t = process['hrtime']();
             return t[0] * 1e3 + t[1] / 1e6;
           }
       } else if (typeof dateNow !== 'undefined') {
         _emscripten_get_now.actual = dateNow;
       } else if (ENVIRONMENT_IS_WEB && window['performance'] && window['performance']['now']) {
-        _emscripten_get_now.actual = function() { return window['performance']['now'](); };
+        _emscripten_get_now.actual = function _emscripten_get_now_actual() { return window['performance']['now'](); };
       } else {
         _emscripten_get_now.actual = Date.now;
       }
@@ -895,7 +895,7 @@ mergeInto(LibraryManager.library, {
       buffer: 0,
       bufferSize: 0
     };
-    info.worker.onmessage = function(msg) {
+    info.worker.onmessage = function info_worker_onmessage(msg) {
       var info = Browser.workers[id];
       if (!info) return; // worker was destroyed meanwhile
       var callbackId = msg.data['callbackId'];
diff --git a/src/library_fs.js b/src/library_fs.js
index aece2664359e7..16512385f8c5a 100644
--- a/src/library_fs.js
+++ b/src/library_fs.js
@@ -439,7 +439,7 @@ mergeInto(LibraryManager.library, {
 
       var completed = 0;
       var total = FS.mounts.length;
-      var done = function(err) {
+      function done(err) {
         if (err) {
           return callback(err);
         }
@@ -1326,11 +1326,11 @@ mergeInto(LibraryManager.library, {
       if (typeof XMLHttpRequest !== 'undefined') {
         if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
         // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
-        var LazyUint8Array = function() {
+        function LazyUint8Array() {
           this.lengthKnown = false;
           this.chunks = []; // Loaded chunks. Index is the chunk number
         }
-        LazyUint8Array.prototype.get = function(idx) {
+        LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
           if (idx > this.length-1 || idx < 0) {
             return undefined;
           }
@@ -1338,10 +1338,10 @@ mergeInto(LibraryManager.library, {
           var chunkNum = Math.floor(idx / this.chunkSize);
           return this.getter(chunkNum)[chunkOffset];
         }
-        LazyUint8Array.prototype.setDataGetter = function(getter) {
+        LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
           this.getter = getter;
         }
-        LazyUint8Array.prototype.cacheLength = function() {
+        LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
             // Find length
             var xhr = new XMLHttpRequest();
             xhr.open('HEAD', url, false);
@@ -1437,7 +1437,7 @@ mergeInto(LibraryManager.library, {
       var keys = Object.keys(node.stream_ops);
       keys.forEach(function(key) {
         var fn = node.stream_ops[key];
-        stream_ops[key] = function() {
+        stream_ops[key] = function forceLoadLazyFile() {
           if (!FS.forceLoadFile(node)) {
             throw new FS.ErrnoError(ERRNO_CODES.EIO);
           }
@@ -1445,7 +1445,7 @@ mergeInto(LibraryManager.library, {
         };
       });
       // use a custom read function
-      stream_ops.read = function(stream, buffer, offset, length, position) {
+      stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
         if (!FS.forceLoadFile(node)) {
           throw new FS.ErrnoError(ERRNO_CODES.EIO);
         }
@@ -1539,12 +1539,12 @@ mergeInto(LibraryManager.library, {
       } catch (e) {
         return onerror(e);
       }
-      openRequest.onupgradeneeded = function() {
+      openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
         console.log('creating db');
         var db = openRequest.result;
         db.createObjectStore(FS.DB_STORE_NAME);
       };
-      openRequest.onsuccess = function() {
+      openRequest.onsuccess = function openRequest_onsuccess() {
         var db = openRequest.result;
         var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
         var files = transaction.objectStore(FS.DB_STORE_NAME);
@@ -1554,8 +1554,8 @@ mergeInto(LibraryManager.library, {
         }
         paths.forEach(function(path) {
           var putRequest = files.put(FS.analyzePath(path).object.contents, path);
-          putRequest.onsuccess = function() { ok++; if (ok + fail == total) finish() };
-          putRequest.onerror = function() { fail++; if (ok + fail == total) finish() };
+          putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
+          putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
         });
         transaction.onerror = onerror;
       };
@@ -1573,7 +1573,7 @@ mergeInto(LibraryManager.library, {
         return onerror(e);
       }
       openRequest.onupgradeneeded = onerror; // no database to load from
-      openRequest.onsuccess = function() {
+      openRequest.onsuccess = function openRequest_onsuccess() {
         var db = openRequest.result;
         try {
           var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
@@ -1588,7 +1588,7 @@ mergeInto(LibraryManager.library, {
         }
         paths.forEach(function(path) {
           var getRequest = files.get(path);
-          getRequest.onsuccess = function() {
+          getRequest.onsuccess = function getRequest_onsuccess() {
             if (FS.analyzePath(path).exists) {
               FS.unlink(path);
             }
@@ -1596,7 +1596,7 @@ mergeInto(LibraryManager.library, {
             ok++;
             if (ok + fail == total) finish();
           };
-          getRequest.onerror = function() { fail++; if (ok + fail == total) finish() };
+          getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
         });
         transaction.onerror = onerror;
       };
diff --git a/src/library_gl.js b/src/library_gl.js
index 6ae20185490a9..7074f844f9976 100644
--- a/src/library_gl.js
+++ b/src/library_gl.js
@@ -1682,7 +1682,7 @@ var LibraryGL = {
       };
 
       var glEnable = _glEnable;
-      _glEnable = function(cap) {
+      _glEnable = function _glEnable(cap) {
         // Clean up the renderer on any change to the rendering state. The optimization of
         // skipping renderer setup is aimed at the case of multiple glDraw* right after each other
         if (GL.immediate.lastRenderer) GL.immediate.lastRenderer.cleanup();
@@ -1704,7 +1704,7 @@ var LibraryGL = {
       };
 
       var glDisable = _glDisable;
-      _glDisable = function(cap) {
+      _glDisable = function _glDisable(cap) {
         if (GL.immediate.lastRenderer) GL.immediate.lastRenderer.cleanup();
         if (cap == 0x0B60 /* GL_FOG */) {
           GLEmulation.fogEnabled = false;
@@ -1722,7 +1722,7 @@ var LibraryGL = {
         }
         glDisable(cap);
       };
-      _glIsEnabled = function(cap) {
+      _glIsEnabled = function _glIsEnabled(cap) {
         if (cap == 0x0B60 /* GL_FOG */) {
           return GLEmulation.fogEnabled ? 1 : 0;
         } else if (!(cap in validCapabilities)) {
@@ -1732,7 +1732,7 @@ var LibraryGL = {
       };
 
       var glGetBooleanv = _glGetBooleanv;
-      _glGetBooleanv = function(pname, p) {
+      _glGetBooleanv = function _glGetBooleanv(pname, p) {
         var attrib = GLEmulation.getAttributeFromCapability(pname);
         if (attrib !== null) {
           var result = GL.immediate.enabledClientAttributes[attrib];
@@ -1743,7 +1743,7 @@ var LibraryGL = {
       };
 
       var glGetIntegerv = _glGetIntegerv;
-      _glGetIntegerv = function(pname, params) {
+      _glGetIntegerv = function _glGetIntegerv(pname, params) {
         switch (pname) {
           case 0x84E2: pname = Module.ctx.MAX_TEXTURE_IMAGE_UNITS /* fake it */; break; // GL_MAX_TEXTURE_UNITS
           case 0x8B4A: { // GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB
@@ -1812,7 +1812,7 @@ var LibraryGL = {
       };
 
       var glGetString = _glGetString;
-      _glGetString = function(name_) {
+      _glGetString = function _glGetString(name_) {
         if (GL.stringCache[name_]) return GL.stringCache[name_];
         switch(name_) {
           case 0x1F03 /* GL_EXTENSIONS */: // Add various extensions that we can support
@@ -1836,7 +1836,7 @@ var LibraryGL = {
       GL.shaderOriginalSources = {};
 #endif
       var glCreateShader = _glCreateShader;
-      _glCreateShader = function(shaderType) {
+      _glCreateShader = function _glCreateShader(shaderType) {
         var id = glCreateShader(shaderType);
         GL.shaderInfos[id] = {
           type: shaderType,
@@ -1846,7 +1846,7 @@ var LibraryGL = {
       };
 
       var glShaderSource = _glShaderSource;
-      _glShaderSource = function(shader, count, string, length) {
+      _glShaderSource = function _glShaderSource(shader, count, string, length) {
         var source = GL.getSource(shader, count, string, length);
 #if GL_DEBUG
         console.log("glShaderSource: Input: \n" + source);
@@ -1959,7 +1959,7 @@ var LibraryGL = {
       };
 
       var glCompileShader = _glCompileShader;
-      _glCompileShader = function(shader) {
+      _glCompileShader = function _glCompileShader(shader) {
         Module.ctx.compileShader(GL.shaders[shader]);
 #if GL_DEBUG
         if (!Module.ctx.getShaderParameter(GL.shaders[shader], Module.ctx.COMPILE_STATUS)) {
@@ -1974,14 +1974,14 @@ var LibraryGL = {
 
       GL.programShaders = {};
       var glAttachShader = _glAttachShader;
-      _glAttachShader = function(program, shader) {
+      _glAttachShader = function _glAttachShader(program, shader) {
         if (!GL.programShaders[program]) GL.programShaders[program] = [];
         GL.programShaders[program].push(shader);
         glAttachShader(program, shader);
       };
 
       var glDetachShader = _glDetachShader;
-      _glDetachShader = function(program, shader) {
+      _glDetachShader = function _glDetachShader(program, shader) {
         var programShader = GL.programShaders[program];
         if (!programShader) {
           Module.printErr('WARNING: _glDetachShader received invalid program: ' + program);
@@ -1993,7 +1993,7 @@ var LibraryGL = {
       };
 
       var glUseProgram = _glUseProgram;
-      _glUseProgram = function(program) {
+      _glUseProgram = function _glUseProgram(program) {
 #if GL_DEBUG
         if (GL.debug) {
           Module.printErr('[using program with shaders]');
@@ -2010,7 +2010,7 @@ var LibraryGL = {
       }
 
       var glDeleteProgram = _glDeleteProgram;
-      _glDeleteProgram = function(program) {
+      _glDeleteProgram = function _glDeleteProgram(program) {
         glDeleteProgram(program);
         if (program == GL.currProgram) GL.currProgram = 0;
       };
@@ -2018,12 +2018,12 @@ var LibraryGL = {
       // If attribute 0 was not bound, bind it to 0 for WebGL performance reasons. Track if 0 is free for that.
       var zeroUsedPrograms = {};
       var glBindAttribLocation = _glBindAttribLocation;
-      _glBindAttribLocation = function(program, index, name) {
+      _glBindAttribLocation = function _glBindAttribLocation(program, index, name) {
         if (index == 0) zeroUsedPrograms[program] = true;
         glBindAttribLocation(program, index, name);
       };
       var glLinkProgram = _glLinkProgram;
-      _glLinkProgram = function(program) {
+      _glLinkProgram = function _glLinkProgram(program) {
         if (!(program in zeroUsedPrograms)) {
           Module.ctx.bindAttribLocation(GL.programs[program], 0, 'a_position');
         }
@@ -2031,7 +2031,7 @@ var LibraryGL = {
       };
 
       var glBindBuffer = _glBindBuffer;
-      _glBindBuffer = function(target, buffer) {
+      _glBindBuffer = function _glBindBuffer(target, buffer) {
         glBindBuffer(target, buffer);
         if (target == Module.ctx.ARRAY_BUFFER) {
           if (GLEmulation.currentVao) {
@@ -2046,7 +2046,7 @@ var LibraryGL = {
       };
 
       var glGetFloatv = _glGetFloatv;
-      _glGetFloatv = function(pname, params) {
+      _glGetFloatv = function _glGetFloatv(pname, params) {
         if (pname == 0x0BA6) { // GL_MODELVIEW_MATRIX
           HEAPF32.set(GL.immediate.matrix['m'], params >> 2);
         } else if (pname == 0x0BA7) { // GL_PROJECTION_MATRIX
@@ -2069,7 +2069,7 @@ var LibraryGL = {
       };
 
       var glHint = _glHint;
-      _glHint = function(target, mode) {
+      _glHint = function _glHint(target, mode) {
         if (target == 0x84EF) { // GL_TEXTURE_COMPRESSION_HINT
           return;
         }
@@ -2077,21 +2077,21 @@ var LibraryGL = {
       };
 
       var glEnableVertexAttribArray = _glEnableVertexAttribArray;
-      _glEnableVertexAttribArray = function(index) {
+      _glEnableVertexAttribArray = function _glEnableVertexAttribArray(index) {
         glEnableVertexAttribArray(index);
         GLEmulation.enabledVertexAttribArrays[index] = 1;
         if (GLEmulation.currentVao) GLEmulation.currentVao.enabledVertexAttribArrays[index] = 1;
       };
 
       var glDisableVertexAttribArray = _glDisableVertexAttribArray;
-      _glDisableVertexAttribArray = function(index) {
+      _glDisableVertexAttribArray = function _glDisableVertexAttribArray(index) {
         glDisableVertexAttribArray(index);
         delete GLEmulation.enabledVertexAttribArrays[index];
         if (GLEmulation.currentVao) delete GLEmulation.currentVao.enabledVertexAttribArrays[index];
       };
 
       var glVertexAttribPointer = _glVertexAttribPointer;
-      _glVertexAttribPointer = function(index, size, type, normalized, stride, pointer) {
+      _glVertexAttribPointer = function _glVertexAttribPointer(index, size, type, normalized, stride, pointer) {
         glVertexAttribPointer(index, size, type, normalized, stride, pointer);
         if (GLEmulation.currentVao) { // TODO: avoid object creation here? likely not hot though
           GLEmulation.currentVao.vertexAttribPointers[index] = [index, size, type, normalized, stride, pointer];
@@ -2212,14 +2212,14 @@ var LibraryGL = {
       function CNaiveListMap() {
         var list = [];
 
-        this.insert = function(key, val) {
+        this.insert = function CNaiveListMap_insert(key, val) {
           if (this.contains(key|0)) return false;
           list.push([key, val]);
           return true;
         };
 
         var __contains_i;
-        this.contains = function(key) {
+        this.contains = function CNaiveListMap_contains(key) {
           for (__contains_i = 0; __contains_i < list.length; ++__contains_i) {
             if (list[__contains_i][0] === key) return true;
           }
@@ -2227,7 +2227,7 @@ var LibraryGL = {
         };
 
         var __get_i;
-        this.get = function(key) {
+        this.get = function CNaiveListMap_get(key) {
           for (__get_i = 0; __get_i < list.length; ++__get_i) {
             if (list[__get_i][0] === key) return list[__get_i][1];
           }
@@ -2261,7 +2261,7 @@ var LibraryGL = {
         function CNLNode() {
           var map = new CNaiveListMap();
 
-          this.child = function(keyFrag) {
+          this.child = function CNLNode_child(keyFrag) {
             if (!map.contains(keyFrag|0)) {
               map.insert(keyFrag|0, new CNLNode());
             }
@@ -2269,11 +2269,11 @@ var LibraryGL = {
           };
 
           this.value = undefined;
-          this.get = function() {
+          this.get = function CNLNode_get() {
             return this.value;
           };
 
-          this.set = function(val) {
+          this.set = function CNLNode_set(val) {
             this.value = val;
           };
         }
@@ -2281,22 +2281,22 @@ var LibraryGL = {
         function CKeyView(root) {
           var cur;
 
-          this.reset = function() {
+          this.reset = function CKeyView_reset() {
             cur = root;
             return this;
           };
           this.reset();
 
-          this.next = function(keyFrag) {
+          this.next = function CKeyView_next(keyFrag) {
             cur = cur.child(keyFrag);
             return this;
           };
 
-          this.get = function() {
+          this.get = function CKeyView_get() {
             return cur.get();
           };
 
-          this.set = function(val) {
+          this.set = function CKeyView_set(val) {
             cur.set(val);
           };
         };
@@ -2304,17 +2304,17 @@ var LibraryGL = {
         var root;
         var staticKeyView;
 
-        this.createKeyView = function() {
+        this.createKeyView = function CNLNode_createKeyView() {
           return new CKeyView(root);
         }
 
-        this.clear = function() {
+        this.clear = function CNLNode_clear() {
           root = new CNLNode();
           staticKeyView = this.createKeyView();
         };
         this.clear();
 
-        this.getStaticKeyView = function() {
+        this.getStaticKeyView = function CNLNode_getStaticKeyView() {
           staticKeyView.reset();
           return staticKeyView;
         };
@@ -2548,7 +2548,7 @@ var LibraryGL = {
           GL_SRC_ALPHA
         ];
 
-        this.traverseState = function(keyView) {
+        this.traverseState = function CTexEnv_traverseState(keyView) {
           keyView.next(this.mode);
           keyView.next(this.colorCombiner);
           keyView.next(this.alphaCombiner);
@@ -2584,7 +2584,7 @@ var LibraryGL = {
         this.enabled_tex3D   = false;
         this.enabled_texCube = false;
 
-        this.traverseState = function(keyView) {
+        this.traverseState = function CTexUnit_traverseState(keyView) {
           var texUnitType = this.getTexType();
           keyView.next(texUnitType);
           if (!texUnitType) return;
@@ -2593,11 +2593,11 @@ var LibraryGL = {
       };
 
       // Class impls:
-      CTexUnit.prototype.enabled = function() {
+      CTexUnit.prototype.enabled = function CTexUnit_enabled() {
         return this.getTexType() != 0;
       }
 
-      CTexUnit.prototype.genPassLines = function(passOutputVar, passInputVar, texUnitID) {
+      CTexUnit.prototype.genPassLines = function CTexUnit_genPassLines(passOutputVar, passInputVar, texUnitID) {
         if (!this.enabled()) {
           return ["vec4 " + passOutputVar + " = " + passInputVar + ";"];
         }
@@ -2605,7 +2605,7 @@ var LibraryGL = {
         return this.env.genPassLines(passOutputVar, passInputVar, texUnitID);
       }
 
-      CTexUnit.prototype.getTexType = function() {
+      CTexUnit.prototype.getTexType = function CTexUnit_getTexType() {
         if (this.enabled_texCube) {
           return GL_TEXTURE_CUBE_MAP;
         } else if (this.enabled_tex3D) {
@@ -2618,7 +2618,7 @@ var LibraryGL = {
         return 0;
       }
 
-      CTexEnv.prototype.genPassLines = function(passOutputVar, passInputVar, texUnitID) {
+      CTexEnv.prototype.genPassLines = function CTexEnv_genPassLines(passOutputVar, passInputVar, texUnitID) {
         switch (this.mode) {
           case GL_REPLACE: {
             /* RGB:
@@ -2740,9 +2740,9 @@ var LibraryGL = {
         return Abort_NoSupport("Unsupported TexEnv mode: 0x" + this.mode.toString(16));
       }
 
-      CTexEnv.prototype.genCombinerLines = function(isColor, outputVar,
-                                                    passInputVar, texUnitID,
-                                                    combiner, srcArr, opArr)
+      CTexEnv.prototype.genCombinerLines = function CTexEnv_getCombinerLines(isColor, outputVar,
+                                                                             passInputVar, texUnitID,
+                                                                             combiner, srcArr, opArr)
       {
         var argsNeeded = null;
         switch (combiner) {
@@ -3598,7 +3598,7 @@ var LibraryGL = {
       // Replace some functions with immediate-mode aware versions. If there are no client
       // attributes enabled, and we use webgl-friendly modes (no GL_QUADS), then no need
       // for emulation
-      _glDrawArrays = function(mode, first, count) {
+      _glDrawArrays = function _glDrawArrays(mode, first, count) {
         if (GL.immediate.totalEnabledClientAttributes == 0 && mode <= 6) {
           Module.ctx.drawArrays(mode, first, count);
           return;
@@ -3614,7 +3614,7 @@ var LibraryGL = {
         GL.immediate.mode = -1;
       };
 
-      _glDrawElements = function(mode, count, type, indices, start, end) { // start, end are given if we come from glDrawRangeElements
+      _glDrawElements = function _glDrawElements(mode, count, type, indices, start, end) { // start, end are given if we come from glDrawRangeElements
         if (GL.immediate.totalEnabledClientAttributes == 0 && mode <= 6 && GL.currElementArrayBuffer) {
           Module.ctx.drawElements(mode, count, type, indices);
           return;
@@ -3654,43 +3654,43 @@ var LibraryGL = {
       }
 
       var glActiveTexture = _glActiveTexture;
-      _glActiveTexture = function(texture) {
+      _glActiveTexture = function _glActiveTexture(texture) {
         GL.immediate.TexEnvJIT.hook_activeTexture(texture);
         glActiveTexture(texture);
       };
 
       var glEnable = _glEnable;
-      _glEnable = function(cap) {
+      _glEnable = function _glEnable(cap) {
         GL.immediate.TexEnvJIT.hook_enable(cap);
         glEnable(cap);
       };
       var glDisable = _glDisable;
-      _glDisable = function(cap) {
+      _glDisable = function _glDisable(cap) {
         GL.immediate.TexEnvJIT.hook_disable(cap);
         glDisable(cap);
       };
 
       var glTexEnvf = (typeof(_glTexEnvf) != 'undefined') ? _glTexEnvf : function(){};
-      _glTexEnvf = function(target, pname, param) {
+      _glTexEnvf = function _glTexEnvf(target, pname, param) {
         GL.immediate.TexEnvJIT.hook_texEnvf(target, pname, param);
         // Don't call old func, since we are the implementor.
         //glTexEnvf(target, pname, param);
       };
       var glTexEnvi = (typeof(_glTexEnvi) != 'undefined') ? _glTexEnvi : function(){};
-      _glTexEnvi = function(target, pname, param) {
+      _glTexEnvi = function _glTexEnvi(target, pname, param) {
         GL.immediate.TexEnvJIT.hook_texEnvi(target, pname, param);
         // Don't call old func, since we are the implementor.
         //glTexEnvi(target, pname, param);
       };
       var glTexEnvfv = (typeof(_glTexEnvfv) != 'undefined') ? _glTexEnvfv : function(){};
-      _glTexEnvfv = function(target, pname, param) {
+      _glTexEnvfv = function _glTexEnvfv(target, pname, param) {
         GL.immediate.TexEnvJIT.hook_texEnvfv(target, pname, param);
         // Don't call old func, since we are the implementor.
         //glTexEnvfv(target, pname, param);
       };
 
       var glGetIntegerv = _glGetIntegerv;
-      _glGetIntegerv = function(pname, params) {
+      _glGetIntegerv = function _glGetIntegerv(pname, params) {
         switch (pname) {
           case 0x8B8D: { // GL_CURRENT_PROGRAM
             // Just query directly so we're working with WebGL objects.
@@ -4733,7 +4733,7 @@ LibraryGL.emscripten_GetProcAddress__deps = [function() {
   tableImpl += '}\nreturn 0;';
   LibraryManager.library.emscripten_procAddressTable = new Function('name', tableImpl);
 }, 'emscripten_procAddressTable'];
-LibraryGL.emscripten_GetProcAddress = function(name) {
+LibraryGL.emscripten_GetProcAddress = function _LibraryGL_emscripten_GetProcAddress(name) {
   name = name.replace('EXT', '').replace('ARB', '');
   switch(name) { // misc renamings
     case 'glCreateProgramObject': name = 'glCreateProgram'; break;
diff --git a/src/library_glut.js b/src/library_glut.js
index fefe7bd31ff19..5e303fd244f38 100644
--- a/src/library_glut.js
+++ b/src/library_glut.js
@@ -372,7 +372,7 @@ var LibraryGLUT = {
   },
 
   glutIdleFunc: function(func) {
-    var callback = function() {
+    function callback() {
       if (GLUT.idleFunc) {
         Runtime.dynCall('v', GLUT.idleFunc);
         Browser.safeSetTimeout(callback, 0);
diff --git a/src/library_idbfs.js b/src/library_idbfs.js
index ab55673ffc26c..7f50f17ec938d 100644
--- a/src/library_idbfs.js
+++ b/src/library_idbfs.js
@@ -58,7 +58,7 @@ mergeInto(LibraryManager.library, {
       }
 
       var completed = 0;
-      var done = function(err) {
+      function done(err) {
         if (err) return callback(err);
         if (++completed >= total) {
           return callback(null);
@@ -68,7 +68,7 @@ mergeInto(LibraryManager.library, {
       // create a single transaction to handle and IDB reads / writes we'll need to do
       var db = src.type === 'remote' ? src.db : dst.db;
       var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
-      transaction.onerror = function() { callback(this.error); };
+      transaction.onerror = function transaction_onerror() { callback(this.error); };
       var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
 
       for (var path in create) {
@@ -92,8 +92,8 @@ mergeInto(LibraryManager.library, {
         } else {
           // save file to IDB
           var req = store.put(entry, path);
-          req.onsuccess = function() { done(null); };
-          req.onerror = function() { done(this.error); };
+          req.onsuccess = function req_onsuccess() { done(null); };
+          req.onerror = function req_onerror() { done(this.error); };
         }
       }
 
@@ -117,18 +117,18 @@ mergeInto(LibraryManager.library, {
         } else {
           // delete file from IDB
           var req = store.delete(path);
-          req.onsuccess = function() { done(null); };
-          req.onerror = function() { done(this.error); };
+          req.onsuccess = function req_onsuccess() { done(null); };
+          req.onerror = function req_onerror() { done(this.error); };
         }
       }
     },
     getLocalSet: function(mount, callback) {
       var files = {};
 
-      var isRealDir = function(p) {
+      function isRealDir(p) {
         return p !== '.' && p !== '..';
       };
-      var toAbsolute = function(root) {
+      function toAbsolute(root) {
         return function(p) {
           return PATH.join2(root, p);
         }
@@ -177,17 +177,17 @@ mergeInto(LibraryManager.library, {
       } catch (e) {
         return onerror(e);
       }
-      req.onupgradeneeded = function() {
+      req.onupgradeneeded = function req_onupgradeneeded() {
         db = req.result;
         db.createObjectStore(IDBFS.DB_STORE_NAME);
       };
-      req.onsuccess = function() {
+      req.onsuccess = function req_onsuccess() {
         db = req.result;
         // add to the cache
         IDBFS.dbs[name] = db;
         callback(null, db);
       };
-      req.onerror = function() {
+      req.onerror = function req_onerror() {
         callback(this.error);
       };
     },
@@ -198,10 +198,10 @@ mergeInto(LibraryManager.library, {
         if (err) return callback(err);
 
         var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
-        transaction.onerror = function() { callback(this.error); };
+        transaction.onerror = function transaction_onerror() { callback(this.error); };
 
         var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
-        store.openCursor().onsuccess = function(event) {
+        store.openCursor().onsuccess = function store_openCursor_onsuccess(event) {
           var cursor = event.target.result;
           if (!cursor) {
             return callback(null, { type: 'remote', db: db, files: files });
diff --git a/src/library_sdl.js b/src/library_sdl.js
index 04a663511dbab..0cf6c97a5488f 100644
--- a/src/library_sdl.js
+++ b/src/library_sdl.js
@@ -1301,12 +1301,12 @@ var LibrarySDL = {
   IMG_Load_RW: function(rwopsID, freeSrc) {
     try {
       // stb_image integration support
-      var cleanup = function() {
+      function cleanup() {
         if (rwops && freeSrc) _SDL_FreeRW(rwopsID);
       };
       function addCleanup(func) {
         var old = cleanup;
-        cleanup = function() {
+        cleanup = function added_cleanup() {
           old();
           func();
         }
@@ -1481,7 +1481,7 @@ var LibrarySDL = {
       SDL.audio.buffer = _malloc(SDL.audio.bufferSize);
       
       // Create a callback function that will be routinely called to ask more audio data from the user application.
-      SDL.audio.caller = function() {
+      SDL.audio.caller = function SDL_audio_caller() {
         if (!SDL.audio) {
           return;
         }
@@ -1495,7 +1495,7 @@ var LibrarySDL = {
         SDL.audio.audioOutput['mozSetup'](SDL.audio.channels, SDL.audio.freq); // use string attributes on mozOutput for closure compiler
         SDL.audio.mozBuffer = new Float32Array(totalSamples);
         SDL.audio.nextPlayTime = 0;
-        SDL.audio.pushAudio = function(ptr, size) {
+        SDL.audio.pushAudio = function SDL_audio_pushAudio(ptr, size) {
           var mozBuffer = SDL.audio.mozBuffer;
           // The input audio data for SDL audio is either 8-bit or 16-bit interleaved across channels, output for Mozilla Audio Data API
           // needs to be Float32 interleaved, so perform a sample conversion.
@@ -1862,7 +1862,7 @@ var LibrarySDL = {
     audio.frequency = info.audio.frequency;
     // TODO: handle N loops. Behavior matches Mix_PlayMusic
     audio.loop = loops != 0; 
-    audio['onended'] = function() { // TODO: cache these
+    audio['onended'] = function SDL_audio_onended() { // TODO: cache these
       channelInfo.audio = null;
       if (SDL.channelFinished) {
         Runtime.getFuncWrapper(SDL.channelFinished, 'vi')(channel);
@@ -1889,7 +1889,7 @@ var LibrarySDL = {
         source.loop = false;
         source.buffer = context.createBuffer(numChannels, 1, audio.frequency);
         var jsNode = context.createJavaScriptNode(2048, numChannels, numChannels);
-        jsNode.onaudioprocess = function(event) {
+        jsNode.onaudioprocess = function jsNode_onaudioprocess(event) {
           var buffers = new Array(numChannels);
           for (var i = 0; i < numChannels; ++i) {
             buffers[i] = event.outputBuffer.getChannelData(i);
diff --git a/src/library_sockfs.js b/src/library_sockfs.js
index af29d11bb6286..a57a51a131500 100644
--- a/src/library_sockfs.js
+++ b/src/library_sockfs.js
@@ -208,7 +208,7 @@ mergeInto(LibraryManager.library, {
           }
         };
 
-        var handleMessage = function(data) {
+        function handleMessage(data) {
           assert(typeof data !== 'string' && data.byteLength !== undefined);  // must receive an ArrayBuffer
           data = new Uint8Array(data);  // make a typed array view on the array buffer
 
@@ -247,7 +247,7 @@ mergeInto(LibraryManager.library, {
           });
         } else {
           peer.socket.onopen = handleOpen;
-          peer.socket.onmessage = function(event) {
+          peer.socket.onmessage = function peer_socket_onmessage(event) {
             handleMessage(event.data);
           };
         }
diff --git a/src/preamble.js b/src/preamble.js
index 9e72e7b8264f1..c88e4052dd23f 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -1060,7 +1060,7 @@ Module['writeAsciiToMemory'] = writeAsciiToMemory;
 {{{ reSign }}}
 
 #if PRECISE_I32_MUL
-if (!Math['imul']) Math['imul'] = function(a, b) {
+if (!Math['imul']) Math['imul'] = function imul(a, b) {
   var ah  = a >>> 16;
   var al = a & 0xffff;
   var bh  = b >>> 16;
@@ -1068,14 +1068,14 @@ if (!Math['imul']) Math['imul'] = function(a, b) {
   return (al*bl + ((ah*bl + al*bh) << 16))|0;
 };
 #else
-Math['imul'] = function(a, b) {
+Math['imul'] = function imul(a, b) {
   return (a*b)|0; // fast but imprecise
 };
 #endif
 Math.imul = Math['imul'];
 
 #if TO_FLOAT32
-if (!Math['toFloat32']) Math['toFloat32'] = function(x) {
+if (!Math['toFloat32']) Math['toFloat32'] = function toFloat32(x) {
   return x;
 };
 Math.toFloat32 = Math['toFloat32'];
diff --git a/src/proxyClient.js b/src/proxyClient.js
index 38ea577110bd1..8f4ad7a6f5f32 100644
--- a/src/proxyClient.js
+++ b/src/proxyClient.js
@@ -5,7 +5,7 @@ Module.ctx = Module.canvas.getContext('2d');
 
 var worker = new Worker('{{{ filename }}}.js');
 
-worker.onmessage = function(event) {
+worker.onmessage = function worker_onmessage(event) {
   var data = event.data;
   switch (data.target) {
     case 'stdout': {
diff --git a/src/proxyWorker.js b/src/proxyWorker.js
index 29b2528ddcae4..5d34b9003f756 100644
--- a/src/proxyWorker.js
+++ b/src/proxyWorker.js
@@ -2,12 +2,12 @@
 function EventListener() {
   this.listeners = {};
 
-  this.addEventListener = function(event, func) {
+  this.addEventListener = function addEventListener(event, func) {
     if (!this.listeners[event]) this.listeners[event] = [];
     this.listeners[event].push(func);
   };
 
-  this.fireEvent = function(event) {
+  this.fireEvent = function fireEvent(event) {
     event.preventDefault = function(){};
 
     if (event.type in this.listeners) {
@@ -22,17 +22,17 @@ var window = this;
 var windowExtra = new EventListener();
 for (var x in windowExtra) window[x] = windowExtra[x];
 
-window.close = function() {
+window.close = function window_close() {
   postMessage({ target: 'window', method: 'close' });
 };
 
 var document = new EventListener();
 
-document.createElement = function(what) {
+document.createElement = function document_createElement(what) {
   switch(what) {
     case 'canvas': {
       var canvas = new EventListener();
-      canvas.ensureData = function() {
+      canvas.ensureData = function canvas_ensureData() {
         if (!canvas.data || canvas.data.width !== canvas.width || canvas.data.height !== canvas.height) {
           canvas.data = {
             width: canvas.width,
@@ -42,7 +42,7 @@ document.createElement = function(what) {
           postMessage({ target: 'canvas', op: 'resize', width: canvas.width, height: canvas.height });
         }
       };
-      canvas.getContext = function(type) {
+      canvas.getContext = function canvas_getContext(type) {
         assert(type == '2d');
         return {
           getImageData: function(x, y, w, h) {
@@ -63,7 +63,7 @@ document.createElement = function(what) {
         };
       };
       canvas.boundingClientRect = {};
-      canvas.getBoundingClientRect = function() {
+      canvas.getBoundingClientRect = function canvas_getBoundingClientRect() {
         return {
           width: canvas.boundingClientRect.width,
           height: canvas.boundingClientRect.height,
@@ -89,10 +89,10 @@ Module.canvas = document.createElement('canvas');
 
 Module.setStatus = function(){};
 
-Module.print = function(x) {
+Module.print = function Module_print(x) {
   postMessage({ target: 'stdout', content: x });
 };
-Module.printErr = function(x) {
+Module.printErr = function Module_printErr(x) {
   postMessage({ target: 'stderr', content: x });
 };
 
@@ -112,7 +112,7 @@ function messageResender() {
   }
 }
 
-onmessage = function(message) {
+onmessage = function onmessage(message) {
   if (!calledMain) {
     if (!messageBuffer) {
       messageBuffer = [];
diff --git a/src/runtime.js b/src/runtime.js
index ca2304daf90e5..3f89dc840b7a4 100644
--- a/src/runtime.js
+++ b/src/runtime.js
@@ -394,7 +394,7 @@ var Runtime = {
   getFuncWrapper: function(func, sig) {
     assert(sig);
     if (!Runtime.funcWrappers[func]) {
-      Runtime.funcWrappers[func] = function() {
+      Runtime.funcWrappers[func] = function dynCall_wrapper() {
         return Runtime.dynCall(sig, func, arguments);
       };
     }
@@ -452,7 +452,7 @@ var Runtime = {
       buffer.length = 0;
       return ret;
     }
-    this.processJSString = function(string) {
+    this.processJSString = function processJSString(string) {
       string = unescape(encodeURIComponent(string));
       var ret = [];
       for (var i = 0; i < string.length; i++) {
diff --git a/src/shell.js b/src/shell.js
index be23b3c120c02..b68e16d918e2f 100644
--- a/src/shell.js
+++ b/src/shell.js
@@ -38,17 +38,17 @@ var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIR
 if (ENVIRONMENT_IS_NODE) {
   // Expose functionality in the same simple way that the shells work
   // Note that we pollute the global namespace here, otherwise we break in node
-  Module['print'] = function(x) {
+  Module['print'] = function print(x) {
     process['stdout'].write(x + '\n');
   };
-  Module['printErr'] = function(x) {
+  Module['printErr'] = function printErr(x) {
     process['stderr'].write(x + '\n');
   };
 
   var nodeFS = require('fs');
   var nodePath = require('path');
 
-  Module['read'] = function(filename, binary) {
+  Module['read'] = function read(filename, binary) {
     filename = nodePath['normalize'](filename);
     var ret = nodeFS['readFileSync'](filename);
     // The path is absolute if the normalized version is the same as the resolved.
@@ -60,9 +60,9 @@ if (ENVIRONMENT_IS_NODE) {
     return ret;
   };
 
-  Module['readBinary'] = function(filename) { return Module['read'](filename, true) };
+  Module['readBinary'] = function readBinary(filename) { return Module['read'](filename, true) };
 
-  Module['load'] = function(f) {
+  Module['load'] = function load(f) {
     globalEval(read(f));
   };
 
@@ -77,10 +77,10 @@ else if (ENVIRONMENT_IS_SHELL) {
   if (typeof read != 'undefined') {
     Module['read'] = read;
   } else {
-    Module['read'] = function() { throw 'no read() available (jsc?)' };
+    Module['read'] = function read() { throw 'no read() available (jsc?)' };
   }
 
-  Module['readBinary'] = function(f) {
+  Module['readBinary'] = function readBinary(f) {
     return read(f, 'binary');
   };
 
@@ -93,7 +93,7 @@ else if (ENVIRONMENT_IS_SHELL) {
   this['{{{ EXPORT_NAME }}}'] = Module;
 }
 else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
-  Module['read'] = function(url) {
+  Module['read'] = function read(url) {
     var xhr = new XMLHttpRequest();
     xhr.open('GET', url, false);
     xhr.send(null);
@@ -105,10 +105,10 @@ else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
   }
 
   if (typeof console !== 'undefined') {
-    Module['print'] = function(x) {
+    Module['print'] = function print(x) {
       console.log(x);
     };
-    Module['printErr'] = function(x) {
+    Module['printErr'] = function printErr(x) {
       console.log(x);
     };
   } else {
@@ -136,7 +136,7 @@ function globalEval(x) {
   eval.call(null, x);
 }
 if (!Module['load'] == 'undefined' && Module['read']) {
-  Module['load'] = function(f) {
+  Module['load'] = function load(f) {
     globalEval(Module['read'](f));
   };
 }

From b1a0b6eddf91ff1c1fc85081273c6c8325541113 Mon Sep 17 00:00:00 2001
From: Fraser Adams <fraser.adams@blueyonder.co.uk>
Date: Mon, 4 Nov 2013 18:44:08 +0000
Subject: [PATCH 74/93] Removed RunnerCore import as no longer needed and added
 return self.skip('node is not present') to test_nodejs_sockets_echo if node
 isn't available

---
 tests/test_sockets.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/test_sockets.py b/tests/test_sockets.py
index 6701f6be76f4d..e1caa1507c56c 100644
--- a/tests/test_sockets.py
+++ b/tests/test_sockets.py
@@ -1,5 +1,5 @@
 import os, multiprocessing, subprocess
-from runner import BrowserCore, RunnerCore, path_from_root
+from runner import BrowserCore, path_from_root
 from tools.shared import *
 
 def clean_pids(pids):
@@ -404,7 +404,7 @@ def test_nodejs_sockets_echo(self):
     # This test checks that sockets work when the client code is run in Node.js
     # Run with ./runner.py sockets.test_nodejs_sockets_echo
     if not NODE_JS in JS_ENGINES:
-        return
+        return self.skip('node is not present')
 
     sockets_include = '-I'+path_from_root('tests', 'sockets')
 

From 26e65ea1eebd8c8b3dffd6bfeaa2dda256f6e203 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 4 Nov 2013 14:33:54 -0800
Subject: [PATCH 75/93] add missing parens for select mathop

---
 src/parseTools.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/parseTools.js b/src/parseTools.js
index db95d71f920f7..c4f28184cb1cd 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -2277,7 +2277,7 @@ function processMathop(item) {
       case 'trunc': {
         return '((' + idents[0] + '[0]) & ' + (Math.pow(2, bitsLeft)-1) + ')';
       }
-      case 'select': return idents[0] + ' ? ' + makeCopyI64(idents[1]) + ' : ' + makeCopyI64(idents[2]);
+      case 'select': return '(' + idents[0] + ' ? ' + makeCopyI64(idents[1]) + ' : ' + makeCopyI64(idents[2]) + ')';;
       case 'ptrtoint': return makeI64(idents[0], 0);
       case 'inttoptr': {
         var m = /\(?\[(\d+),\d+\]\)?/.exec(idents[0]);
@@ -2481,7 +2481,7 @@ function processMathop(item) {
     }
     case 'fpext': case 'sext': return idents[0];
     case 'fptrunc': return idents[0];
-    case 'select': return idents[0] + '?' + asmEnsureFloat(idents[1], item.type) + ':' + asmEnsureFloat(idents[2], item.type);
+    case 'select': return '(' + idents[0] + '?' + asmEnsureFloat(idents[1], item.type) + ':' + asmEnsureFloat(idents[2], item.type) + ')';
     case 'ptrtoint': case 'inttoptr': {
       var ret = '';
       if (QUANTUM_SIZE == 1) {

From 71ea2d712934c28b866a19041d3d9459398d9528 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 4 Nov 2013 14:54:38 -0800
Subject: [PATCH 76/93] add testcase for select fix

---
 tests/cases/selectadd.ll | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 tests/cases/selectadd.ll

diff --git a/tests/cases/selectadd.ll b/tests/cases/selectadd.ll
new file mode 100644
index 0000000000000..093032b860b76
--- /dev/null
+++ b/tests/cases/selectadd.ll
@@ -0,0 +1,29 @@
+
+; ModuleID = 'tests/hello_world.bc'
+target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128"
+target triple = "i386-pc-linux-gnu"
+
+@.str = private unnamed_addr constant [15 x i8] c"hello, world!\0A\00", align 1 ; [#uses=1 type=[15 x i8]*]
+
+; [#uses=0]
+define i32 @main() {
+entry:
+  br label %zero
+
+zero:
+  %.3.ph.i757 = phi i8* [ getelementptr ([15 x i8]* @.str, i32 0, i32 add (i32 xor (i32 ptrtoint (i8* getelementptr ([15 x i8]* @.str, i32 0, i32 select (i1 icmp ugt (i32 sub (i32 0, i32 add (i32 ptrtoint ([15 x i8]* @.str to i32), i32 25)), i32 xor (i32 ptrtoint ([15 x i8]* @.str to i32), i32 -1)), i32 sub (i32 0, i32 add (i32 ptrtoint ([15 x i8]* @.str to i32), i32 25)), i32 xor (i32 ptrtoint ([15 x i8]* @.str to i32), i32 -1))) to i32), i32 -1), i32 25)), %entry ], [ getelementptr ([15 x i8]* @.str, i32 0, i32 ptrtoint (i8* getelementptr ([15 x i8]* @.str, i32 0, i32 add (i32 sub (i32 0, i32 ptrtoint ([15 x i8]* @.str to i32)), i32 25)) to i32)), %other ]
+
+  %retval = alloca i32, align 4                   ; [#uses=1 type=i32*]
+  store i32 0, i32* %retval
+  %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([15 x i8]* @.str, i32 0, i32 0)) ; [#uses=0 type=i32]
+  br label %other
+
+other:
+  br i1 0, label %zero, label %last
+
+last:
+  ret i32 1
+}
+
+declare i32 @printf(i8*, ...)
+

From 8cdfca24e3955fd1c340bbc0635e8c442963fe6f Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 4 Nov 2013 17:46:21 -0800
Subject: [PATCH 77/93] pthread_mutexattr_setpshared stub

---
 src/library.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/library.js b/src/library.js
index 106c4f740748f..aec98b2deb8a5 100644
--- a/src/library.js
+++ b/src/library.js
@@ -6876,6 +6876,10 @@ LibraryManager.library = {
   pthread_mutex_trylock: function() {
     return 0;
   },
+  pthread_mutexattr_setpshared: function(attr, pshared) {
+    // XXX implement if/when getpshared is required
+    return 0;
+  },
   pthread_cond_init: function() {},
   pthread_cond_destroy: function() {},
   pthread_cond_broadcast: function() {

From 7016f3ec866da493a82586ea9ea1a0895514b251 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Mon, 4 Nov 2013 18:06:36 -0800
Subject: [PATCH 78/93] fake dladdr

---
 src/library.js | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/library.js b/src/library.js
index aec98b2deb8a5..52b1fc8e12d30 100644
--- a/src/library.js
+++ b/src/library.js
@@ -5295,6 +5295,16 @@ LibraryManager.library = {
     }
   },
 
+  dladdr: function(addr, info) {
+    // report all function pointers as coming from this program itself XXX not really correct in any way
+    var fname = allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL); // XXX leak
+    {{{ makeSetValue('addr', 0, 'fname', 'i32') }}};
+    {{{ makeSetValue('addr', QUANTUM_SIZE, '0', 'i32') }}};
+    {{{ makeSetValue('addr', QUANTUM_SIZE*2, '0', 'i32') }}};
+    {{{ makeSetValue('addr', QUANTUM_SIZE*3, '0', 'i32') }}};
+    return 1;
+  },
+
   // ==========================================================================
   // pwd.h
   // ==========================================================================

From a142589e1d8961b7b4017121f8e6f99eb96b4528 Mon Sep 17 00:00:00 2001
From: bobroberts177 <bobroberts177@gmail.com>
Date: Tue, 5 Nov 2013 10:32:02 -0800
Subject: [PATCH 79/93] Fix dependencies on DNS

---
 src/library.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/library.js b/src/library.js
index e3cdc7c33c399..7b25f750b9ce4 100644
--- a/src/library.js
+++ b/src/library.js
@@ -7312,6 +7312,7 @@ LibraryManager.library = {
   // we're generating fake IP addresses with lookup_name that we can
   // resolve later on with lookup_addr.
   // We do the aliasing in 172.29.*.*, giving us 65536 possibilities.
+  $DNS__deps: ['_inet_pton4_raw', '_inet_pton6_raw'],
   $DNS: {
     address_map: {
       id: 1,
@@ -7319,7 +7320,6 @@ LibraryManager.library = {
       names: {}
     },
 
-    lookup_name__deps: ['_inet_pton4_raw', '_inet_pton6_raw'],
     lookup_name: function (name) {
       // If the name is already a valid ipv4 / ipv6 address, don't generate a fake one.
       var res = __inet_pton4_raw(name);

From f69eed7731abf65fa76adb8878f9ff352ffb25c3 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 5 Nov 2013 10:40:14 -0800
Subject: [PATCH 80/93] support ASM_JS=2 not just in test runner, and remove
 some unneeded uses in test suite

---
 emscripten.py      | 2 +-
 src/settings.js    | 3 ++-
 tests/test_core.py | 2 --
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/emscripten.py b/emscripten.py
index dbea6eb22baaa..5576babae4695 100755
--- a/emscripten.py
+++ b/emscripten.py
@@ -578,7 +578,7 @@ def math_fix(g):
   var HEAPU32 = new global.Uint32Array(buffer);
   var HEAPF32 = new global.Float32Array(buffer);
   var HEAPF64 = new global.Float64Array(buffer);
-''' % (asm_setup, "'use asm';" if not forwarded_json['Types']['hasInlineJS'] and not settings['SIDE_MODULE'] else "'almost asm';") + '\n' + asm_global_vars + '''
+''' % (asm_setup, "'use asm';" if not forwarded_json['Types']['hasInlineJS'] and not settings['SIDE_MODULE'] and settings['ASM_JS'] == 1 else "'almost asm';") + '\n' + asm_global_vars + '''
   var __THREW__ = 0;
   var threwValue = 0;
   var setjmpId = 0;
diff --git a/src/settings.js b/src/settings.js
index d2b47dc88c38f..42e31b3a1f9dc 100644
--- a/src/settings.js
+++ b/src/settings.js
@@ -410,7 +410,8 @@ var HEADLESS = 0; // If 1, will include shim code that tries to 'fake' a browser
 var BENCHMARK = 0; // If 1, will just time how long main() takes to execute, and not
                    // print out anything at all whatsoever. This is useful for benchmarking.
 
-var ASM_JS = 0; // If 1, generate code in asm.js format.
+var ASM_JS = 0; // If 1, generate code in asm.js format. If 2, emits the same code except
+                // for omitting 'use asm'
 
 var PGO = 0; // Enables profile-guided optimization in the form of runtime checks for
              // which functions are actually called. Emits a list during shutdown that you
diff --git a/tests/test_core.py b/tests/test_core.py
index 0cd619b0a5ed2..b2147d4936961 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -3814,7 +3814,6 @@ def test_emscripten_get_now(self):
       self.do_run(open(path_from_root('tests', 'emscripten_get_now.cpp')).read(), 'Timer resolution is good.')
 
   def test_inlinejs(self):
-      if Settings.ASM_JS: Settings.ASM_JS = 2 # skip validation, asm does not support random code
       if not self.is_le32(): return self.skip('le32 needed for inline js')
       src = r'''
         #include <stdio.h>
@@ -3842,7 +3841,6 @@ def test_inlinejs(self):
       self.do_run(src, 'Inline JS is very cool\n3.64\n') # TODO 1\n2\n3\n1\n2\n3\n')
 
   def test_inlinejs2(self):
-      if Settings.ASM_JS: Settings.ASM_JS = 2 # skip validation, asm does not support random code
       if not self.is_le32(): return self.skip('le32 needed for inline js')
       src = r'''
         #include <stdio.h>

From bfc7cac11c17bec7beab71ad5b721432b4d6254c Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 5 Nov 2013 10:59:15 -0800
Subject: [PATCH 81/93] handle errors in ioctl

---
 src/library.js | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/library.js b/src/library.js
index 52b1fc8e12d30..48137540c5478 100644
--- a/src/library.js
+++ b/src/library.js
@@ -8559,7 +8559,13 @@ LibraryManager.library = {
       return -1;
     }
     var arg = {{{ makeGetValue('varargs', '0', 'i32') }}};
-    return FS.ioctl(stream, request, arg);
+
+    try {
+      return FS.ioctl(stream, request, arg);
+    } catch (e) {
+      FS.handleFSError(e);
+      return -1;
+    }
   },
 #endif
 

From 21997d53d6cf2269cf215689e9673a1fe8ab719f Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 5 Nov 2013 13:52:03 -0800
Subject: [PATCH 82/93] stub for pthread_rwlock_init

---
 src/library.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/library.js b/src/library.js
index 48137540c5478..501f766cf4f1f 100644
--- a/src/library.js
+++ b/src/library.js
@@ -6985,6 +6985,10 @@ LibraryManager.library = {
     _pthread_cleanup_push.level = __ATEXIT__.length;
   },
 
+  pthread_rwlock_init: function() {
+    return 0; // XXX
+  },
+
   // ==========================================================================
   // malloc.h
   // ==========================================================================

From c0f26e65da33a6437a04d1adba19966f98fd79cb Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Tue, 5 Nov 2013 17:52:22 -0800
Subject: [PATCH 83/93] use __proto__ when available for new streams, otherwise
 do a full copy; fixes #1759, #1760

---
 src/library_fs.js   | 16 +++++++++++++---
 tests/test_other.py | 43 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+), 3 deletions(-)

diff --git a/src/library_fs.js b/src/library_fs.js
index 16512385f8c5a..5412185ffde46 100644
--- a/src/library_fs.js
+++ b/src/library_fs.js
@@ -361,9 +361,10 @@ mergeInto(LibraryManager.library, {
     // SOCKFS is completed.
     createStream: function(stream, fd_start, fd_end) {
       if (!FS.FSStream) {
-        FS.FSStream = {};
+        FS.FSStream = function(){};
+        FS.FSStream.prototype = {};
         // compatibility
-        Object.defineProperties(FS.FSStream, {
+        Object.defineProperties(FS.FSStream.prototype, {
           object: {
             get: function() { return this.node; },
             set: function(val) { this.node = val; }
@@ -379,7 +380,16 @@ mergeInto(LibraryManager.library, {
           }
         });
       }
-      stream.prototype = FS.FSStream;
+      if (stream.__proto__) {
+        // reuse the object
+        stream.__proto__ = FS.FSStream.prototype;
+      } else {
+        var newStream = new FS.FSStream();
+        for (var p in stream) {
+          newStream[p] = stream[p];
+        }
+        stream = newStream;
+      }
       var fd = FS.nextfd(fd_start, fd_end);
       stream.fd = fd;
       FS.streams[fd] = stream;
diff --git a/tests/test_other.py b/tests/test_other.py
index 86e0eadfecd95..584f67146f957 100644
--- a/tests/test_other.py
+++ b/tests/test_other.py
@@ -2010,6 +2010,49 @@ def test_module_exports_with_closure(self):
     try_delete(path_from_root('tests', 'Module-exports', 'test.js'))
     try_delete(path_from_root('tests', 'Module-exports', 'test.js.map'))
 
+  def test_fs_stream_proto(self):
+    open('src.cpp', 'w').write(r'''
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <string.h>
+
+int main()
+{
+    int file_size = 0;
+    int h = open("src.cpp", O_RDONLY, 0666);
+    if (0 != h)
+    {
+        FILE* file = fdopen(h, "rb");
+        if (0 != file)
+        {
+            fseek(file, 0, SEEK_END);
+            file_size = ftell(file);
+            fseek(file, 0, SEEK_SET);
+        }
+        else
+        {
+            printf("fdopen() failed: %s\n", strerror(errno));
+            return 10;
+        }
+        close(h);
+        printf("File size: %d\n", file_size);
+    }
+    else
+    {
+        printf("open() failed: %s\n", strerror(errno));
+        return 10;
+    }
+    return 0;
+}
+    ''')
+    Popen([PYTHON, EMCC, 'src.cpp', '--embed-file', 'src.cpp']).communicate()
+    for engine in JS_ENGINES:
+      out = run_js('a.out.js', engine=engine, stderr=PIPE, full_output=True)
+      self.assertContained('File size: 722', out)
+
   def test_simd(self):
     self.clear()
     Popen([PYTHON, EMCC, path_from_root('tests', 'linpack.c'), '-O2', '-DSP', '--llvm-opts', '''['-O3', '-vectorize', '-vectorize-loops', '-bb-vectorize-vector-bits=128', '-force-vector-width=4']''']).communicate()

From c4b07c9d429603e492657992f77ad982577d72d9 Mon Sep 17 00:00:00 2001
From: Pierre Renaux <pierre@talansoft.com>
Date: Wed, 6 Nov 2013 18:44:32 +0800
Subject: [PATCH 84/93] [library_glut.js]: Handle DELETE & BACKSPACE correctly
 ;

---
 src/library_glut.js | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/library_glut.js b/src/library_glut.js
index fefe7bd31ff19..0d843fe75b7e9 100644
--- a/src/library_glut.js
+++ b/src/library_glut.js
@@ -59,6 +59,9 @@ var LibraryGLUT = {
     getSpecialKey: function(keycode) {
         var key = null;
         switch (keycode) {
+          case 8:  key = 120 /* backspace */; break;
+          case 46: key = 111 /* delete */; break;
+
           case 0x70 /*DOM_VK_F1*/: key = 1 /* GLUT_KEY_F1 */; break;
           case 0x71 /*DOM_VK_F2*/: key = 2 /* GLUT_KEY_F2 */; break;
           case 0x72 /*DOM_VK_F3*/: key = 3 /* GLUT_KEY_F3 */; break;
@@ -228,14 +231,14 @@ var LibraryGLUT = {
       if (delta < 0) {
         button = 4; // wheel down
       }
-      
+
       if (GLUT.mouseFunc) {
         event.preventDefault();
         GLUT.saveModifiers(event);
         Runtime.dynCall('viiii', GLUT.mouseFunc, [button, 0/*GLUT_DOWN*/, Browser.mouseX, Browser.mouseY]);
       }
     },
-    
+
     // TODO add fullscreen API ala:
     // http://johndyer.name/native-fullscreen-javascript-api-plus-jquery-plugin/
     onFullScreenEventChange: function(event) {
@@ -304,7 +307,7 @@ var LibraryGLUT = {
       // Firefox
       window.addEventListener("DOMMouseScroll", GLUT.onMouseWheel, true);
     }
-    
+
     Browser.resizeListeners.push(function(width, height) {
       if (GLUT.reshapeFunc) {
       	Runtime.dynCall('vii', GLUT.reshapeFunc, [width, height]);

From 1e4e155f25751f87b7b246448f98644c5f5c535c Mon Sep 17 00:00:00 2001
From: Pierre Renaux <pierre@talansoft.com>
Date: Wed, 6 Nov 2013 18:47:26 +0800
Subject: [PATCH 85/93] [thirdparty/lzma.js]: Fixed doit.sh so that it compiles
 on Windows using MingW's GCC & Bash ;

---
 .gitignore                  |  3 ++-
 third_party/lzma.js/doit.sh | 11 +++++++++--
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/.gitignore b/.gitignore
index 747394e7459d7..f5f3313c63d77 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,7 +6,7 @@ src/relooper*.js
 
 node_modules/
 
-# Ignore generated files 
+# Ignore generated files
 src/relooper.js
 src/relooper.js.raw.js
 src/relooper/*.o
@@ -18,3 +18,4 @@ tests/freetype/objs/*.lo
 
 third_party/lzma.js/lzip/*.o
 third_party/lzma.js/lzma-native
+third_party/lzma.js/lzma-native.exe
diff --git a/third_party/lzma.js/doit.sh b/third_party/lzma.js/doit.sh
index 1f5306516f196..6046022ccb1d5 100755
--- a/third_party/lzma.js/doit.sh
+++ b/third_party/lzma.js/doit.sh
@@ -5,7 +5,14 @@ export CXX=`../../../em-config LLVM_ROOT`/clang++
 echo "native"
 make clean
 DECODER_ONLY=0 make lzip -j 4 # native build
-mv lzip ../lzma-native
+case `uname` in
+    *_NT*)
+        mv lzip.exe ../lzma-native.exe
+        ;;
+    *)
+        mv lzip ../lzma-native
+        ;;
+esac
 
 exit # just build natively, that's it
 
@@ -18,7 +25,7 @@ echo "bitcode decoder only"
 make clean
 DECODER_ONLY=1 ../../../emmake make lzip -j 4
 mv lzip lzip-decoder.bc
- 
+
 cd ..
 
 echo "javascript full"

From 44af976a44bc194b985fdb880f99a7feff133b5a Mon Sep 17 00:00:00 2001
From: Bruce Mitchener <bruce.mitchener@gmail.com>
Date: Thu, 7 Nov 2013 15:49:37 +0700
Subject: [PATCH 86/93] Update libcxx to 194185, 2013-11-07.

This brings C++14 support.
---
 system/include/libcxx/CREDITS.TXT             |  10 +-
 system/include/libcxx/__bit_reference         |  16 +-
 system/include/libcxx/__config                | 112 ++-
 system/include/libcxx/__debug                 |  29 +-
 system/include/libcxx/__functional_03         |  14 +-
 system/include/libcxx/__functional_base       | 178 ++++-
 system/include/libcxx/__functional_base_03    |   2 +-
 system/include/libcxx/__hash_table            |  50 +-
 system/include/libcxx/__locale                |  40 +-
 system/include/libcxx/__mutex_base            |  35 +-
 system/include/libcxx/__split_buffer          |  18 +-
 system/include/libcxx/__std_stream            |  14 +
 system/include/libcxx/__tree                  |  61 +-
 system/include/libcxx/__tuple                 |  30 +-
 system/include/libcxx/__tuple_03              |   4 +-
 system/include/libcxx/__undef_min_max         |   8 +
 system/include/libcxx/algorithm               | 231 +++---
 system/include/libcxx/array                   |  30 +-
 system/include/libcxx/bitset                  |   8 +-
 system/include/libcxx/chrono                  |  68 +-
 system/include/libcxx/cmath                   |  48 +-
 system/include/libcxx/codecvt                 |  39 +-
 system/include/libcxx/complex                 |  55 +-
 system/include/libcxx/cstddef                 |   2 +-
 system/include/libcxx/cstdio                  |   9 +-
 system/include/libcxx/cstdlib                 |   2 +-
 system/include/libcxx/cwchar                  |   2 +-
 system/include/libcxx/deque                   |  38 +-
 system/include/libcxx/dynarray                | 311 ++++++++
 system/include/libcxx/exception               |   8 +-
 system/include/libcxx/ext/__hash              |   6 +-
 system/include/libcxx/ext/hash_map            |  34 +-
 system/include/libcxx/ext/hash_set            |  10 +-
 system/include/libcxx/forward_list            |  40 +-
 system/include/libcxx/fstream                 |   8 +-
 system/include/libcxx/functional              | 370 +++++-----
 system/include/libcxx/future                  | 122 ++-
 system/include/libcxx/initializer_list        |  35 +-
 system/include/libcxx/iomanip                 | 147 ++++
 system/include/libcxx/ios                     |  40 +-
 system/include/libcxx/iosfwd                  |  38 +-
 system/include/libcxx/istream                 |  21 +-
 system/include/libcxx/iterator                | 525 +++----------
 system/include/libcxx/limits                  |  12 +-
 system/include/libcxx/list                    |  36 +-
 system/include/libcxx/locale                  | 543 ++++----------
 system/include/libcxx/map                     | 380 +++++++---
 system/include/libcxx/memory                  | 146 ++--
 system/include/libcxx/mutex                   |   4 +-
 system/include/libcxx/new                     |  57 +-
 system/include/libcxx/numeric                 |   4 +-
 system/include/libcxx/optional                | 697 ++++++++++++++++++
 system/include/libcxx/ostream                 |  25 +-
 system/include/libcxx/queue                   |  10 +-
 system/include/libcxx/random                  | 104 +--
 system/include/libcxx/ratio                   |  22 +-
 system/include/libcxx/readme.txt              |   2 +-
 system/include/libcxx/regex                   |  43 +-
 system/include/libcxx/scoped_allocator        |   2 +-
 system/include/libcxx/set                     | 168 ++++-
 system/include/libcxx/shared_mutex            | 419 +++++++++++
 system/include/libcxx/sstream                 |   8 +-
 system/include/libcxx/stack                   |   6 +-
 system/include/libcxx/streambuf               |  10 +-
 system/include/libcxx/string                  | 696 +++++++++--------
 system/include/libcxx/support/ibm/limits.h    |  99 +++
 system/include/libcxx/support/ibm/support.h   |  54 ++
 system/include/libcxx/support/ibm/xlocale.h   | 326 ++++++++
 .../libcxx/support/win32/limits_win32.h       |  12 +-
 .../libcxx/support/win32/locale_win32.h       |  30 +-
 .../include/libcxx/support/win32/math_win32.h |   2 +
 system/include/libcxx/support/win32/support.h |   7 +-
 system/include/libcxx/system_error            |  22 +-
 system/include/libcxx/thread                  |  15 +-
 system/include/libcxx/tuple                   | 117 +--
 system/include/libcxx/type_traits             | 462 ++++++------
 system/include/libcxx/typeindex               |   6 +-
 system/include/libcxx/unordered_map           | 263 ++++---
 system/include/libcxx/unordered_set           |  81 +-
 system/include/libcxx/utility                 |  40 +-
 system/include/libcxx/valarray                |  46 +-
 system/include/libcxx/vector                  | 205 +++---
 system/lib/libcxx/CREDITS.TXT                 |  10 +-
 system/lib/libcxx/algorithm.cpp               |   1 +
 system/lib/libcxx/debug.cpp                   | 108 +--
 system/lib/libcxx/exception.cpp               | 104 ++-
 system/lib/libcxx/future.cpp                  |   6 +
 system/lib/libcxx/ios.cpp                     |   9 +-
 system/lib/libcxx/iostream.cpp                |  16 +-
 system/lib/libcxx/locale.cpp                  |  49 +-
 system/lib/libcxx/mutex.cpp                   |   3 +
 system/lib/libcxx/new.cpp                     |  54 +-
 system/lib/libcxx/optional.cpp                |  25 +
 system/lib/libcxx/random.cpp                  |  26 +
 system/lib/libcxx/readme.txt                  |   2 +-
 system/lib/libcxx/shared_mutex.cpp            | 101 +++
 system/lib/libcxx/stdexcept.cpp               |  18 +-
 system/lib/libcxx/string.cpp                  |   4 +-
 system/lib/libcxx/strstream.cpp               |  14 +-
 .../lib/libcxx/support/win32/locale_win32.cpp |  25 +-
 system/lib/libcxx/support/win32/support.cpp   |  69 +-
 system/lib/libcxx/system_error.cpp            |   1 +
 system/lib/libcxx/thread.cpp                  |  10 +-
 system/lib/libcxx/typeinfo.cpp                |  15 +-
 system/lib/libcxx/valarray.cpp                |   2 +
 105 files changed, 5828 insertions(+), 2893 deletions(-)
 create mode 100644 system/include/libcxx/dynarray
 create mode 100644 system/include/libcxx/optional
 create mode 100644 system/include/libcxx/shared_mutex
 create mode 100644 system/include/libcxx/support/ibm/limits.h
 create mode 100644 system/include/libcxx/support/ibm/support.h
 create mode 100644 system/include/libcxx/support/ibm/xlocale.h
 create mode 100644 system/lib/libcxx/optional.cpp
 create mode 100644 system/lib/libcxx/shared_mutex.cpp

diff --git a/system/include/libcxx/CREDITS.TXT b/system/include/libcxx/CREDITS.TXT
index 5e4d14ec20a45..368b526fcc1b5 100644
--- a/system/include/libcxx/CREDITS.TXT
+++ b/system/include/libcxx/CREDITS.TXT
@@ -31,7 +31,7 @@ D: FreeBSD and Solaris ports, libcxxrt support, some atomics work.
 N: Marshall Clow
 E: mclow.lists@gmail.com
 E: marshall@idio.com
-D: Minor patches and bug fixes.
+D: C++14 support, patches and bug fixes.
 
 N: Bill Fisher
 E: william.w.fisher@gmail.com
@@ -76,6 +76,10 @@ N: Bjorn Reese
 E: breese@users.sourceforge.net
 D: Initial regex prototype
 
+N: Nico Rieck
+E: nico.rieck@gmail.com
+D: Windows fixes
+
 N: Jonathan Sauer
 D: Minor patches, mostly related to constexpr
 
@@ -105,6 +109,10 @@ N: Zhang Xiongpang
 E: zhangxiongpang@gmail.com
 D: Minor patches and bug fixes.
 
+N: Xing Xue
+E: xingxue@ca.ibm.com
+D: AIX port
+
 N: Zhihao Yuan
 E: lichray@gmail.com
 D: Standard compatibility fixes.
diff --git a/system/include/libcxx/__bit_reference b/system/include/libcxx/__bit_reference
index 857dd5a43036c..37b7923712806 100644
--- a/system/include/libcxx/__bit_reference
+++ b/system/include/libcxx/__bit_reference
@@ -40,7 +40,7 @@ class __bit_reference
     __storage_pointer __seg_;
     __storage_type    __mask_;
 
-#if defined(__clang__)
+#if defined(__clang__) || defined(__IBMCPP__) || defined(_LIBCPP_MSVC)
     friend typename _Cp::__self;
 #else
     friend class _Cp::__self;
@@ -82,7 +82,7 @@ class __bit_reference<_Cp, false>
 };
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(__bit_reference<_Cp> __x, __bit_reference<_Cp> __y) _NOEXCEPT
 {
@@ -92,7 +92,7 @@ swap(__bit_reference<_Cp> __x, __bit_reference<_Cp> __y) _NOEXCEPT
 }
 
 template <class _Cp, class _Dp>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(__bit_reference<_Cp> __x, __bit_reference<_Dp> __y) _NOEXCEPT
 {
@@ -102,7 +102,7 @@ swap(__bit_reference<_Cp> __x, __bit_reference<_Dp> __y) _NOEXCEPT
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(__bit_reference<_Cp> __x, bool& __y) _NOEXCEPT
 {
@@ -112,7 +112,7 @@ swap(__bit_reference<_Cp> __x, bool& __y) _NOEXCEPT
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(bool& __x, __bit_reference<_Cp> __y) _NOEXCEPT
 {
@@ -130,7 +130,7 @@ class __bit_const_reference
     __storage_pointer        __seg_;
     __storage_type __mask_;
 
-#if defined(__clang__)
+#if defined(__clang__) || defined(__IBMCPP__) || defined(_LIBCPP_MSVC)
     friend typename _Cp::__self;
 #else
     friend class _Cp::__self;
@@ -379,7 +379,7 @@ __fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value_)
 {
@@ -1222,7 +1222,7 @@ private:
     __bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT
         : __seg_(__s), __ctz_(__ctz) {}
 
-#if defined(__clang__)
+#if defined(__clang__) || defined(__IBMCPP__) || defined(_LIBCPP_MSVC)
     friend typename _Cp::__self;
 #else
     friend class _Cp::__self;
diff --git a/system/include/libcxx/__config b/system/include/libcxx/__config
index b1f0d9586ec4e..a45b02de035c7 100644
--- a/system/include/libcxx/__config
+++ b/system/include/libcxx/__config
@@ -79,8 +79,14 @@
 #  endif
 #  if defined(_MSC_VER) && !defined(__clang__)
 #    define _LIBCPP_MSVC // Using Microsoft Visual C++ compiler
+#    define _LIBCPP_TOSTRING2(x) #x
+#    define _LIBCPP_TOSTRING(x) _LIBCPP_TOSTRING2(x)
+#    define _LIBCPP_WARNING(x) __pragma(message(__FILE__ "(" _LIBCPP_TOSTRING(__LINE__) ") : warning note: " x))
+#  endif
+#  // If mingw not explicitly detected, assume using MS C runtime only.
+#  ifndef __MINGW32__
+#    define _LIBCPP_MSVCRT // Using Microsoft's C Runtime library
 #  endif
-#  define _LIBCPP_MSVCRT // Using Microsoft's C Runtime library
 #endif  // _WIN32
 
 #ifdef __linux__
@@ -132,6 +138,9 @@
 # define _LIBCPP_TYPE_VIS
 #endif
 
+#define _LIBCPP_TYPE_VIS_ONLY
+#define _LIBCPP_FUNC_VIS_ONLY
+
 #ifndef _LIBCPP_INLINE_VISIBILITY
 # ifdef _LIBCPP_MSVC
 #  define _LIBCPP_INLINE_VISIBILITY __forceinline
@@ -172,6 +181,14 @@
 #  endif
 #endif
 
+#ifndef _LIBCPP_TYPE_VIS_ONLY
+# define _LIBCPP_TYPE_VIS_ONLY _LIBCPP_TYPE_VIS
+#endif
+
+#ifndef _LIBCPP_FUNC_VIS_ONLY
+# define _LIBCPP_FUNC_VIS_ONLY _LIBCPP_FUNC_VIS
+#endif
+
 #ifndef _LIBCPP_INLINE_VISIBILITY
 #define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__visibility__("hidden"), __always_inline__))
 #endif
@@ -180,10 +197,6 @@
 #define _LIBCPP_EXCEPTION_ABI _LIBCPP_TYPE_VIS
 #endif
 
-#ifndef _LIBCPP_CANTTHROW
-#define _LIBCPP_CANTTHROW __attribute__ ((__nothrow__))
-#endif
-
 #ifndef _LIBCPP_ALWAYS_INLINE
 #define _LIBCPP_ALWAYS_INLINE  __attribute__ ((__visibility__("hidden"), __always_inline__))
 #endif
@@ -408,6 +421,7 @@ using namespace _LIBCPP_NAMESPACE __attribute__((__strong__));
 #define _LIBCPP_HAS_NO_CONSTEXPR
 #define _LIBCPP_HAS_NO_UNICODE_CHARS
 #define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
+#define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 #define __alignof__ __alignof
 #define _LIBCPP_NORETURN __declspec(noreturn)
 #define _ALIGNAS(x) __declspec(align(x))
@@ -420,10 +434,43 @@ using namespace _LIBCPP_NAMESPACE __attribute__((__strong__));
 #define _LIBCPP_END_NAMESPACE_STD  }
 #define _VSTD std
 
+#  define _LIBCPP_WEAK
+namespace std {
+}
+
+#elif defined(__IBMCPP__)
+
+#define _ALIGNAS(x) __attribute__((__aligned__(x)))
+#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
+#define _ATTRIBUTE(x) __attribute__((x))
+#define _LIBCPP_NORETURN __attribute__((noreturn))
+
+#define _NOEXCEPT throw()
+#define _NOEXCEPT_(x)
+
+#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#define _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
+#define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#define _LIBCPP_HAS_NO_NULLPTR
+#define _LIBCPP_HAS_NO_UNICODE_CHARS
+#define _LIBCPP_HAS_NO_STRONG_ENUMS
+#define _LIBCPP_HAS_IS_BASE_OF
+
+#if defined(_AIX)
+#define __MULTILOCALE_API
+#endif
+
+#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {inline namespace _LIBCPP_NAMESPACE {
+#define _LIBCPP_END_NAMESPACE_STD  } }
+#define _VSTD std::_LIBCPP_NAMESPACE
+
 namespace std {
+  inline namespace _LIBCPP_NAMESPACE {
+  }
 }
 
-#endif // __clang__ || __GNUC__ || _LIBCPP_MSVC
+#endif // __clang__ || __GNUC___ || _MSC_VER || __IBMCPP__
 
 #ifdef _LIBCPP_HAS_NO_UNICODE_CHARS
 typedef unsigned short char16_t;
@@ -486,8 +533,23 @@ template <unsigned> struct __static_assert_check {};
 #define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x)
 #endif  // _LIBCPP_HAS_NO_STRONG_ENUMS
 
+#ifdef _LIBCPP_DEBUG
+#   if _LIBCPP_DEBUG == 0
+#       define _LIBCPP_DEBUG_LEVEL 1
+#   elif _LIBCPP_DEBUG == 1
+#       define _LIBCPP_DEBUG_LEVEL 2
+#   else
+#       error Supported values for _LIBCPP_DEBUG are 0 and 1
+#   endif
+#   define _LIBCPP_EXTERN_TEMPLATE(...)
+#endif
+
 #ifndef _LIBCPP_EXTERN_TEMPLATE
-#define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
+#define _LIBCPP_EXTERN_TEMPLATE(...)
+#endif
+
+#ifndef _LIBCPP_EXTERN_TEMPLATE2
+#define _LIBCPP_EXTERN_TEMPLATE2(...) extern template __VA_ARGS__;
 #endif
 
 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(_WIN32) || defined(__sun__) || defined(__NetBSD__)
@@ -505,16 +567,6 @@ template <unsigned> struct __static_assert_check {};
 #define _LIBCPP_WCTYPE_IS_MASK
 #endif
 
-#ifdef _LIBCPP_DEBUG2
-#   if _LIBCPP_DEBUG2 == 0
-#       define _LIBCPP_DEBUG_LEVEL 1
-#   elif _LIBCPP_DEBUG2 == 1
-#       define _LIBCPP_DEBUG_LEVEL 2
-#   else
-#       error Supported values for _LIBCPP_DEBUG2 are 0 and 1
-#   endif
-#endif
-
 #ifndef _LIBCPP_STD_VER
 #  if  __cplusplus <= 201103L
 #    define _LIBCPP_STD_VER 11
@@ -523,10 +575,36 @@ template <unsigned> struct __static_assert_check {};
 #  endif
 #endif  // _LIBCPP_STD_VER
 
+#if _LIBCPP_STD_VER > 11
+#define _LIBCPP_DEPRECATED [[deprecated]]
+#else
+#define _LIBCPP_DEPRECATED
+#endif
+
 #if _LIBCPP_STD_VER <= 11
 #define _LIBCPP_CONSTEXPR_AFTER_CXX11
+#define _LIBCPP_EXPLICIT_AFTER_CXX11
+#define _LIBCPP_DEPRECATED_AFTER_CXX11
 #else
 #define _LIBCPP_CONSTEXPR_AFTER_CXX11 constexpr
+#define _LIBCPP_EXPLICIT_AFTER_CXX11 explicit
+#define _LIBCPP_DEPRECATED_AFTER_CXX11 [[deprecated]]
+#endif
+
+// Try to find out if RTTI is disabled.
+// g++ and cl.exe have RTTI on by default and define a macro when it is.
+// g++ only defines the macro in 4.3.2 and onwards.
+#if !defined(_LIBCPP_NO_RTTI)
+#  if defined(__GNUG__) && (__GNUC__ >= 4 && \
+   (__GNUC_MINOR__ >= 3 || __GNUC_PATCHLEVEL__ >= 2)) && !defined(__GXX_RTTI)
+#    define _LIBCPP_NO_RTTI
+#  elif (defined(_MSC_VER) && !defined(__clang__)) && !defined(_CPPRTTI)
+#    define _LIBCPP_NO_RTTI
+#  endif
+#endif
+
+#ifndef _LIBCPP_WEAK
+#  define _LIBCPP_WEAK __attribute__((__weak__))
 #endif
 
 #endif  // _LIBCPP_CONFIG
diff --git a/system/include/libcxx/__debug b/system/include/libcxx/__debug
index bac580cfa8005..f1805adcfe4cd 100644
--- a/system/include/libcxx/__debug
+++ b/system/include/libcxx/__debug
@@ -11,6 +11,10 @@
 #ifndef _LIBCPP_DEBUG_H
 #define _LIBCPP_DEBUG_H
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
 #if _LIBCPP_DEBUG_LEVEL >= 1
 
 #   include <cstdlib>
@@ -24,10 +28,6 @@
 
 #if _LIBCPP_DEBUG_LEVEL >= 2
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
-#endif
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 struct _LIBCPP_TYPE_VIS __c_node;
@@ -38,8 +38,15 @@ struct _LIBCPP_TYPE_VIS __i_node
     __i_node* __next_;
     __c_node* __c_;
 
+#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
     __i_node(const __i_node&) = delete;
     __i_node& operator=(const __i_node&) = delete;
+#else
+private:
+    __i_node(const __i_node&);
+    __i_node& operator=(const __i_node&);
+public:
+#endif
     _LIBCPP_INLINE_VISIBILITY
     __i_node(void* __i, __i_node* __next, __c_node* __c)
         : __i_(__i), __next_(__next), __c_(__c) {}
@@ -54,8 +61,15 @@ struct _LIBCPP_TYPE_VIS __c_node
     __i_node** end_;
     __i_node** cap_;
 
+#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
     __c_node(const __c_node&) = delete;
     __c_node& operator=(const __c_node&) = delete;
+#else
+private:
+    __c_node(const __c_node&);
+    __c_node& operator=(const __c_node&);
+public:
+#endif
     _LIBCPP_INLINE_VISIBILITY
     __c_node(void* __c, __c_node* __next)
         : __c_(__c), __next_(__next), beg_(nullptr), end_(nullptr), cap_(nullptr) {}
@@ -134,8 +148,15 @@ class _LIBCPP_TYPE_VIS __libcpp_db
 
     __libcpp_db();
 public:
+#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
     __libcpp_db(const __libcpp_db&) = delete;
     __libcpp_db& operator=(const __libcpp_db&) = delete;
+#else
+private:
+    __libcpp_db(const __libcpp_db&);
+    __libcpp_db& operator=(const __libcpp_db&);
+public:
+#endif
     ~__libcpp_db();
 
     class __db_c_iterator;
diff --git a/system/include/libcxx/__functional_03 b/system/include/libcxx/__functional_03
index 662928d83b3bf..f9a3d9766255e 100644
--- a/system/include/libcxx/__functional_03
+++ b/system/include/libcxx/__functional_03
@@ -203,7 +203,7 @@ class _LIBCPP_EXCEPTION_ABI bad_function_call
 {
 };
 
-template<class _Fp> class _LIBCPP_TYPE_VIS function; // undefined
+template<class _Fp> class _LIBCPP_TYPE_VIS_ONLY function; // undefined
 
 namespace __function
 {
@@ -644,7 +644,7 @@ __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::target_type() const
 }  // __function
 
 template<class _Rp>
-class _LIBCPP_TYPE_VIS function<_Rp()>
+class _LIBCPP_TYPE_VIS_ONLY function<_Rp()>
 {
     typedef __function::__base<_Rp()> __base;
     aligned_storage<3*sizeof(void*)>::type __buf_;
@@ -928,7 +928,7 @@ function<_Rp()>::target() const
 #endif  // _LIBCPP_NO_RTTI
 
 template<class _Rp, class _A0>
-class _LIBCPP_TYPE_VIS function<_Rp(_A0)>
+class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_A0)>
     : public unary_function<_A0, _Rp>
 {
     typedef __function::__base<_Rp(_A0)> __base;
@@ -1230,7 +1230,7 @@ function<_Rp(_A0)>::target() const
 #endif  // _LIBCPP_NO_RTTI
 
 template<class _Rp, class _A0, class _A1>
-class _LIBCPP_TYPE_VIS function<_Rp(_A0, _A1)>
+class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_A0, _A1)>
     : public binary_function<_A0, _A1, _Rp>
 {
     typedef __function::__base<_Rp(_A0, _A1)> __base;
@@ -1532,7 +1532,7 @@ function<_Rp(_A0, _A1)>::target() const
 #endif  // _LIBCPP_NO_RTTI
 
 template<class _Rp, class _A0, class _A1, class _A2>
-class _LIBCPP_TYPE_VIS function<_Rp(_A0, _A1, _A2)>
+class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_A0, _A1, _A2)>
 {
     typedef __function::__base<_Rp(_A0, _A1, _A2)> __base;
     aligned_storage<3*sizeof(void*)>::type __buf_;
@@ -1860,11 +1860,11 @@ swap(function<_Fp>& __x, function<_Fp>& __y)
 {return __x.swap(__y);}
 
 template<class _Tp> struct __is_bind_expression : public false_type {};
-template<class _Tp> struct _LIBCPP_TYPE_VIS is_bind_expression
+template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_bind_expression
     : public __is_bind_expression<typename remove_cv<_Tp>::type> {};
 
 template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
-template<class _Tp> struct _LIBCPP_TYPE_VIS is_placeholder
+template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_placeholder
     : public __is_placeholder<typename remove_cv<_Tp>::type> {};
 
 namespace placeholders
diff --git a/system/include/libcxx/__functional_base b/system/include/libcxx/__functional_base
index 2bc2d2c1466f4..1c337d8b4bf79 100644
--- a/system/include/libcxx/__functional_base
+++ b/system/include/libcxx/__functional_base
@@ -15,6 +15,7 @@
 #include <type_traits>
 #include <typeinfo>
 #include <exception>
+#include <new>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
@@ -23,21 +24,21 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Arg, class _Result>
-struct _LIBCPP_TYPE_VIS unary_function
+struct _LIBCPP_TYPE_VIS_ONLY unary_function
 {
     typedef _Arg    argument_type;
     typedef _Result result_type;
 };
 
 template <class _Arg1, class _Arg2, class _Result>
-struct _LIBCPP_TYPE_VIS binary_function
+struct _LIBCPP_TYPE_VIS_ONLY binary_function
 {
     typedef _Arg1   first_argument_type;
     typedef _Arg2   second_argument_type;
     typedef _Result result_type;
 };
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS hash;
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY hash;
 
 template <class _Tp>
 struct __has_result_type
@@ -55,22 +56,75 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS less : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS_ONLY less : binary_function<_Tp, _Tp, bool>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 
+    bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x < __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS less<void>
+struct _LIBCPP_TYPE_VIS_ONLY less<void>
 {
-    template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY
+    template <class _T1, class _T2> 
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
+// addressof
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp*
+addressof(_Tp& __x) _NOEXCEPT
+{
+    return (_Tp*)&reinterpret_cast<const volatile char&>(__x);
+}
+
+#if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF)
+// Objective-C++ Automatic Reference Counting uses qualified pointers
+// that require special addressof() signatures. When
+// _LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF is defined, the compiler
+// itself is providing these definitions. Otherwise, we provide them.
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__strong _Tp*
+addressof(__strong _Tp& __x) _NOEXCEPT
+{
+  return &__x;
+}
+
+#ifdef _LIBCPP_HAS_OBJC_ARC_WEAK
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__weak _Tp*
+addressof(__weak _Tp& __x) _NOEXCEPT
+{
+  return &__x;
+}
+#endif
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__autoreleasing _Tp*
+addressof(__autoreleasing _Tp& __x) _NOEXCEPT
+{
+  return &__x;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__unsafe_unretained _Tp*
+addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT
+{
+  return &__x;
+}
+#endif
+
 #ifdef _LIBCPP_HAS_NO_VARIADICS
 
 #include <__functional_base_03>
@@ -366,7 +420,7 @@ struct __invoke_return
 };
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS reference_wrapper
+class _LIBCPP_TYPE_VIS_ONLY reference_wrapper
     : public __weak_result_type<_Tp>
 {
 public:
@@ -377,7 +431,8 @@ private:
 
 public:
     // construct/copy/destroy
-    _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) _NOEXCEPT : __f_(&__f) {}
+    _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) _NOEXCEPT
+        : __f_(_VSTD::addressof(__f)) {}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     private: reference_wrapper(type&&); public: // = delete; // do not bind to temps
 #endif
@@ -450,6 +505,111 @@ template <class _Tp> void cref(const _Tp&&);// = delete;
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
+#if _LIBCPP_STD_VER > 11
+template <class _Tp1, class _Tp2 = void>
+struct __is_transparent
+{
+private:
+    struct __two {char __lx; char __lxx;};
+    template <class _Up> static __two __test(...);
+    template <class _Up> static char __test(typename _Up::is_transparent* = 0);
+public:
+    static const bool value = sizeof(__test<_Tp1>(0)) == 1;
+};
+#endif
+
+// allocator_arg_t
+
+struct _LIBCPP_TYPE_VIS_ONLY allocator_arg_t { };
+
+#if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MEMORY)
+extern const allocator_arg_t allocator_arg;
+#else
+constexpr allocator_arg_t allocator_arg = allocator_arg_t();
+#endif
+
+// uses_allocator
+
+template <class _Tp>
+struct __has_allocator_type
+{
+private:
+    struct __two {char __lx; char __lxx;};
+    template <class _Up> static __two __test(...);
+    template <class _Up> static char __test(typename _Up::allocator_type* = 0);
+public:
+    static const bool value = sizeof(__test<_Tp>(0)) == 1;
+};
+
+template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value>
+struct __uses_allocator
+    : public integral_constant<bool,
+        is_convertible<_Alloc, typename _Tp::allocator_type>::value>
+{
+};
+
+template <class _Tp, class _Alloc>
+struct __uses_allocator<_Tp, _Alloc, false>
+    : public false_type
+{
+};
+
+template <class _Tp, class _Alloc>
+struct _LIBCPP_TYPE_VIS_ONLY uses_allocator
+    : public __uses_allocator<_Tp, _Alloc>
+{
+};
+
+#ifndef _LIBCPP_HAS_NO_VARIADICS
+
+// allocator construction
+
+template <class _Tp, class _Alloc, class ..._Args>
+struct __uses_alloc_ctor_imp
+{
+    static const bool __ua = uses_allocator<_Tp, _Alloc>::value;
+    static const bool __ic =
+        is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
+    static const int value = __ua ? 2 - __ic : 0;
+};
+
+template <class _Tp, class _Alloc, class ..._Args>
+struct __uses_alloc_ctor
+    : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
+    {};
+
+template <class _Tp, class _Allocator, class... _Args>
+inline _LIBCPP_INLINE_VISIBILITY
+void __user_alloc_construct_impl (integral_constant<int, 0>, _Tp *__storage, const _Allocator &, _Args &&... __args )
+{
+    new (__storage) _Tp (_VSTD::forward<_Args>(__args)...);
+}
+
+template <class _Tp, class _Allocator, class... _Args>
+inline _LIBCPP_INLINE_VISIBILITY
+void __user_alloc_construct_impl (integral_constant<int, 1>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
+{
+    new (__storage) _Tp (allocator_arg, __a, _VSTD::forward<_Args>(__args)...);
+}
+
+template <class _Tp, class _Allocator, class... _Args>
+inline _LIBCPP_INLINE_VISIBILITY
+void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
+{
+    new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a);
+}
+
+template <class _Tp, class _Allocator, class... _Args>
+inline _LIBCPP_INLINE_VISIBILITY
+void __user_alloc_construct (_Tp *__storage, const _Allocator &__a, _Args &&... __args)
+{ 
+    __user_alloc_construct_impl( 
+             __uses_alloc_ctor<_Tp, _Allocator>(), 
+             __storage, __a, _VSTD::forward<_Args>(__args)...
+        );
+}
+#endif  // _LIBCPP_HAS_NO_VARIADICS
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_FUNCTIONAL_BASE
diff --git a/system/include/libcxx/__functional_base_03 b/system/include/libcxx/__functional_base_03
index 11165a964d185..296dd8db30728 100644
--- a/system/include/libcxx/__functional_base_03
+++ b/system/include/libcxx/__functional_base_03
@@ -996,7 +996,7 @@ struct __invoke_return2
 };
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS reference_wrapper
+class _LIBCPP_TYPE_VIS_ONLY reference_wrapper
     : public __weak_result_type<_Tp>
 {
 public:
diff --git a/system/include/libcxx/__hash_table b/system/include/libcxx/__hash_table
index 6157fcd99fc7d..4c4feb03eabfb 100644
--- a/system/include/libcxx/__hash_table
+++ b/system/include/libcxx/__hash_table
@@ -20,7 +20,7 @@
 
 #include <__undef_min_max>
 
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
 #   include <__debug>
 #else
 #   define _LIBCPP_ASSERT(x, m) ((void)0)
@@ -85,14 +85,14 @@ __next_pow2(size_t __n)
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc> class __hash_table;
-template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS __hash_const_iterator;
-template <class _HashIterator> class _LIBCPP_TYPE_VIS __hash_map_iterator;
-template <class _HashIterator> class _LIBCPP_TYPE_VIS __hash_map_const_iterator;
+template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator;
+template <class _HashIterator> class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator;
+template <class _HashIterator> class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator;
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-    class _LIBCPP_TYPE_VIS unordered_map;
+    class _LIBCPP_TYPE_VIS_ONLY unordered_map;
 
 template <class _NodePtr>
-class _LIBCPP_TYPE_VIS __hash_iterator
+class _LIBCPP_TYPE_VIS_ONLY __hash_iterator
 {
     typedef _NodePtr __node_pointer;
 
@@ -212,14 +212,14 @@ private:
 #endif
 
     template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_const_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_map_iterator;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_multimap;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
 };
 
 template <class _ConstNodePtr>
-class _LIBCPP_TYPE_VIS __hash_const_iterator
+class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator
 {
     typedef _ConstNodePtr __node_pointer;
 
@@ -359,15 +359,15 @@ private:
 #endif
 
     template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_map_const_iterator;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_multimap;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
 };
 
-template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS __hash_const_local_iterator;
+template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator;
 
 template <class _NodePtr>
-class _LIBCPP_TYPE_VIS __hash_local_iterator
+class _LIBCPP_TYPE_VIS_ONLY __hash_local_iterator
 {
     typedef _NodePtr __node_pointer;
 
@@ -503,12 +503,12 @@ private:
         }
 #endif
     template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_map_iterator;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator;
 };
 
 template <class _ConstNodePtr>
-class _LIBCPP_TYPE_VIS __hash_const_local_iterator
+class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator
 {
     typedef _ConstNodePtr __node_pointer;
 
@@ -668,7 +668,7 @@ private:
         }
 #endif
     template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_map_const_iterator;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator;
 };
 
 template <class _Alloc>
@@ -1160,8 +1160,8 @@ private:
     void __deallocate(__node_pointer __np) _NOEXCEPT;
     __node_pointer __detach() _NOEXCEPT;
 
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_multimap;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
 };
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
@@ -2101,7 +2101,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(value_type&& __v,
     __h.get_deleter().__value_constructed = true;
     __h->__hash_ = __hash;
     __h->__next_ = nullptr;
-    return _VSTD::move(__h);
+    return __h;
 }
 
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -2116,7 +2116,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const value_type& __v
     __h.get_deleter().__value_constructed = true;
     __h->__hash_ = hash_function()(__h->__value_);
     __h->__next_ = nullptr;
-    return _VSTD::move(__h);
+    return _VSTD::move(__h);  // explicitly moved for C++03
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -2132,7 +2132,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const value_type& __v
     __h.get_deleter().__value_constructed = true;
     __h->__hash_ = __hash;
     __h->__next_ = nullptr;
-    return _VSTD::move(__h);
+    return _VSTD::move(__h);  // explicitly moved for C++03
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
diff --git a/system/include/libcxx/__locale b/system/include/libcxx/__locale
index 5ae8fa5927f4d..6d75162a99aa8 100644
--- a/system/include/libcxx/__locale
+++ b/system/include/libcxx/__locale
@@ -19,11 +19,13 @@
 #include <cstdint>
 #include <cctype>
 #include <locale.h>
-#ifdef _LIBCPP_MSVCRT
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
 # include <support/win32/locale_win32.h>
-#elif (defined(__GLIBC__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__sun__)) || defined(__EMSCRIPTEN__)
+#elif _AIX
+# include <support/ibm/xlocale.h>
+#elif (defined(__GLIBC__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__sun__)) || defined(__EMSCRIPTEN__) || defined(__IBMCPP__)
 # include <xlocale.h>
-#endif  // _WIN32 || __GLIBC__ || __APPLE__ || __FreeBSD__ || __sun__ || __EMSCRIPTEN__
+#endif  // _WIN32 || __GLIBC__ || __APPLE__ || __FreeBSD__ || __sun__ || __EMSCRIPTEN__ || __IBMCPP__
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
@@ -175,7 +177,7 @@ use_facet(const locale& __l)
 // template <class _CharT> class collate;
 
 template <class _CharT>
-class _LIBCPP_TYPE_VIS collate
+class _LIBCPP_TYPE_VIS_ONLY collate
     : public locale::facet
 {
 public:
@@ -254,12 +256,12 @@ collate<_CharT>::do_hash(const char_type* __lo, const char_type* __hi) const
     return static_cast<long>(__h);
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS collate<char>)
-_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS collate<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS collate<char>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS collate<wchar_t>)
 
 // template <class CharT> class collate_byname;
 
-template <class _CharT> class _LIBCPP_TYPE_VIS collate_byname;
+template <class _CharT> class _LIBCPP_TYPE_VIS_ONLY collate_byname;
 
 template <>
 class _LIBCPP_TYPE_VIS collate_byname<char>
@@ -361,7 +363,7 @@ public:
 # else
     static const mask blank  = _CTYPE_B;
 # endif
-#elif defined(__sun__)
+#elif defined(__sun__) || defined(_AIX)
     typedef unsigned int mask;
     static const mask space  = _ISSPACE;
     static const mask print  = _ISPRINT;
@@ -392,7 +394,7 @@ public:
     _LIBCPP_ALWAYS_INLINE ctype_base() {}
 };
 
-template <class _CharT> class _LIBCPP_TYPE_VIS ctype;
+template <class _CharT> class _LIBCPP_TYPE_VIS_ONLY ctype;
 
 template <>
 class _LIBCPP_TYPE_VIS ctype<wchar_t>
@@ -510,7 +512,7 @@ public:
     _LIBCPP_ALWAYS_INLINE
     bool is(mask __m, char_type __c) const
     {
-        return isascii(__c) ? __tab_[static_cast<int>(__c)] & __m : false;
+        return isascii(__c) ? (__tab_[static_cast<int>(__c)] & __m) !=0 : false;
     }
 
     _LIBCPP_ALWAYS_INLINE
@@ -619,7 +621,7 @@ protected:
 
 // template <class CharT> class ctype_byname;
 
-template <class _CharT> class _LIBCPP_TYPE_VIS ctype_byname;
+template <class _CharT> class _LIBCPP_TYPE_VIS_ONLY ctype_byname;
 
 template <>
 class _LIBCPP_TYPE_VIS ctype_byname<char>
@@ -780,7 +782,7 @@ public:
 
 // template <class internT, class externT, class stateT> class codecvt;
 
-template <class _InternT, class _ExternT, class _StateT> class _LIBCPP_TYPE_VIS codecvt;
+template <class _InternT, class _ExternT, class _StateT> class _LIBCPP_TYPE_VIS_ONLY codecvt;
 
 // template <> class codecvt<char, char, mbstate_t>
 
@@ -1126,7 +1128,7 @@ protected:
 // template <class _InternT, class _ExternT, class _StateT> class codecvt_byname
 
 template <class _InternT, class _ExternT, class _StateT>
-class _LIBCPP_TYPE_VIS codecvt_byname
+class _LIBCPP_TYPE_VIS_ONLY codecvt_byname
     : public codecvt<_InternT, _ExternT, _StateT>
 {
 public:
@@ -1145,10 +1147,10 @@ codecvt_byname<_InternT, _ExternT, _StateT>::~codecvt_byname()
 {
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class codecvt_byname<char, char, mbstate_t>)
-_LIBCPP_EXTERN_TEMPLATE(class codecvt_byname<wchar_t, char, mbstate_t>)
-_LIBCPP_EXTERN_TEMPLATE(class codecvt_byname<char16_t, char, mbstate_t>)
-_LIBCPP_EXTERN_TEMPLATE(class codecvt_byname<char32_t, char, mbstate_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS codecvt_byname<char, char, mbstate_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS codecvt_byname<wchar_t, char, mbstate_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS codecvt_byname<char16_t, char, mbstate_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS codecvt_byname<char32_t, char, mbstate_t>)
 
 _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
 
@@ -1334,7 +1336,7 @@ struct __widen_from_utf8<32>
 
 // template <class charT> class numpunct
 
-template <class _CharT> class _LIBCPP_TYPE_VIS numpunct;
+template <class _CharT> class _LIBCPP_TYPE_VIS_ONLY numpunct;
 
 template <>
 class _LIBCPP_TYPE_VIS numpunct<char>
@@ -1400,7 +1402,7 @@ protected:
 
 // template <class charT> class numpunct_byname
 
-template <class charT> class _LIBCPP_TYPE_VIS numpunct_byname;
+template <class charT> class _LIBCPP_TYPE_VIS_ONLY numpunct_byname;
 
 template <>
 class _LIBCPP_TYPE_VIS numpunct_byname<char>
diff --git a/system/include/libcxx/__mutex_base b/system/include/libcxx/__mutex_base
index 0583df933a06e..d4023a64f9faf 100644
--- a/system/include/libcxx/__mutex_base
+++ b/system/include/libcxx/__mutex_base
@@ -20,16 +20,6 @@
 #pragma GCC system_header
 #endif
 
-#ifdef _LIBCPP_SHARED_LOCK
-
-namespace ting {
-template <class _Mutex> class shared_lock;
-template <class _Mutex> class upgrade_lock;
-}
-
-#endif  // _LIBCPP_SHARED_LOCK
-
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TYPE_VIS mutex
@@ -77,7 +67,7 @@ constexpr adopt_lock_t  adopt_lock  = adopt_lock_t();
 #endif
 
 template <class _Mutex>
-class _LIBCPP_TYPE_VIS lock_guard
+class _LIBCPP_TYPE_VIS_ONLY lock_guard
 {
 public:
     typedef _Mutex mutex_type;
@@ -101,7 +91,7 @@ private:
 };
 
 template <class _Mutex>
-class _LIBCPP_TYPE_VIS unique_lock
+class _LIBCPP_TYPE_VIS_ONLY unique_lock
 {
 public:
     typedef _Mutex mutex_type;
@@ -162,27 +152,6 @@ public:
             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
 
     void lock();
diff --git a/system/include/libcxx/__split_buffer b/system/include/libcxx/__split_buffer
index f1c404f7741a1..1d529cbe27d20 100644
--- a/system/include/libcxx/__split_buffer
+++ b/system/include/libcxx/__split_buffer
@@ -285,7 +285,7 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _F
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_type)
 {
@@ -294,7 +294,7 @@ __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, true_type)
 {
@@ -302,7 +302,7 @@ __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, true_t
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 __split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT
 {
@@ -311,7 +311,7 @@ __split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_typ
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 __split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, true_type) _NOEXCEPT
 {
@@ -328,7 +328,7 @@ __split_buffer<_Tp, _Allocator>::__split_buffer(size_type __cap, size_type __sta
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 __split_buffer<_Tp, _Allocator>::__split_buffer()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr)
@@ -336,14 +336,14 @@ __split_buffer<_Tp, _Allocator>::__split_buffer()
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 __split_buffer<_Tp, _Allocator>::__split_buffer(__alloc_rr& __a)
     : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a)
 {
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 __split_buffer<_Tp, _Allocator>::__split_buffer(const __alloc_rr& __a)
     : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a)
 {
@@ -541,7 +541,7 @@ __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 __split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
 {
@@ -640,7 +640,7 @@ __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(__split_buffer<_Tp, _Allocator>& __x, __split_buffer<_Tp, _Allocator>& __y)
         _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
diff --git a/system/include/libcxx/__std_stream b/system/include/libcxx/__std_stream
index cff43317e5807..5403adabc343e 100644
--- a/system/include/libcxx/__std_stream
+++ b/system/include/libcxx/__std_stream
@@ -233,6 +233,7 @@ public:
 
 protected:
     virtual int_type overflow (int_type __c = traits_type::eof());
+    virtual streamsize xsputn(const char_type* __s, streamsize __n);
     virtual int sync();
     virtual void imbue(const locale& __loc);
 
@@ -308,6 +309,19 @@ __stdoutbuf<_CharT>::overflow(int_type __c)
     return traits_type::not_eof(__c);
 }
 
+template <class _CharT>
+streamsize
+__stdoutbuf<_CharT>::xsputn(const char_type* __s, streamsize __n)
+{
+    if (__always_noconv_)
+        return fwrite(__s, sizeof(char_type), __n, __file_);
+    streamsize __i = 0;
+    for (; __i < __n; ++__i, ++__s)
+        if (overflow(traits_type::to_int_type(*__s)) == traits_type::eof())
+            break;
+    return __i;
+}
+
 template <class _CharT>
 int
 __stdoutbuf<_CharT>::sync()
diff --git a/system/include/libcxx/__tree b/system/include/libcxx/__tree
index 9ffc38d2287ed..acf87593a9700 100644
--- a/system/include/libcxx/__tree
+++ b/system/include/libcxx/__tree
@@ -25,17 +25,17 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _Compare, class _Allocator> class __tree;
 template <class _Tp, class _NodePtr, class _DiffType>
-    class _LIBCPP_TYPE_VIS __tree_iterator;
+    class _LIBCPP_TYPE_VIS_ONLY __tree_iterator;
 template <class _Tp, class _ConstNodePtr, class _DiffType>
-    class _LIBCPP_TYPE_VIS __tree_const_iterator;
+    class _LIBCPP_TYPE_VIS_ONLY __tree_const_iterator;
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-    class _LIBCPP_TYPE_VIS map;
+    class _LIBCPP_TYPE_VIS_ONLY map;
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-    class _LIBCPP_TYPE_VIS multimap;
+    class _LIBCPP_TYPE_VIS_ONLY multimap;
 template <class _Key, class _Compare, class _Allocator>
-    class _LIBCPP_TYPE_VIS set;
+    class _LIBCPP_TYPE_VIS_ONLY set;
 template <class _Key, class _Compare, class _Allocator>
-    class _LIBCPP_TYPE_VIS multiset;
+    class _LIBCPP_TYPE_VIS_ONLY multiset;
 
 /*
 
@@ -614,11 +614,11 @@ public:
 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
 };
 
-template <class _TreeIterator> class _LIBCPP_TYPE_VIS __map_iterator;
-template <class _TreeIterator> class _LIBCPP_TYPE_VIS __map_const_iterator;
+template <class _TreeIterator> class _LIBCPP_TYPE_VIS_ONLY __map_iterator;
+template <class _TreeIterator> class _LIBCPP_TYPE_VIS_ONLY __map_const_iterator;
 
 template <class _Tp, class _NodePtr, class _DiffType>
-class _LIBCPP_TYPE_VIS __tree_iterator
+class _LIBCPP_TYPE_VIS_ONLY __tree_iterator
 {
     typedef _NodePtr                                              __node_pointer;
     typedef typename pointer_traits<__node_pointer>::element_type __node;
@@ -641,7 +641,11 @@ public:
 #endif
                                        pointer;
 
-    _LIBCPP_INLINE_VISIBILITY __tree_iterator() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY __tree_iterator() _NOEXCEPT
+#if _LIBCPP_STD_VER > 11
+    : __ptr_(nullptr)
+#endif
+    {}
 
     _LIBCPP_INLINE_VISIBILITY reference operator*() const {return __ptr_->__value_;}
     _LIBCPP_INLINE_VISIBILITY pointer operator->() const
@@ -674,16 +678,16 @@ private:
     _LIBCPP_INLINE_VISIBILITY
     explicit __tree_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
     template <class, class, class> friend class __tree;
-    template <class, class, class> friend class _LIBCPP_TYPE_VIS __tree_const_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS __map_iterator;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS multimap;
-    template <class, class, class> friend class _LIBCPP_TYPE_VIS set;
-    template <class, class, class> friend class _LIBCPP_TYPE_VIS multiset;
+    template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY __tree_const_iterator;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __map_iterator;
+    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY map;
+    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multimap;
+    template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY set;
+    template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multiset;
 };
 
 template <class _Tp, class _ConstNodePtr, class _DiffType>
-class _LIBCPP_TYPE_VIS __tree_const_iterator
+class _LIBCPP_TYPE_VIS_ONLY __tree_const_iterator
 {
     typedef _ConstNodePtr                                         __node_pointer;
     typedef typename pointer_traits<__node_pointer>::element_type __node;
@@ -712,7 +716,12 @@ public:
 #endif
                                        pointer;
 
-    _LIBCPP_INLINE_VISIBILITY __tree_const_iterator() {}
+    _LIBCPP_INLINE_VISIBILITY __tree_const_iterator() _NOEXCEPT
+#if _LIBCPP_STD_VER > 11
+    : __ptr_(nullptr)
+#endif
+    {}
+
 private:
     typedef typename remove_const<__node>::type  __non_const_node;
     typedef typename pointer_traits<__node_pointer>::template
@@ -761,11 +770,11 @@ private:
     explicit __tree_const_iterator(__node_pointer __p) _NOEXCEPT
         : __ptr_(__p) {}
     template <class, class, class> friend class __tree;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS multimap;
-    template <class, class, class> friend class _LIBCPP_TYPE_VIS set;
-    template <class, class, class> friend class _LIBCPP_TYPE_VIS multiset;
-    template <class> friend class _LIBCPP_TYPE_VIS __map_const_iterator;
+    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY map;
+    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multimap;
+    template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY set;
+    template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multiset;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __map_const_iterator;
 };
 
 template <class _Tp, class _Compare, class _Allocator>
@@ -1107,8 +1116,8 @@ private:
     __node_pointer __detach();
     static __node_pointer __detach(__node_pointer);
 
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS multimap;
+    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY map;
+    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multimap;
 };
 
 template <class _Tp, class _Compare, class _Allocator>
@@ -1845,7 +1854,7 @@ __tree<_Tp, _Compare, _Allocator>::__construct_node(const value_type& __v)
     __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
     __node_traits::construct(__na, _VSTD::addressof(__h->__value_), __v);
     __h.get_deleter().__value_constructed = true;
-    return _VSTD::move(__h);
+    return _VSTD::move(__h);  // explicitly moved for C++03
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
diff --git a/system/include/libcxx/__tuple b/system/include/libcxx/__tuple
index 9a6b6e09fb1e8..de35cb87e8de0 100644
--- a/system/include/libcxx/__tuple
+++ b/system/include/libcxx/__tuple
@@ -27,46 +27,46 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> class _LIBCPP_TYPE_VIS tuple_size;
+template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_size;
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS tuple_size<const _Tp>
+class _LIBCPP_TYPE_VIS_ONLY tuple_size<const _Tp>
     : public tuple_size<_Tp> {};
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS tuple_size<volatile _Tp>
+class _LIBCPP_TYPE_VIS_ONLY tuple_size<volatile _Tp>
     : public tuple_size<_Tp> {};
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS tuple_size<const volatile _Tp>
+class _LIBCPP_TYPE_VIS_ONLY tuple_size<const volatile _Tp>
     : public tuple_size<_Tp> {};
 
-template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS tuple_element;
+template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_element;
 
 template <size_t _Ip, class _Tp>
-class _LIBCPP_TYPE_VIS tuple_element<_Ip, const _Tp>
+class _LIBCPP_TYPE_VIS_ONLY 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_TYPE_VIS tuple_element<_Ip, volatile _Tp>
+class _LIBCPP_TYPE_VIS_ONLY 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_TYPE_VIS tuple_element<_Ip, const volatile _Tp>
+class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const volatile _Tp>
 {
 public:
     typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
 };
 
-template <class ..._Tp> class _LIBCPP_TYPE_VIS tuple;
-template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS pair;
-template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS array;
+template <class ..._Tp> class _LIBCPP_TYPE_VIS_ONLY tuple;
+template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY pair;
+template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY array;
 
 template <class _Tp> struct __tuple_like : false_type {};
 
@@ -154,7 +154,7 @@ struct __make_tuple_indices
 template <class ..._Tp> struct __tuple_types {};
 
 template <size_t _Ip>
-class _LIBCPP_TYPE_VIS tuple_element<_Ip, __tuple_types<> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<> >
 {
 public:
     static_assert(_Ip == 0, "tuple_element index out of range");
@@ -162,21 +162,21 @@ public:
 };
 
 template <class _Hp, class ..._Tp>
-class _LIBCPP_TYPE_VIS tuple_element<0, __tuple_types<_Hp, _Tp...> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_element<0, __tuple_types<_Hp, _Tp...> >
 {
 public:
     typedef _Hp type;
 };
 
 template <size_t _Ip, class _Hp, class ..._Tp>
-class _LIBCPP_TYPE_VIS tuple_element<_Ip, __tuple_types<_Hp, _Tp...> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<_Hp, _Tp...> >
 {
 public:
     typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...> >::type type;
 };
 
 template <class ..._Tp>
-class _LIBCPP_TYPE_VIS tuple_size<__tuple_types<_Tp...> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_size<__tuple_types<_Tp...> >
     : public integral_constant<size_t, sizeof...(_Tp)>
 {
 };
diff --git a/system/include/libcxx/__tuple_03 b/system/include/libcxx/__tuple_03
index 605d84df1ea48..b91c2cd48a63c 100644
--- a/system/include/libcxx/__tuple_03
+++ b/system/include/libcxx/__tuple_03
@@ -19,8 +19,8 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> class _LIBCPP_TYPE_VIS tuple_size;
-template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS tuple_element;
+template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_size;
+template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_element;
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/system/include/libcxx/__undef_min_max b/system/include/libcxx/__undef_min_max
index b1e80d1b0499f..2b6bc90a125ad 100644
--- a/system/include/libcxx/__undef_min_max
+++ b/system/include/libcxx/__undef_min_max
@@ -9,11 +9,19 @@
 //===----------------------------------------------------------------------===//
 
 #ifdef min
+#if defined(_MSC_VER) && ! defined(__clang__)
+_LIBCPP_WARNING("macro min is incompatible with C++.  #undefing min")
+#else
 #warning: macro min is incompatible with C++.  #undefing min
+#endif
 #undef min
 #endif
 
 #ifdef max
+#if defined(_MSC_VER) && ! defined(__clang__)
+_LIBCPP_WARNING("macro max is incompatible with C++.  #undefing max")
+#else
 #warning: macro max is incompatible with C++.  #undefing max
+#endif
 #undef max
 #endif
diff --git a/system/include/libcxx/algorithm b/system/include/libcxx/algorithm
index 2fc1f8ab4bb64..367489fbb83c3 100644
--- a/system/include/libcxx/algorithm
+++ b/system/include/libcxx/algorithm
@@ -628,6 +628,13 @@ template <class BidirectionalIterator, class Compare>
 #include <iterator>
 #include <cstddef>
 
+#if defined(__IBMCPP__)
+#include "support/ibm/support.h"
+#endif
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
+#include "support/win32/support.h"
+#endif
+
 #include <__undef_min_max>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -710,7 +717,7 @@ public:
     bool operator()(const _T1& __x, const _T2& __y) {return !__p_(__x, __y);}
 };
 
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
 
 template <class _Compare>
 struct __debug_less
@@ -727,7 +734,7 @@ struct __debug_less
     }
 };
 
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 
 // Precondition:  __x != 0
 inline _LIBCPP_INLINE_VISIBILITY
@@ -825,7 +832,7 @@ for_each(_InputIterator __first, _InputIterator __last, _Function __f)
 {
     for (; __first != __last; ++__first)
         __f(*__first);
-    return _VSTD::move(__f);
+    return _VSTD::move(__f);  // explicitly moved for (emulated) C++03
 }
 
 // find
@@ -1688,6 +1695,8 @@ __unwrap_iter(move_iterator<_Tp*> __i)
     return __i.base();
 }
 
+#if _LIBCPP_DEBUG_LEVEL < 2
+
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
@@ -1700,6 +1709,8 @@ __unwrap_iter(__wrap_iter<_Tp*> __i)
     return __i.base();
 }
 
+#endif  // _LIBCPP_DEBUG_LEVEL < 2
+
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
@@ -2964,11 +2975,11 @@ uniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p
     return static_cast<result_type>(__u + __p.a());
 }
 
-class __rs_default;
+class _LIBCPP_TYPE_VIS __rs_default;
 
-__rs_default __rs_get();
+_LIBCPP_FUNC_VIS __rs_default __rs_get();
 
-class __rs_default
+class _LIBCPP_TYPE_VIS __rs_default
 {
     static unsigned __c_;
 
@@ -2987,10 +2998,10 @@ public:
     static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
     static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
 
-    friend __rs_default __rs_get();
+    friend _LIBCPP_FUNC_VIS __rs_default __rs_get();
 };
 
-__rs_default __rs_get();
+_LIBCPP_FUNC_VIS __rs_default __rs_get();
 
 template <class _RandomAccessIterator>
 void
@@ -3945,14 +3956,14 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     __sort<_Comp_ref>(__first, __last, __c);
-#else  // _LIBCPP_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __sort<_Comp_ref>(__first, __last, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _RandomAccessIterator>
@@ -3992,39 +4003,39 @@ sort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last, _Compare __comp)
 #pragma warning( push )
 #pragma warning( disable: 4231)
 #endif // _LIBCPP_MSVC
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<char>&, char*>(char*, char*, __less<char>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<short>&, short*>(short*, short*, __less<short>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<int>&, int*>(int*, int*, __less<int>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<long>&, long*>(long*, long*, __less<long>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<long long>&, long long*>(long long*, long long*, __less<long long>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<float>&, float*>(float*, float*, __less<float>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<double>&, double*>(double*, double*, __less<double>&))
-_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<long double>&, long double*>(long double*, long double*, __less<long double>&))
-
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<char>&, char*>(char*, char*, __less<char>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<short>&, short*>(short*, short*, __less<short>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<int>&, int*>(int*, int*, __less<int>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<long>&, long*>(long*, long*, __less<long>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<long long>&, long long*>(long long*, long long*, __less<long long>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&))
-_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&))
-
-_LIBCPP_EXTERN_TEMPLATE(unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<char>&, char*>(char*, char*, __less<char>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<short>&, short*>(short*, short*, __less<short>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<int>&, int*>(int*, int*, __less<int>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long>&, long*>(long*, long*, __less<long>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long long>&, long long*>(long long*, long long*, __less<long long>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<float>&, float*>(float*, float*, __less<float>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<double>&, double*>(double*, double*, __less<double>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long double>&, long double*>(long double*, long double*, __less<long double>&))
+
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<char>&, char*>(char*, char*, __less<char>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<short>&, short*>(short*, short*, __less<short>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<int>&, int*>(int*, int*, __less<int>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long>&, long*>(long*, long*, __less<long>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long long>&, long long*>(long long*, long long*, __less<long long>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&))
+
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&))
 #ifdef _LIBCPP_MSVC
 #pragma warning( pop )
 #endif  // _LIBCPP_MSVC
@@ -4058,14 +4069,14 @@ inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __lower_bound<_Comp_ref>(__first, __last, __value_, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _ForwardIterator, class _Tp>
@@ -4106,14 +4117,14 @@ inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __upper_bound<_Comp_ref>(__first, __last, __value_, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _ForwardIterator, class _Tp>
@@ -4166,14 +4177,14 @@ inline _LIBCPP_INLINE_VISIBILITY
 pair<_ForwardIterator, _ForwardIterator>
 equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __equal_range<_Comp_ref>(__first, __last, __value_, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _ForwardIterator, class _Tp>
@@ -4201,14 +4212,14 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __binary_search<_Comp_ref>(__first, __last, __value_, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _ForwardIterator, class _Tp>
@@ -4251,14 +4262,14 @@ _OutputIterator
 merge(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
-#else  // _LIBCPP_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -4425,16 +4436,16 @@ inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _
         __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size);
         __h.reset(__buf.first);
     }
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
     return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __c, __len1, __len2,
                                             __buf.first, __buf.second);
-#else  // _LIBCPP_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2,
                                             __buf.first, __buf.second);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _BidirectionalIterator>
@@ -4636,14 +4647,14 @@ stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compar
         __buf = _VSTD::get_temporary_buffer<value_type>(__len);
         __h.reset(__buf.first);
     }
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __stable_sort<_Comp_ref>(__first, __last, __comp, __len, __buf.first, __buf.second);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _RandomAccessIterator>
@@ -4785,14 +4796,14 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __push_heap_back<_Comp_ref>(__first, __last, __comp, __last - __first);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _RandomAccessIterator>
@@ -4823,14 +4834,14 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __pop_heap<_Comp_ref>(__first, __last, __comp, __last - __first);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _RandomAccessIterator>
@@ -4863,14 +4874,14 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __make_heap<_Comp_ref>(__first, __last, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _RandomAccessIterator>
@@ -4897,14 +4908,14 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __sort_heap<_Comp_ref>(__first, __last, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _RandomAccessIterator>
@@ -4941,14 +4952,14 @@ void
 partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
              _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __partial_sort<_Comp_ref>(__first, __middle, __last, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _RandomAccessIterator>
@@ -4991,14 +5002,14 @@ _RandomAccessIterator
 partial_sort_copy(_InputIterator __first, _InputIterator __last,
                   _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _InputIterator, class _RandomAccessIterator>
@@ -5205,14 +5216,14 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     __nth_element<_Comp_ref>(__first, __nth, __last, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _RandomAccessIterator>
@@ -5246,14 +5257,14 @@ bool
 includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
          _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _InputIterator1, class _InputIterator2>
@@ -5299,14 +5310,14 @@ _OutputIterator
 set_union(_InputIterator1 __first1, _InputIterator1 __last1,
           _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -5351,14 +5362,14 @@ _OutputIterator
 set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
                  _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -5405,14 +5416,14 @@ _OutputIterator
 set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
                _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -5464,14 +5475,14 @@ _OutputIterator
 set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
                          _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
@@ -5508,14 +5519,14 @@ bool
 lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
                         _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _InputIterator1, class _InputIterator2>
@@ -5563,14 +5574,14 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __next_permutation<_Comp_ref>(__first, __last, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _BidirectionalIterator>
@@ -5616,14 +5627,14 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
 {
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
     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_DEBUG2
+#else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
     return __prev_permutation<_Comp_ref>(__first, __last, __comp);
-#endif  // _LIBCPP_DEBUG2
+#endif  // _LIBCPP_DEBUG
 }
 
 template <class _BidirectionalIterator>
diff --git a/system/include/libcxx/array b/system/include/libcxx/array
index 86d1fc0be69b9..d37075da1a2a9 100644
--- a/system/include/libcxx/array
+++ b/system/include/libcxx/array
@@ -118,7 +118,7 @@ template <int I, class T, size_t N> T&& get(array<T, N>&&) noexcept; // constexp
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, size_t _Size>
-struct _LIBCPP_TYPE_VIS array
+struct _LIBCPP_TYPE_VIS_ONLY array
 {
     // types:
     typedef array __self;
@@ -224,7 +224,7 @@ array<_Tp, _Size>::at(size_type __n) const
 }
 
 template <class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 {
@@ -232,7 +232,7 @@ operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 }
 
 template <class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 {
@@ -240,7 +240,7 @@ operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 }
 
 template <class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 {
@@ -248,7 +248,7 @@ operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 }
 
 template <class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 {
@@ -256,7 +256,7 @@ operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 }
 
 template <class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 {
@@ -264,7 +264,7 @@ operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 }
 
 template <class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 {
@@ -272,7 +272,7 @@ operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 }
 
 template <class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     __is_swappable<_Tp>::value,
@@ -285,29 +285,29 @@ swap(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 }
 
 template <class _Tp, size_t _Size>
-class _LIBCPP_TYPE_VIS tuple_size<array<_Tp, _Size> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_size<array<_Tp, _Size> >
     : public integral_constant<size_t, _Size> {};
 
 template <class _Tp, size_t _Size>
-class _LIBCPP_TYPE_VIS tuple_size<const array<_Tp, _Size> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_size<const array<_Tp, _Size> >
     : public integral_constant<size_t, _Size> {};
 
 template <size_t _Ip, class _Tp, size_t _Size>
-class _LIBCPP_TYPE_VIS tuple_element<_Ip, array<_Tp, _Size> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, array<_Tp, _Size> >
 {
 public:
     typedef _Tp type;
 };
 
 template <size_t _Ip, class _Tp, size_t _Size>
-class _LIBCPP_TYPE_VIS tuple_element<_Ip, const array<_Tp, _Size> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const array<_Tp, _Size> >
 {
 public:
     typedef const _Tp type;
 };
 
 template <size_t _Ip, class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY inline _LIBCPP_CONSTEXPR_AFTER_CXX11
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp&
 get(array<_Tp, _Size>& __a) _NOEXCEPT
 {
@@ -316,7 +316,7 @@ get(array<_Tp, _Size>& __a) _NOEXCEPT
 }
 
 template <size_t _Ip, class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY inline _LIBCPP_CONSTEXPR_AFTER_CXX11
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 const _Tp&
 get(const array<_Tp, _Size>& __a) _NOEXCEPT
 {
@@ -327,7 +327,7 @@ get(const array<_Tp, _Size>& __a) _NOEXCEPT
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <size_t _Ip, class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY inline _LIBCPP_CONSTEXPR_AFTER_CXX11
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp&&
 get(array<_Tp, _Size>&& __a) _NOEXCEPT
 {
diff --git a/system/include/libcxx/bitset b/system/include/libcxx/bitset
index dd9be4fcb87b1..4cc7dbdaef953 100644
--- a/system/include/libcxx/bitset
+++ b/system/include/libcxx/bitset
@@ -632,11 +632,11 @@ __bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT
 {
 }
 
-template <size_t _Size> class _LIBCPP_TYPE_VIS bitset;
-template <size_t _Size> struct _LIBCPP_TYPE_VIS hash<bitset<_Size> >;
+template <size_t _Size> class _LIBCPP_TYPE_VIS_ONLY bitset;
+template <size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY hash<bitset<_Size> >;
 
 template <size_t _Size>
-class _LIBCPP_TYPE_VIS bitset
+class _LIBCPP_TYPE_VIS_ONLY bitset
     : private __bitset<_Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1, _Size>
 {
 public:
@@ -1060,7 +1060,7 @@ operator^(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
 }
 
 template <size_t _Size>
-struct _LIBCPP_TYPE_VIS hash<bitset<_Size> >
+struct _LIBCPP_TYPE_VIS_ONLY hash<bitset<_Size> >
     : public unary_function<bitset<_Size>, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
diff --git a/system/include/libcxx/chrono b/system/include/libcxx/chrono
index da550498b4521..2c65eee7d067e 100644
--- a/system/include/libcxx/chrono
+++ b/system/include/libcxx/chrono
@@ -292,7 +292,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace chrono
 {
 
-template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TYPE_VIS duration;
+template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TYPE_VIS_ONLY duration;
 
 template <class _Tp>
 struct __is_duration : false_type {};
@@ -312,8 +312,8 @@ struct __is_duration<const volatile duration<_Rep, _Period> > : true_type  {};
 } // chrono
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-struct _LIBCPP_TYPE_VIS common_type<chrono::duration<_Rep1, _Period1>,
-                                   chrono::duration<_Rep2, _Period2> >
+struct _LIBCPP_TYPE_VIS_ONLY 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;
@@ -390,10 +390,10 @@ duration_cast(const duration<_Rep, _Period>& __fd)
 }
 
 template <class _Rep>
-struct _LIBCPP_TYPE_VIS treat_as_floating_point : is_floating_point<_Rep> {};
+struct _LIBCPP_TYPE_VIS_ONLY treat_as_floating_point : is_floating_point<_Rep> {};
 
 template <class _Rep>
-struct _LIBCPP_TYPE_VIS duration_values
+struct _LIBCPP_TYPE_VIS_ONLY duration_values
 {
 public:
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);}
@@ -404,11 +404,42 @@ public:
 // duration
 
 template <class _Rep, class _Period>
-class _LIBCPP_TYPE_VIS duration
+class _LIBCPP_TYPE_VIS_ONLY 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");
     static_assert(_Period::num > 0, "duration period must be positive");
+
+    template <class _R1, class _R2>
+    struct __no_overflow
+    {
+    private:
+        static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
+        static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
+        static const intmax_t __n1 = _R1::num / __gcd_n1_n2;
+        static const intmax_t __d1 = _R1::den / __gcd_d1_d2;
+        static const intmax_t __n2 = _R2::num / __gcd_n1_n2;
+        static const intmax_t __d2 = _R2::den / __gcd_d1_d2;
+        static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);
+
+        template <intmax_t _Xp, intmax_t _Yp, bool __overflow>
+        struct __mul    // __overflow == false
+        {
+            static const intmax_t value = _Xp * _Yp;
+        };
+
+        template <intmax_t _Xp, intmax_t _Yp>
+        struct __mul<_Xp, _Yp, true>
+        {
+            static const intmax_t value = 1;
+        };
+
+    public:
+        static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1);
+        typedef ratio<__mul<__n1, __d2, !value>::value,
+                      __mul<__n2, __d1, !value>::value> type;
+    };
+    
 public:
     typedef _Rep rep;
     typedef _Period period;
@@ -440,9 +471,10 @@ public:
         duration(const duration<_Rep2, _Period2>& __d,
             typename enable_if
             <
+                __no_overflow<_Period2, period>::value && (
                 treat_as_floating_point<rep>::value ||
-                (ratio_divide<_Period2, period>::type::den == 1 &&
-                 !treat_as_floating_point<_Rep2>::value)
+                (__no_overflow<_Period2, period>::type::den == 1 &&
+                 !treat_as_floating_point<_Rep2>::value))
             >::type* = 0)
                 : __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {}
 
@@ -715,7 +747,7 @@ operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2
 //////////////////////////////////////////////////////////
 
 template <class _Clock, class _Duration = typename _Clock::duration>
-class _LIBCPP_TYPE_VIS time_point
+class _LIBCPP_TYPE_VIS_ONLY time_point
 {
     static_assert(__is_duration<_Duration>::value,
                   "Second template parameter of time_point must be a std::chrono::duration");
@@ -759,8 +791,8 @@ public:
 } // chrono
 
 template <class _Clock, class _Duration1, class _Duration2>
-struct _LIBCPP_TYPE_VIS common_type<chrono::time_point<_Clock, _Duration1>,
-                                   chrono::time_point<_Clock, _Duration2> >
+struct _LIBCPP_TYPE_VIS_ONLY common_type<chrono::time_point<_Clock, _Duration1>,
+                                         chrono::time_point<_Clock, _Duration2> >
 {
     typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;
 };
@@ -910,12 +942,9 @@ typedef steady_clock high_resolution_clock;
 
 } // chrono
 
-#if _LIBCPP_STD_VER > 11 
-// Literal suffixes for chrono types
-// inline // Deviation from N3690.
-//    We believe the inline to be a defect and have submitted an LWG issue.
-//    An LWG issue number has not yet been assigned.
-namespace literals
+#if _LIBCPP_STD_VER > 11
+// Suffixes for duration literals [time.duration.literals]
+inline namespace literals
 { 
   inline namespace chrono_literals
   {
@@ -986,6 +1015,11 @@ namespace literals
     }
 
 }}
+
+namespace chrono { // hoist the literals into namespace std::chrono
+   using namespace literals::chrono_literals;
+}
+
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/system/include/libcxx/cmath b/system/include/libcxx/cmath
index 3e545cea58639..75087ae78fb45 100644
--- a/system/include/libcxx/cmath
+++ b/system/include/libcxx/cmath
@@ -654,6 +654,7 @@ using ::double_t;
 
 // abs
 
+#if !defined(_AIX)
 inline _LIBCPP_INLINE_VISIBILITY
 float
 abs(float __x) _NOEXCEPT {return fabsf(__x);}
@@ -665,6 +666,7 @@ abs(double __x) _NOEXCEPT {return fabs(__x);}
 inline _LIBCPP_INLINE_VISIBILITY
 long double
 abs(long double __x) _NOEXCEPT {return fabsl(__x);}
+#endif // !defined(_AIX)
 
 #ifndef __sun__
 
@@ -673,7 +675,7 @@ abs(long double __x) _NOEXCEPT {return fabsl(__x);}
 using ::acos;
 using ::acosf;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       acos(float __x) _NOEXCEPT       {return acosf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __x) _NOEXCEPT {return acosl(__x);}
 #endif
@@ -688,7 +690,7 @@ acos(_A1 __x) _NOEXCEPT {return acos((double)__x);}
 using ::asin;
 using ::asinf;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       asin(float __x) _NOEXCEPT       {return asinf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __x) _NOEXCEPT {return asinl(__x);}
 #endif
@@ -703,7 +705,7 @@ asin(_A1 __x) _NOEXCEPT {return asin((double)__x);}
 using ::atan;
 using ::atanf;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       atan(float __x) _NOEXCEPT       {return atanf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __x) _NOEXCEPT {return atanl(__x);}
 #endif
@@ -718,7 +720,7 @@ atan(_A1 __x) _NOEXCEPT {return atan((double)__x);}
 using ::atan2;
 using ::atan2f;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       atan2(float __y, float __x) _NOEXCEPT             {return atan2f(__y, __x);}
 inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __y, long double __x) _NOEXCEPT {return atan2l(__y, __x);}
 #endif
@@ -744,7 +746,7 @@ atan2(_A1 __y, _A2 __x) _NOEXCEPT
 using ::ceil;
 using ::ceilf;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       ceil(float __x) _NOEXCEPT       {return ceilf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __x) _NOEXCEPT {return ceill(__x);}
 #endif
@@ -759,13 +761,13 @@ ceil(_A1 __x) _NOEXCEPT {return ceil((double)__x);}
 using ::cos;
 using ::cosf;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       cos(float __x) _NOEXCEPT       {return cosf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __x) _NOEXCEPT {return cosl(__x);}
 #endif
 
 template <class _A1>
-inline _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if<is_integral<_A1>::value, double>::type
 cos(_A1 __x) _NOEXCEPT {return cos((double)__x);}
 
@@ -774,7 +776,7 @@ cos(_A1 __x) _NOEXCEPT {return cos((double)__x);}
 using ::cosh;
 using ::coshf;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       cosh(float __x) _NOEXCEPT       {return coshf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __x) _NOEXCEPT {return coshl(__x);}
 #endif
@@ -792,7 +794,7 @@ using ::expf;
 
 #ifndef __sun__
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       exp(float __x) _NOEXCEPT       {return expf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __x) _NOEXCEPT {return expl(__x);}
 #endif
@@ -808,7 +810,7 @@ exp(_A1 __x) _NOEXCEPT {return exp((double)__x);}
 using ::fabs;
 using ::fabsf;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       fabs(float __x) _NOEXCEPT       {return fabsf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __x) _NOEXCEPT {return fabsl(__x);}
 #endif
@@ -823,7 +825,7 @@ fabs(_A1 __x) _NOEXCEPT {return fabs((double)__x);}
 using ::floor;
 using ::floorf;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       floor(float __x) _NOEXCEPT       {return floorf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __x) _NOEXCEPT {return floorl(__x);}
 #endif
@@ -840,7 +842,7 @@ using ::fmod;
 using ::fmodf;
 #ifndef __sun__
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       fmod(float __x, float __y) _NOEXCEPT             {return fmodf(__x, __y);}
 inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __x, long double __y) _NOEXCEPT {return fmodl(__x, __y);}
 #endif
@@ -867,7 +869,7 @@ fmod(_A1 __x, _A2 __y) _NOEXCEPT
 using ::frexp;
 using ::frexpf;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       frexp(float __x, int* __e) _NOEXCEPT       {return frexpf(__x, __e);}
 inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __x, int* __e) _NOEXCEPT {return frexpl(__x, __e);}
 #endif
@@ -882,7 +884,7 @@ frexp(_A1 __x, int* __e) _NOEXCEPT {return frexp((double)__x, __e);}
 using ::ldexp;
 using ::ldexpf;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       ldexp(float __x, int __e) _NOEXCEPT       {return ldexpf(__x, __e);}
 inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __x, int __e) _NOEXCEPT {return ldexpl(__x, __e);}
 #endif
@@ -899,7 +901,7 @@ using ::log;
 using ::logf;
 #ifndef __sun__
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       log(float __x) _NOEXCEPT       {return logf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double log(long double __x) _NOEXCEPT {return logl(__x);}
 #endif
@@ -915,7 +917,7 @@ log(_A1 __x) _NOEXCEPT {return log((double)__x);}
 using ::log10;
 using ::log10f;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       log10(float __x) _NOEXCEPT       {return log10f(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __x) _NOEXCEPT {return log10l(__x);}
 #endif
@@ -930,7 +932,7 @@ log10(_A1 __x) _NOEXCEPT {return log10((double)__x);}
 using ::modf;
 using ::modff;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       modf(float __x, float* __y) _NOEXCEPT             {return modff(__x, __y);}
 inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __x, long double* __y) _NOEXCEPT {return modfl(__x, __y);}
 #endif
@@ -943,7 +945,7 @@ using ::powf;
 
 #ifndef __sun__
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       pow(float __x, float __y) _NOEXCEPT             {return powf(__x, __y);}
 inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __x, long double __y) _NOEXCEPT {return powl(__x, __y);}
 #endif
@@ -970,7 +972,7 @@ pow(_A1 __x, _A2 __y) _NOEXCEPT
 using ::sin;
 using ::sinf;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       sin(float __x) _NOEXCEPT       {return sinf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __x) _NOEXCEPT {return sinl(__x);}
 #endif
@@ -985,7 +987,7 @@ sin(_A1 __x) _NOEXCEPT {return sin((double)__x);}
 using ::sinh;
 using ::sinhf;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       sinh(float __x) _NOEXCEPT       {return sinhf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __x) _NOEXCEPT {return sinhl(__x);}
 #endif
@@ -1002,7 +1004,7 @@ using ::sqrt;
 using ::sqrtf;
 
 
-#if !(defined(_LIBCPP_MSVCRT) || defined(__sun__))
+#if !(defined(_LIBCPP_MSVCRT) || defined(__sun__) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       sqrt(float __x) _NOEXCEPT       {return sqrtf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __x) _NOEXCEPT {return sqrtl(__x);}
 #endif
@@ -1018,7 +1020,7 @@ using ::tan;
 using ::tanf;
 #ifndef __sun__
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       tan(float __x) _NOEXCEPT       {return tanf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __x) _NOEXCEPT {return tanl(__x);}
 #endif
@@ -1033,7 +1035,7 @@ tan(_A1 __x) _NOEXCEPT {return tan((double)__x);}
 using ::tanh;
 using ::tanhf;
 
-#ifndef _LIBCPP_MSVCRT
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
 inline _LIBCPP_INLINE_VISIBILITY float       tanh(float __x) _NOEXCEPT       {return tanhf(__x);}
 inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __x) _NOEXCEPT {return tanhl(__x);}
 #endif
diff --git a/system/include/libcxx/codecvt b/system/include/libcxx/codecvt
index a6e4308e2512c..6eff107cd1cdf 100644
--- a/system/include/libcxx/codecvt
+++ b/system/include/libcxx/codecvt
@@ -29,7 +29,8 @@ template <class Elem, unsigned long Maxcode = 0x10ffff,
 class codecvt_utf8
     : public codecvt<Elem, char, mbstate_t>
 {
-    // unspecified
+    explicit codecvt_utf8(size_t refs = 0);
+    ~codecvt_utf8();
 };
 
 template <class Elem, unsigned long Maxcode = 0x10ffff,
@@ -37,7 +38,8 @@ template <class Elem, unsigned long Maxcode = 0x10ffff,
 class codecvt_utf16
     : public codecvt<Elem, char, mbstate_t>
 {
-    // unspecified
+    explicit codecvt_utf16(size_t refs = 0);
+    ~codecvt_utf16();
 };
 
 template <class Elem, unsigned long Maxcode = 0x10ffff,
@@ -45,7 +47,8 @@ template <class Elem, unsigned long Maxcode = 0x10ffff,
 class codecvt_utf8_utf16
     : public codecvt<Elem, char, mbstate_t>
 {
-    // unspecified
+    explicit codecvt_utf8_utf16(size_t refs = 0);
+    ~codecvt_utf8_utf16();
 };
 
 }  // std
@@ -73,7 +76,7 @@ enum codecvt_mode
 template <class _Elem> class __codecvt_utf8;
 
 template <>
-class __codecvt_utf8<wchar_t>
+class _LIBCPP_TYPE_VIS __codecvt_utf8<wchar_t>
     : public codecvt<wchar_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
@@ -108,7 +111,7 @@ protected:
 };
 
 template <>
-class __codecvt_utf8<char16_t>
+class _LIBCPP_TYPE_VIS __codecvt_utf8<char16_t>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
@@ -143,7 +146,7 @@ protected:
 };
 
 template <>
-class __codecvt_utf8<char32_t>
+class _LIBCPP_TYPE_VIS __codecvt_utf8<char32_t>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
@@ -179,7 +182,7 @@ protected:
 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
-class _LIBCPP_TYPE_VIS codecvt_utf8
+class _LIBCPP_TYPE_VIS_ONLY codecvt_utf8
     : public __codecvt_utf8<_Elem>
 {
 public:
@@ -196,7 +199,7 @@ public:
 template <class _Elem, bool _LittleEndian> class __codecvt_utf16;
 
 template <>
-class __codecvt_utf16<wchar_t, false>
+class _LIBCPP_TYPE_VIS __codecvt_utf16<wchar_t, false>
     : public codecvt<wchar_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
@@ -231,7 +234,7 @@ protected:
 };
 
 template <>
-class __codecvt_utf16<wchar_t, true>
+class _LIBCPP_TYPE_VIS __codecvt_utf16<wchar_t, true>
     : public codecvt<wchar_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
@@ -266,7 +269,7 @@ protected:
 };
 
 template <>
-class __codecvt_utf16<char16_t, false>
+class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, false>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
@@ -301,7 +304,7 @@ protected:
 };
 
 template <>
-class __codecvt_utf16<char16_t, true>
+class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, true>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
@@ -336,7 +339,7 @@ protected:
 };
 
 template <>
-class __codecvt_utf16<char32_t, false>
+class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, false>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
@@ -371,7 +374,7 @@ protected:
 };
 
 template <>
-class __codecvt_utf16<char32_t, true>
+class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, true>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
@@ -407,7 +410,7 @@ protected:
 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
-class _LIBCPP_TYPE_VIS codecvt_utf16
+class _LIBCPP_TYPE_VIS_ONLY codecvt_utf16
     : public __codecvt_utf16<_Elem, _Mode & little_endian>
 {
 public:
@@ -424,7 +427,7 @@ public:
 template <class _Elem> class __codecvt_utf8_utf16;
 
 template <>
-class __codecvt_utf8_utf16<wchar_t>
+class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<wchar_t>
     : public codecvt<wchar_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
@@ -459,7 +462,7 @@ protected:
 };
 
 template <>
-class __codecvt_utf8_utf16<char32_t>
+class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char32_t>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
@@ -494,7 +497,7 @@ protected:
 };
 
 template <>
-class __codecvt_utf8_utf16<char16_t>
+class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char16_t>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
@@ -530,7 +533,7 @@ protected:
 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
-class _LIBCPP_TYPE_VIS codecvt_utf8_utf16
+class _LIBCPP_TYPE_VIS_ONLY codecvt_utf8_utf16
     : public __codecvt_utf8_utf16<_Elem>
 {
 public:
diff --git a/system/include/libcxx/complex b/system/include/libcxx/complex
index dddc58e0dc916..2943da1d775ca 100644
--- a/system/include/libcxx/complex
+++ b/system/include/libcxx/complex
@@ -255,13 +255,13 @@ template<class T, class charT, class traits>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Tp> class _LIBCPP_TYPE_VIS complex;
+template<class _Tp> class _LIBCPP_TYPE_VIS_ONLY 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_TYPE_VIS complex
+class _LIBCPP_TYPE_VIS_ONLY complex
 {
 public:
     typedef _Tp value_type;
@@ -319,11 +319,11 @@ public:
         }
 };
 
-template<> class _LIBCPP_TYPE_VIS complex<double>;
-template<> class _LIBCPP_TYPE_VIS complex<long double>;
+template<> class _LIBCPP_TYPE_VIS_ONLY complex<double>;
+template<> class _LIBCPP_TYPE_VIS_ONLY complex<long double>;
 
 template<>
-class _LIBCPP_TYPE_VIS complex<float>
+class _LIBCPP_TYPE_VIS_ONLY complex<float>
 {
     float __re_;
     float __im_;
@@ -379,7 +379,7 @@ public:
 };
 
 template<>
-class _LIBCPP_TYPE_VIS complex<double>
+class _LIBCPP_TYPE_VIS_ONLY complex<double>
 {
     double __re_;
     double __im_;
@@ -435,7 +435,7 @@ public:
 };
 
 template<>
-class _LIBCPP_TYPE_VIS complex<long double>
+class _LIBCPP_TYPE_VIS_ONLY complex<long double>
 {
     long double __re_;
     long double __im_;
@@ -1521,6 +1521,47 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
     return __os << __s.str();
 }
 
+#if _LIBCPP_STD_VER > 11 
+// Literal suffix for complex number literals [complex.literals]
+inline namespace literals
+{ 
+  inline namespace complex_literals
+  {
+    constexpr complex<long double> operator""il(long double __im)
+    {
+        return { 0.0l, __im };
+    }
+
+    constexpr complex<long double> operator""il(unsigned long long __im)
+    {
+        return { 0.0l, static_cast<long double>(__im) };
+    }
+
+
+    constexpr complex<double> operator""i(long double __im)
+    {
+        return { 0.0, static_cast<double>(__im) };
+    }
+
+    constexpr complex<double> operator""i(unsigned long long __im)
+    {
+        return { 0.0, static_cast<double>(__im) };
+    }
+
+
+    constexpr complex<float> operator""if(long double __im)
+    {
+        return { 0.0f, static_cast<float>(__im) };
+    }
+
+    constexpr complex<float> operator""if(unsigned long long __im)
+    {
+        return { 0.0f, static_cast<float>(__im) };
+    }
+  }
+}
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_COMPLEX
diff --git a/system/include/libcxx/cstddef b/system/include/libcxx/cstddef
index c263772160285..7ef16ff2a367c 100644
--- a/system/include/libcxx/cstddef
+++ b/system/include/libcxx/cstddef
@@ -56,7 +56,7 @@ typedef long double max_align_t;
 
 #ifdef _LIBCPP_HAS_NO_NULLPTR
 
-struct _LIBCPP_TYPE_VIS nullptr_t
+struct _LIBCPP_TYPE_VIS_ONLY nullptr_t
 {
     void* __lx;
 
diff --git a/system/include/libcxx/cstdio b/system/include/libcxx/cstdio
index 1cde3eee536b7..ce3af4d91dc4b 100644
--- a/system/include/libcxx/cstdio
+++ b/system/include/libcxx/cstdio
@@ -74,7 +74,7 @@ int fputc(int c, FILE* stream);
 int fputs(const char* restrict s, FILE* restrict stream);
 int getc(FILE* stream);
 int getchar(void);
-char* gets(char* s);
+char* gets(char* s);  // removed in C++14
 int putc(int c, FILE* stream);
 int putchar(int c);
 int puts(const char* s);
@@ -103,6 +103,11 @@ void perror(const char* s);
 #pragma GCC system_header
 #endif
 
+// snprintf
+#if defined(_LIBCPP_MSVCRT)
+#include "support/win32/support.h"
+#endif
+
 #ifdef getc
 inline _LIBCPP_INLINE_VISIBILITY int __libcpp_getc(FILE* __stream) {return getc(__stream);}
 #undef getc
@@ -153,7 +158,9 @@ using ::fputc;
 using ::fputs;
 using ::getc;
 using ::getchar;
+#if _LIBCPP_STD_VER <= 11
 using ::gets;
+#endif
 using ::putc;
 using ::putchar;
 using ::puts;
diff --git a/system/include/libcxx/cstdlib b/system/include/libcxx/cstdlib
index 0a96fb0a858e2..152b891de78e4 100644
--- a/system/include/libcxx/cstdlib
+++ b/system/include/libcxx/cstdlib
@@ -155,7 +155,7 @@ using ::aligned_alloc;
 #endif
 
 // MSVCRT already has the correct prototype in <stdlib.h> #ifdef __cplusplus
-#if !defined(_LIBCPP_MSVCRT) && !defined(__sun__)
+#if !defined(_LIBCPP_MSVCRT) && !defined(__sun__) && !defined(_AIX)
 inline _LIBCPP_INLINE_VISIBILITY long      abs(     long __x) _NOEXCEPT {return  labs(__x);}
 #ifndef _LIBCPP_HAS_NO_LONG_LONG
 inline _LIBCPP_INLINE_VISIBILITY long long abs(long long __x) _NOEXCEPT {return llabs(__x);}
diff --git a/system/include/libcxx/cwchar b/system/include/libcxx/cwchar
index 90eae75e86978..9f51587caa5fd 100644
--- a/system/include/libcxx/cwchar
+++ b/system/include/libcxx/cwchar
@@ -106,7 +106,7 @@ size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
 #include <__config>
 #include <cwctype>
 #include <wchar.h>
-#ifdef _LIBCPP_MSVCRT
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
 #include <support/win32/support.h> // pull in *swprintf defines
 #endif // _LIBCPP_MSVCRT
 
diff --git a/system/include/libcxx/deque b/system/include/libcxx/deque
index 86272721f2175..f099000b137c6 100644
--- a/system/include/libcxx/deque
+++ b/system/include/libcxx/deque
@@ -41,6 +41,7 @@ public:
     deque() noexcept(is_nothrow_default_constructible<allocator_type>::value);
     explicit deque(const allocator_type& a);
     explicit deque(size_type n);
+    explicit deque(size_type n, const allocator_type& a); // C++14
     deque(size_type n, const value_type& v);
     deque(size_type n, const value_type& v, const allocator_type& a);
     template <class InputIterator>
@@ -170,7 +171,7 @@ template <class _Tp, class _Allocator> class __deque_base;
 
 template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
           class _DiffType, _DiffType _BlockSize>
-class _LIBCPP_TYPE_VIS __deque_iterator;
+class _LIBCPP_TYPE_VIS_ONLY __deque_iterator;
 
 template <class _RAIter,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
@@ -262,7 +263,7 @@ move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
 
 template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
           class _DiffType, _DiffType _BlockSize>
-class _LIBCPP_TYPE_VIS __deque_iterator
+class _LIBCPP_TYPE_VIS_ONLY __deque_iterator
 {
     typedef _MapPointer __map_iterator;
 public:
@@ -414,9 +415,9 @@ private:
         : __m_iter_(__m), __ptr_(__p) {}
 
     template <class _Tp, class _Ap> friend class __deque_base;
-    template <class _Tp, class _Ap> friend class _LIBCPP_TYPE_VIS deque;
+    template <class _Tp, class _Ap> friend class _LIBCPP_TYPE_VIS_ONLY deque;
     template <class _Vp, class _Pp, class _Rp, class _MP, class _Dp, _Dp>
-        friend class _LIBCPP_TYPE_VIS __deque_iterator;
+        friend class _LIBCPP_TYPE_VIS_ONLY __deque_iterator;
 
     template <class _RAIter,
               class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
@@ -1178,7 +1179,7 @@ __deque_base<_Tp, _Allocator>::clear() _NOEXCEPT
 }
 
 template <class _Tp, class _Allocator = allocator<_Tp> >
-class _LIBCPP_TYPE_VIS deque
+class _LIBCPP_TYPE_VIS_ONLY deque
     : private __deque_base<_Tp, _Allocator>
 {
 public:
@@ -1209,6 +1210,9 @@ public:
         {}
     _LIBCPP_INLINE_VISIBILITY deque(const allocator_type& __a) : __base(__a) {}
     explicit deque(size_type __n);
+#if _LIBCPP_STD_VER > 11
+    explicit deque(size_type __n, const _Allocator& __a);
+#endif
     deque(size_type __n, const value_type& __v);
     deque(size_type __n, const value_type& __v, const allocator_type& __a);
     template <class _InputIter>
@@ -1431,6 +1435,16 @@ deque<_Tp, _Allocator>::deque(size_type __n)
         __append(__n);
 }
 
+#if _LIBCPP_STD_VER > 11
+template <class _Tp, class _Allocator>
+deque<_Tp, _Allocator>::deque(size_type __n, const _Allocator& __a)
+    : __base(__a)
+{
+    if (__n > 0)
+        __append(__n);
+}
+#endif
+
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(size_type __n, const value_type& __v)
 {
@@ -2797,7 +2811,7 @@ deque<_Tp, _Allocator>::clear() _NOEXCEPT
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 {
@@ -2806,7 +2820,7 @@ operator==(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 {
@@ -2814,7 +2828,7 @@ operator!=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 {
@@ -2822,7 +2836,7 @@ operator< (const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator> (const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 {
@@ -2830,7 +2844,7 @@ operator> (const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 {
@@ -2838,7 +2852,7 @@ operator>=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 {
@@ -2846,7 +2860,7 @@ operator<=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(deque<_Tp, _Allocator>& __x, deque<_Tp, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
diff --git a/system/include/libcxx/dynarray b/system/include/libcxx/dynarray
new file mode 100644
index 0000000000000..b0d04f91544ef
--- /dev/null
+++ b/system/include/libcxx/dynarray
@@ -0,0 +1,311 @@
+// -*- C++ -*-
+//===-------------------------- dynarray ----------------------------------===//
+//
+//                     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_DYNARRAY
+#define _LIBCPP_DYNARRAY
+
+#include <__config>
+#if _LIBCPP_STD_VER > 11
+
+/*
+    dynarray synopsis
+
+namespace std {
+
+template< typename T >
+class dynarray
+{
+    // types:
+    typedef       T                               value_type;
+    typedef       T&                              reference;
+    typedef const T&                              const_reference;
+    typedef       T*                              pointer;
+    typedef const T*                              const_pointer;
+    typedef       implementation-defined          iterator;
+    typedef       implementation-defined          const_iterator;
+    typedef reverse_iterator<iterator>            reverse_iterator;
+    typedef reverse_iterator<const_iterator>      const_reverse_iterator;
+    typedef size_t                                size_type;
+    typedef ptrdiff_t                             difference_type;
+
+public:
+    // construct/copy/destroy:
+    explicit dynarray(size_type c);
+    template <typename Alloc>
+      dynarray(size_type c, const Alloc& alloc);
+    dynarray(size_type c, const T& v);
+    template <typename Alloc>
+      dynarray(size_type c, const T& v, const Alloc& alloc);
+    dynarray(const dynarray& d);
+    template <typename Alloc>
+      dynarray(const dynarray& d, const Alloc& alloc);
+    dynarray(initializer_list<T>);
+    template <typename Alloc>
+      dynarray(initializer_list<T>, const Alloc& alloc);
+
+    dynarray& operator=(const dynarray&) = delete;
+    ~dynarray();
+
+    // iterators:
+    iterator       begin()        noexcept;
+    const_iterator begin()  const noexcept;
+    const_iterator cbegin() const noexcept;
+    iterator       end()          noexcept;
+    const_iterator end()    const noexcept;
+    const_iterator cend()   const noexcept;
+
+    reverse_iterator       rbegin()        noexcept;
+    const_reverse_iterator rbegin()  const noexcept;
+    const_reverse_iterator crbegin() const noexcept;
+    reverse_iterator       rend()          noexcept;
+    const_reverse_iterator rend()    const noexcept;
+    const_reverse_iterator crend()   const noexcept;
+
+    // capacity:
+    size_type size()     const noexcept;
+    size_type max_size() const noexcept;
+    bool      empty()    const noexcept;
+
+    // element access:
+    reference       operator[](size_type n);
+    const_reference operator[](size_type n) const;
+
+    reference       front();
+    const_reference front() const;
+    reference       back();
+    const_reference back()  const;
+
+    const_reference at(size_type n) const;
+    reference       at(size_type n);
+
+    // data access:
+    T*       data()       noexcept;
+    const T* data() const noexcept;
+
+    // mutating member functions:
+    void fill(const T& v);
+};
+
+}  // std
+
+*/
+
+#include <__functional_base>
+#include <iterator>
+#include <stdexcept>
+#include <initializer_list>
+#include <new>
+#include <algorithm>
+
+#if defined(_LIBCPP_NO_EXCEPTIONS)
+    #include <cassert>
+#endif
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY dynarray
+{
+public:
+    // types:
+    typedef dynarray __self;
+    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;
+
+private:
+    size_t                  __size_;
+    value_type *            __base_;
+    _LIBCPP_ALWAYS_INLINE dynarray () noexcept : __base_(nullptr), __size_(0) {}
+    
+    static inline _LIBCPP_INLINE_VISIBILITY value_type* __allocate ( size_t count )
+    {
+        if ( numeric_limits<size_t>::max() / sizeof (value_type) <= count )
+        {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+            throw bad_array_length();
+#else
+            assert(!"dynarray::allocation");
+#endif
+        }
+        return static_cast<value_type *> (::operator new (sizeof(value_type) * count));
+    }
+
+    static inline _LIBCPP_INLINE_VISIBILITY void __deallocate ( value_type* __ptr ) noexcept
+    {
+        ::operator delete (static_cast<void *> (__ptr));
+    }
+
+public:
+
+    explicit dynarray(size_type __c);
+    dynarray(size_type __c, const value_type& __v);
+    dynarray(const dynarray& __d);
+    dynarray(initializer_list<value_type>);
+
+//  We're not implementing these right now.
+//  Waiting for the resolution of LWG issue #2235
+//     template <typename _Alloc>
+//       dynarray(size_type __c, const _Alloc& __alloc);
+//     template <typename _Alloc>
+//       dynarray(size_type __c, const value_type& __v, const _Alloc& __alloc);
+//     template <typename _Alloc>
+//       dynarray(const dynarray& __d, const _Alloc& __alloc);
+//     template <typename _Alloc>
+//       dynarray(initializer_list<value_type>, const _Alloc& __alloc);
+
+    dynarray& operator=(const dynarray&) = delete;
+    ~dynarray();
+
+    // iterators:
+    inline _LIBCPP_INLINE_VISIBILITY iterator       begin()        noexcept { return iterator(data()); }
+    inline _LIBCPP_INLINE_VISIBILITY const_iterator begin()  const noexcept { return const_iterator(data()); }
+    inline _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const noexcept { return const_iterator(data()); }
+    inline _LIBCPP_INLINE_VISIBILITY iterator       end()          noexcept { return iterator(data() + __size_); }
+    inline _LIBCPP_INLINE_VISIBILITY const_iterator end()    const noexcept { return const_iterator(data() + __size_); }
+    inline _LIBCPP_INLINE_VISIBILITY const_iterator cend()   const noexcept { return const_iterator(data() + __size_); }
+
+    inline _LIBCPP_INLINE_VISIBILITY reverse_iterator       rbegin()        noexcept { return reverse_iterator(end()); }
+    inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rbegin()  const noexcept { return const_reverse_iterator(end()); }
+    inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
+    inline _LIBCPP_INLINE_VISIBILITY reverse_iterator       rend()          noexcept { return reverse_iterator(begin()); }
+    inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rend()    const noexcept { return const_reverse_iterator(begin()); }
+    inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crend()   const noexcept { return const_reverse_iterator(begin()); }
+
+    // capacity:
+    inline _LIBCPP_INLINE_VISIBILITY size_type size()     const noexcept { return __size_; }
+    inline _LIBCPP_INLINE_VISIBILITY size_type max_size() const noexcept { return __size_; }
+    inline _LIBCPP_INLINE_VISIBILITY bool      empty()    const noexcept { return __size_ == 0; }
+
+    // element access:
+    inline _LIBCPP_INLINE_VISIBILITY reference       operator[](size_type __n)       { return data()[__n]; }
+    inline _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const { return data()[__n]; }
+
+    inline _LIBCPP_INLINE_VISIBILITY reference       front()       { return data()[0]; }
+    inline _LIBCPP_INLINE_VISIBILITY const_reference front() const { return data()[0]; }
+    inline _LIBCPP_INLINE_VISIBILITY reference       back()        { return data()[__size_-1]; }
+    inline _LIBCPP_INLINE_VISIBILITY const_reference back()  const { return data()[__size_-1]; }
+
+    inline _LIBCPP_INLINE_VISIBILITY const_reference at(size_type __n) const;
+    inline _LIBCPP_INLINE_VISIBILITY reference       at(size_type __n);
+
+    // data access:
+    inline _LIBCPP_INLINE_VISIBILITY _Tp*       data()       noexcept { return __base_; }
+    inline _LIBCPP_INLINE_VISIBILITY const _Tp* data() const noexcept { return __base_; }
+
+    // mutating member functions:
+    inline _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __v) { fill_n(begin(), __size_, __v); }
+};
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+dynarray<_Tp>::dynarray(size_type __c) : dynarray ()
+{
+    __base_ = __allocate (__c);
+    value_type *__data = data ();
+    for ( __size_ = 0; __size_ < __c; ++__size_, ++__data )
+        ::new (__data) value_type;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+dynarray<_Tp>::dynarray(size_type __c, const value_type& __v) : dynarray ()
+{
+    __base_ = __allocate (__c);
+    value_type *__data = data ();
+    for ( __size_ = 0; __size_ < __c; ++__size_, ++__data )
+        ::new (__data) value_type (__v);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+dynarray<_Tp>::dynarray(initializer_list<value_type> __il) : dynarray ()
+{
+    size_t sz = __il.size();
+    __base_ = __allocate (sz);
+    value_type *__data = data ();
+    auto src = __il.begin();
+    for ( __size_ = 0; __size_ < sz; ++__size_, ++__data, ++src )
+        ::new (__data) value_type (*src);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+dynarray<_Tp>::dynarray(const dynarray& __d) : dynarray ()
+{
+    size_t sz = __d.size();
+    __base_ = __allocate (sz);
+    value_type *__data = data ();
+    auto src = __d.begin();
+    for ( __size_ = 0; __size_ < sz; ++__size_, ++__data, ++src )
+        ::new (__data) value_type (*src);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+dynarray<_Tp>::~dynarray()
+{ 
+    value_type *__data = data () + __size_;
+    for ( size_t i = 0; i < __size_; ++i )
+        (--__data)->value_type::~value_type();
+    __deallocate ( __base_ );
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+typename dynarray<_Tp>::reference
+dynarray<_Tp>::at(size_type __n)
+{
+    if (__n >= __size_)
+    {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        throw out_of_range("dynarray::at");
+#else
+        assert(!"dynarray::at out_of_range");
+#endif
+    }
+    return data()[__n];
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+typename dynarray<_Tp>::const_reference
+dynarray<_Tp>::at(size_type __n) const
+{
+    if (__n >= __size_)
+    {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        throw out_of_range("dynarray::at");
+#else
+        assert(!"dynarray::at out_of_range");
+#endif
+    }
+    return data()[__n];
+}
+
+template <class _Tp, class _Alloc>
+struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<dynarray<_Tp>, _Alloc> : true_type {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif  // if _LIBCPP_STD_VER > 11 
+#endif  // _LIBCPP_DYNARRAY
diff --git a/system/include/libcxx/exception b/system/include/libcxx/exception
index 102b10d6099af..ddd75bd45643c 100644
--- a/system/include/libcxx/exception
+++ b/system/include/libcxx/exception
@@ -118,8 +118,8 @@ _LIBCPP_FUNC_VIS bool uncaught_exception() _NOEXCEPT;
 
 class _LIBCPP_TYPE_VIS exception_ptr;
 
-exception_ptr current_exception() _NOEXCEPT;
-_LIBCPP_NORETURN void rethrow_exception(exception_ptr);
+_LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
+_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
 
 class _LIBCPP_TYPE_VIS exception_ptr
 {
@@ -142,8 +142,8 @@ public:
     bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
         {return !(__x == __y);}
 
-    friend exception_ptr current_exception() _NOEXCEPT;
-    friend void rethrow_exception(exception_ptr);
+    friend _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
+    friend _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
 };
 
 template<class _Ep>
diff --git a/system/include/libcxx/ext/__hash b/system/include/libcxx/ext/__hash
index f6ecfe3605c7e..04975bfd05216 100644
--- a/system/include/libcxx/ext/__hash
+++ b/system/include/libcxx/ext/__hash
@@ -19,10 +19,10 @@
 namespace __gnu_cxx {
 using namespace std;
 
-template <typename T> struct _LIBCPP_TYPE_VIS hash : public std::hash<T>
+template <typename T> struct _LIBCPP_TYPE_VIS_ONLY hash : public std::hash<T>
     { };
 
-template <> struct _LIBCPP_TYPE_VIS hash<const char*>
+template <> struct _LIBCPP_TYPE_VIS_ONLY hash<const char*>
     : public unary_function<const char*, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -32,7 +32,7 @@ template <> struct _LIBCPP_TYPE_VIS hash<const char*>
     }
 };
 
-template <> struct _LIBCPP_TYPE_VIS hash<char *>
+template <> struct _LIBCPP_TYPE_VIS_ONLY hash<char *>
     : public unary_function<char*, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
diff --git a/system/include/libcxx/ext/hash_map b/system/include/libcxx/ext/hash_map
index a6fe894e4d94f..225b72baa2c9c 100644
--- a/system/include/libcxx/ext/hash_map
+++ b/system/include/libcxx/ext/hash_map
@@ -206,7 +206,11 @@ template <class Key, class T, class Hash, class Pred, class Alloc>
 #include <ext/__hash>
 
 #if __DEPRECATED
-#warning Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>
+#if defined(_MSC_VER) && ! defined(__clang__)
+    _LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>")
+#else
+#   warning Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>
+#endif
 #endif
 
 #pragma GCC system_header
@@ -361,7 +365,7 @@ public:
 };
 
 template <class _HashIterator>
-class _LIBCPP_TYPE_VIS __hash_map_iterator
+class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator
 {
     _HashIterator __i_;
 
@@ -404,15 +408,15 @@ public:
     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_TYPE_VIS hash_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS hash_multimap;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_const_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_map_const_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY hash_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY hash_multimap;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator;
 };
 
 template <class _HashIterator>
-class _LIBCPP_TYPE_VIS __hash_map_const_iterator
+class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator
 {
     _HashIterator __i_;
 
@@ -463,15 +467,15 @@ public:
     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_TYPE_VIS hash_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS hash_multimap;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_const_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY hash_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY hash_multimap;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __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_TYPE_VIS hash_map
+class _LIBCPP_TYPE_VIS_ONLY hash_map
 {
 public:
     // types
@@ -684,7 +688,7 @@ hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type& __k)
     __h.get_deleter().__first_constructed = true;
     __node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
     __h.get_deleter().__second_constructed = true;
-    return _VSTD::move(__h);
+    return _VSTD::move(__h);  // explicitly moved for C++03
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
@@ -750,7 +754,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_TYPE_VIS hash_multimap
+class _LIBCPP_TYPE_VIS_ONLY hash_multimap
 {
 public:
     // types
diff --git a/system/include/libcxx/ext/hash_set b/system/include/libcxx/ext/hash_set
index 52bbeee13c35c..c4bb89843d552 100644
--- a/system/include/libcxx/ext/hash_set
+++ b/system/include/libcxx/ext/hash_set
@@ -199,7 +199,11 @@ template <class Value, class Hash, class Pred, class Alloc>
 #include <ext/__hash>
 
 #if __DEPRECATED
-#warning Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>
+#if defined(_MSC_VER) && ! defined(__clang__)
+    _LIBCPP_WARNING("Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>")
+#else
+#   warning Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>
+#endif
 #endif
 
 namespace __gnu_cxx {
@@ -208,7 +212,7 @@ using namespace std;
 
 template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
           class _Alloc = allocator<_Value> >
-class _LIBCPP_TYPE_VIS hash_set
+class _LIBCPP_TYPE_VIS_ONLY hash_set
 {
 public:
     // types
@@ -429,7 +433,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_TYPE_VIS hash_multiset
+class _LIBCPP_TYPE_VIS_ONLY hash_multiset
 {
 public:
     // types
diff --git a/system/include/libcxx/forward_list b/system/include/libcxx/forward_list
index 88bf75f90d7cc..398226b8d42d2 100644
--- a/system/include/libcxx/forward_list
+++ b/system/include/libcxx/forward_list
@@ -38,6 +38,7 @@ public:
         noexcept(is_nothrow_default_constructible<allocator_type>::value);
     explicit forward_list(const allocator_type& a);
     explicit forward_list(size_type n);
+    explicit forward_list(size_type n, const allocator_type& a); // C++14
     forward_list(size_type n, const value_type& v);
     forward_list(size_type n, const value_type& v, const allocator_type& a);
     template <class InputIterator>
@@ -212,11 +213,11 @@ struct __forward_list_node
     value_type __value_;
 };
 
-template<class _Tp, class _Alloc> class _LIBCPP_TYPE_VIS forward_list;
-template<class _NodeConstPtr> class _LIBCPP_TYPE_VIS __forward_list_const_iterator;
+template<class _Tp, class _Alloc> class _LIBCPP_TYPE_VIS_ONLY forward_list;
+template<class _NodeConstPtr> class _LIBCPP_TYPE_VIS_ONLY __forward_list_const_iterator;
 
 template <class _NodePtr>
-class _LIBCPP_TYPE_VIS __forward_list_iterator
+class _LIBCPP_TYPE_VIS_ONLY __forward_list_iterator
 {
     typedef _NodePtr __node_pointer;
 
@@ -225,8 +226,8 @@ class _LIBCPP_TYPE_VIS __forward_list_iterator
     _LIBCPP_INLINE_VISIBILITY
     explicit __forward_list_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
 
-    template<class, class> friend class _LIBCPP_TYPE_VIS forward_list;
-    template<class> friend class _LIBCPP_TYPE_VIS __forward_list_const_iterator;
+    template<class, class> friend class _LIBCPP_TYPE_VIS_ONLY forward_list;
+    template<class> friend class _LIBCPP_TYPE_VIS_ONLY __forward_list_const_iterator;
 
 public:
     typedef forward_iterator_tag                              iterator_category;
@@ -276,7 +277,7 @@ public:
 };
 
 template <class _NodeConstPtr>
-class _LIBCPP_TYPE_VIS __forward_list_const_iterator
+class _LIBCPP_TYPE_VIS_ONLY __forward_list_const_iterator
 {
     typedef _NodeConstPtr __node_const_pointer;
 
@@ -542,7 +543,7 @@ __forward_list_base<_Tp, _Alloc>::clear() _NOEXCEPT
 }
 
 template <class _Tp, class _Alloc = allocator<_Tp> >
-class _LIBCPP_TYPE_VIS forward_list
+class _LIBCPP_TYPE_VIS_ONLY forward_list
     : private __forward_list_base<_Tp, _Alloc>
 {
     typedef __forward_list_base<_Tp, _Alloc> base;
@@ -571,6 +572,9 @@ public:
         {} // = default;
     explicit forward_list(const allocator_type& __a);
     explicit forward_list(size_type __n);
+#if _LIBCPP_STD_VER > 11
+    explicit forward_list(size_type __n, const allocator_type& __a);
+#endif
     forward_list(size_type __n, const value_type& __v);
     forward_list(size_type __n, const value_type& __v, const allocator_type& __a);
     template <class _InputIterator>
@@ -794,6 +798,28 @@ forward_list<_Tp, _Alloc>::forward_list(size_type __n)
     }
 }
 
+#if _LIBCPP_STD_VER > 11
+template <class _Tp, class _Alloc>
+forward_list<_Tp, _Alloc>::forward_list(size_type __n, const allocator_type& __a)
+    : base ( __a )
+{
+    if (__n > 0)
+    {
+        __node_allocator& __a = base::__alloc();
+        typedef __allocator_destructor<__node_allocator> _Dp;
+        unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
+        for (__node_pointer __p = base::__before_begin(); __n > 0; --__n,
+                                                             __p = __p->__next_)
+        {
+            __h.reset(__node_traits::allocate(__a, 1));
+            __node_traits::construct(__a, _VSTD::addressof(__h->__value_));
+            __h->__next_ = nullptr;
+            __p->__next_ = __h.release();
+        }
+    }
+}
+#endif
+
 template <class _Tp, class _Alloc>
 forward_list<_Tp, _Alloc>::forward_list(size_type __n, const value_type& __v)
 {
diff --git a/system/include/libcxx/fstream b/system/include/libcxx/fstream
index e3f8306f4a01b..38778c6779aa4 100644
--- a/system/include/libcxx/fstream
+++ b/system/include/libcxx/fstream
@@ -180,7 +180,7 @@ typedef basic_fstream<wchar_t> wfstream;
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS basic_filebuf
+class _LIBCPP_TYPE_VIS_ONLY basic_filebuf
     : public basic_streambuf<_CharT, _Traits>
 {
 public:
@@ -994,7 +994,7 @@ basic_filebuf<_CharT, _Traits>::__write_mode()
 // basic_ifstream
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS basic_ifstream
+class _LIBCPP_TYPE_VIS_ONLY basic_ifstream
     : public basic_istream<_CharT, _Traits>
 {
 public:
@@ -1139,7 +1139,7 @@ basic_ifstream<_CharT, _Traits>::close()
 // basic_ofstream
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS basic_ofstream
+class _LIBCPP_TYPE_VIS_ONLY basic_ofstream
     : public basic_ostream<_CharT, _Traits>
 {
 public:
@@ -1284,7 +1284,7 @@ basic_ofstream<_CharT, _Traits>::close()
 // basic_fstream
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS basic_fstream
+class _LIBCPP_TYPE_VIS_ONLY basic_fstream
     : public basic_iostream<_CharT, _Traits>
 {
 public:
diff --git a/system/include/libcxx/functional b/system/include/libcxx/functional
index 2130f0e36cd57..d40f70af40ba8 100644
--- a/system/include/libcxx/functional
+++ b/system/include/libcxx/functional
@@ -56,7 +56,7 @@ public:
 
     // invoke
     template <class... ArgTypes>
-      typename result_of<T(ArgTypes...)>::type
+      typename result_of<T&(ArgTypes&&...)>::type
           operator() (ArgTypes&&...) const;
 };
 
@@ -358,18 +358,6 @@ template <class S, class T>          const_mem_fun_ref_t<S,T>    mem_fun_ref(S (
 template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);
 
 template<class R, class T> unspecified mem_fn(R T::*);
-template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...));
-template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const);
-template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile);
-template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile);
-template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &);
-template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &);
-template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &);
-template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &);
-template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &&);
-template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &&);
-template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &&);
-template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &&);
 
 class bad_function_call
     : public exception
@@ -502,19 +490,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS plus : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY plus : binary_function<_Tp, _Tp, _Tp>
 {
-    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x + __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS plus<void>
+struct _LIBCPP_TYPE_VIS_ONLY plus<void>
 {
     template <class _T1, class _T2>
-    _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -524,19 +515,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS minus : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY minus : binary_function<_Tp, _Tp, _Tp>
 {
-    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x - __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS minus<void>
+struct _LIBCPP_TYPE_VIS_ONLY minus<void>
 {
     template <class _T1, class _T2>
-    _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -546,19 +540,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS multiplies : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY multiplies : binary_function<_Tp, _Tp, _Tp>
 {
-    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x * __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS multiplies<void>
+struct _LIBCPP_TYPE_VIS_ONLY multiplies<void>
 {
     template <class _T1, class _T2>
-    _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -568,19 +565,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS divides : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY divides : binary_function<_Tp, _Tp, _Tp>
 {
-    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x / __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS divides<void>
+struct _LIBCPP_TYPE_VIS_ONLY divides<void>
 {
     template <class _T1, class _T2>
-    _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -590,19 +590,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS modulus : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY modulus : binary_function<_Tp, _Tp, _Tp>
 {
-    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x % __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS modulus<void>
+struct _LIBCPP_TYPE_VIS_ONLY modulus<void>
 {
     template <class _T1, class _T2>
-    _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -612,19 +615,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS negate : unary_function<_Tp, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY negate : unary_function<_Tp, _Tp>
 {
-    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x) const
         {return -__x;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS negate<void>
+struct _LIBCPP_TYPE_VIS_ONLY negate<void>
 {
     template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_Tp&& __x) const
         { return -_VSTD::forward<_Tp>(__x); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -634,19 +640,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS equal_to : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS_ONLY equal_to : binary_function<_Tp, _Tp, bool>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x == __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS equal_to<void>
+struct _LIBCPP_TYPE_VIS_ONLY equal_to<void>
 {
-    template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY
+    template <class _T1, class _T2>
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -656,19 +665,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS not_equal_to : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS_ONLY not_equal_to : binary_function<_Tp, _Tp, bool>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x != __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS not_equal_to<void>
+struct _LIBCPP_TYPE_VIS_ONLY not_equal_to<void>
 {
-    template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY
+    template <class _T1, class _T2>
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -678,19 +690,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS greater : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS_ONLY greater : binary_function<_Tp, _Tp, bool>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x > __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS greater<void>
+struct _LIBCPP_TYPE_VIS_ONLY greater<void>
 {
-    template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY
+    template <class _T1, class _T2>
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -702,19 +717,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS greater_equal : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS_ONLY greater_equal : binary_function<_Tp, _Tp, bool>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x >= __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS greater_equal<void>
+struct _LIBCPP_TYPE_VIS_ONLY greater_equal<void>
 {
-    template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY
+    template <class _T1, class _T2>
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -724,19 +742,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS less_equal : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS_ONLY less_equal : binary_function<_Tp, _Tp, bool>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x <= __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS less_equal<void>
+struct _LIBCPP_TYPE_VIS_ONLY less_equal<void>
 {
-    template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY
+    template <class _T1, class _T2>
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -746,19 +767,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS logical_and : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS_ONLY logical_and : binary_function<_Tp, _Tp, bool>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x && __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS logical_and<void>
+struct _LIBCPP_TYPE_VIS_ONLY logical_and<void>
 {
-    template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY
+    template <class _T1, class _T2>
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -768,19 +792,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS logical_or : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS_ONLY logical_or : binary_function<_Tp, _Tp, bool>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x || __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS logical_or<void>
+struct _LIBCPP_TYPE_VIS_ONLY logical_or<void>
 {
-    template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY
+    template <class _T1, class _T2>
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -790,19 +817,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS logical_not : unary_function<_Tp, bool>
+struct _LIBCPP_TYPE_VIS_ONLY logical_not : unary_function<_Tp, bool>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x) const
         {return !__x;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS logical_not<void>
+struct _LIBCPP_TYPE_VIS_ONLY logical_not<void>
 {
     template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_Tp&& __x) const
         { return !_VSTD::forward<_Tp>(__x); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -812,19 +842,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS bit_and : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY bit_and : binary_function<_Tp, _Tp, _Tp>
 {
-    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x & __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS bit_and<void>
+struct _LIBCPP_TYPE_VIS_ONLY bit_and<void>
 {
-    template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY
+    template <class _T1, class _T2>
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -834,19 +867,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS bit_or : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY bit_or : binary_function<_Tp, _Tp, _Tp>
 {
-    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x | __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS bit_or<void>
+struct _LIBCPP_TYPE_VIS_ONLY bit_or<void>
 {
-    template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY
+    template <class _T1, class _T2>
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
@@ -856,79 +892,89 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TYPE_VIS bit_xor : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY bit_xor : binary_function<_Tp, _Tp, _Tp>
 {
-    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x ^ __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
-struct _LIBCPP_TYPE_VIS bit_xor<void>
+struct _LIBCPP_TYPE_VIS_ONLY bit_xor<void>
 {
-    template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY
+    template <class _T1, class _T2>
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
         { return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
 };
 #endif
 
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
-struct _LIBCPP_TYPE_VIS bit_not : unary_function<_Tp, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY bit_not : unary_function<_Tp, _Tp>
 {
-    _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x) const
         {return ~__x;}
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS bit_not<void>
+struct _LIBCPP_TYPE_VIS_ONLY bit_not<void>
 {
     template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_Tp&& __x) const
         { return ~_VSTD::forward<_Tp>(__x); }
+    typedef void is_transparent;
 };
 #endif
 
 template <class _Predicate>
-class _LIBCPP_TYPE_VIS unary_negate
+class _LIBCPP_TYPE_VIS_ONLY unary_negate
     : public unary_function<typename _Predicate::argument_type, bool>
 {
     _Predicate __pred_;
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit unary_negate(const _Predicate& __pred)
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    explicit unary_negate(const _Predicate& __pred)
         : __pred_(__pred) {}
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const typename _Predicate::argument_type& __x) const
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool operator()(const typename _Predicate::argument_type& __x) const
         {return !__pred_(__x);}
 };
 
 template <class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 unary_negate<_Predicate>
 not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}
 
 template <class _Predicate>
-class _LIBCPP_TYPE_VIS binary_negate
+class _LIBCPP_TYPE_VIS_ONLY binary_negate
     : public binary_function<typename _Predicate::first_argument_type,
                              typename _Predicate::second_argument_type,
                              bool>
 {
     _Predicate __pred_;
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit binary_negate(const _Predicate& __pred)
-        : __pred_(__pred) {}
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const typename _Predicate::first_argument_type& __x,
+    _LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_AFTER_CXX11 
+    binary_negate(const _Predicate& __pred) : __pred_(__pred) {}
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool operator()(const typename _Predicate::first_argument_type& __x,
                     const typename _Predicate::second_argument_type& __y) const
         {return !__pred_(__x, __y);}
 };
 
 template <class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 binary_negate<_Predicate>
 not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
 
 template <class __Operation>
-class _LIBCPP_TYPE_VIS binder1st
+class _LIBCPP_TYPE_VIS_ONLY binder1st
     : public unary_function<typename __Operation::second_argument_type,
                             typename __Operation::result_type>
 {
@@ -954,7 +1000,7 @@ bind1st(const __Operation& __op, const _Tp& __x)
     {return binder1st<__Operation>(__op, __x);}
 
 template <class __Operation>
-class _LIBCPP_TYPE_VIS binder2nd
+class _LIBCPP_TYPE_VIS_ONLY binder2nd
     : public unary_function<typename __Operation::first_argument_type,
                             typename __Operation::result_type>
 {
@@ -980,7 +1026,7 @@ bind2nd(const __Operation& __op, const _Tp& __x)
     {return binder2nd<__Operation>(__op, __x);}
 
 template <class _Arg, class _Result>
-class _LIBCPP_TYPE_VIS pointer_to_unary_function
+class _LIBCPP_TYPE_VIS_ONLY pointer_to_unary_function
     : public unary_function<_Arg, _Result>
 {
     _Result (*__f_)(_Arg);
@@ -998,7 +1044,7 @@ ptr_fun(_Result (*__f)(_Arg))
     {return pointer_to_unary_function<_Arg,_Result>(__f);}
 
 template <class _Arg1, class _Arg2, class _Result>
-class _LIBCPP_TYPE_VIS pointer_to_binary_function
+class _LIBCPP_TYPE_VIS_ONLY pointer_to_binary_function
     : public binary_function<_Arg1, _Arg2, _Result>
 {
     _Result (*__f_)(_Arg1, _Arg2);
@@ -1016,7 +1062,7 @@ ptr_fun(_Result (*__f)(_Arg1,_Arg2))
     {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);}
 
 template<class _Sp, class _Tp>
-class _LIBCPP_TYPE_VIS mem_fun_t : public unary_function<_Tp*, _Sp>
+class _LIBCPP_TYPE_VIS_ONLY mem_fun_t : public unary_function<_Tp*, _Sp>
 {
     _Sp (_Tp::*__p_)();
 public:
@@ -1027,7 +1073,7 @@ public:
 };
 
 template<class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TYPE_VIS mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>
+class _LIBCPP_TYPE_VIS_ONLY mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap);
 public:
@@ -1050,7 +1096,7 @@ mem_fun(_Sp (_Tp::*__f)(_Ap))
     {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 
 template<class _Sp, class _Tp>
-class _LIBCPP_TYPE_VIS mem_fun_ref_t : public unary_function<_Tp, _Sp>
+class _LIBCPP_TYPE_VIS_ONLY mem_fun_ref_t : public unary_function<_Tp, _Sp>
 {
     _Sp (_Tp::*__p_)();
 public:
@@ -1061,7 +1107,7 @@ public:
 };
 
 template<class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TYPE_VIS mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
+class _LIBCPP_TYPE_VIS_ONLY mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap);
 public:
@@ -1084,7 +1130,7 @@ mem_fun_ref(_Sp (_Tp::*__f)(_Ap))
     {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
 
 template <class _Sp, class _Tp>
-class _LIBCPP_TYPE_VIS const_mem_fun_t : public unary_function<const _Tp*, _Sp>
+class _LIBCPP_TYPE_VIS_ONLY const_mem_fun_t : public unary_function<const _Tp*, _Sp>
 {
     _Sp (_Tp::*__p_)() const;
 public:
@@ -1095,7 +1141,7 @@ public:
 };
 
 template <class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TYPE_VIS const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>
+class _LIBCPP_TYPE_VIS_ONLY const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap) const;
 public:
@@ -1118,7 +1164,7 @@ mem_fun(_Sp (_Tp::*__f)(_Ap) const)
     {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 
 template <class _Sp, class _Tp>
-class _LIBCPP_TYPE_VIS const_mem_fun_ref_t : public unary_function<_Tp, _Sp>
+class _LIBCPP_TYPE_VIS_ONLY const_mem_fun_ref_t : public unary_function<_Tp, _Sp>
 {
     _Sp (_Tp::*__p_)() const;
 public:
@@ -1129,7 +1175,7 @@ public:
 };
 
 template <class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TYPE_VIS const_mem_fun1_ref_t
+class _LIBCPP_TYPE_VIS_ONLY const_mem_fun1_ref_t
     : public binary_function<_Tp, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap) const;
@@ -1189,38 +1235,6 @@ mem_fn(_Rp _Tp::* __pm)
     return __mem_fn<_Rp _Tp::*>(__pm);
 }
 
-template<class _Rp, class _Tp, class ..._Args>
-inline _LIBCPP_INLINE_VISIBILITY
-__mem_fn<_Rp (_Tp::*)(_Args...)>
-mem_fn(_Rp (_Tp::* __pm)(_Args...))
-{
-    return __mem_fn<_Rp (_Tp::*)(_Args...)>(__pm);
-}
-
-template<class _Rp, class _Tp, class ..._Args>
-inline _LIBCPP_INLINE_VISIBILITY
-__mem_fn<_Rp (_Tp::*)(_Args...) const>
-mem_fn(_Rp (_Tp::* __pm)(_Args...) const)
-{
-    return __mem_fn<_Rp (_Tp::*)(_Args...) const>(__pm);
-}
-
-template<class _Rp, class _Tp, class ..._Args>
-inline _LIBCPP_INLINE_VISIBILITY
-__mem_fn<_Rp (_Tp::*)(_Args...) volatile>
-mem_fn(_Rp (_Tp::* __pm)(_Args...) volatile)
-{
-    return __mem_fn<_Rp (_Tp::*)(_Args...) volatile>(__pm);
-}
-
-template<class _Rp, class _Tp, class ..._Args>
-inline _LIBCPP_INLINE_VISIBILITY
-__mem_fn<_Rp (_Tp::*)(_Args...) const volatile>
-mem_fn(_Rp (_Tp::* __pm)(_Args...) const volatile)
-{
-    return __mem_fn<_Rp (_Tp::*)(_Args...) const volatile>(__pm);
-}
-
 // bad_function_call
 
 class _LIBCPP_EXCEPTION_ABI bad_function_call
@@ -1228,7 +1242,7 @@ class _LIBCPP_EXCEPTION_ABI bad_function_call
 {
 };
 
-template<class _Fp> class _LIBCPP_TYPE_VIS function; // undefined
+template<class _Fp> class _LIBCPP_TYPE_VIS_ONLY function; // undefined
 
 namespace __function
 {
@@ -1379,7 +1393,7 @@ __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
 }  // __function
 
 template<class _Rp, class ..._ArgTypes>
-class _LIBCPP_TYPE_VIS function<_Rp(_ArgTypes...)>
+class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_ArgTypes...)>
     : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
       public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
 {
@@ -1801,11 +1815,11 @@ swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCE
 {return __x.swap(__y);}
 
 template<class _Tp> struct __is_bind_expression : public false_type {};
-template<class _Tp> struct _LIBCPP_TYPE_VIS is_bind_expression
+template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_bind_expression
     : public __is_bind_expression<typename remove_cv<_Tp>::type> {};
 
 template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
-template<class _Tp> struct _LIBCPP_TYPE_VIS is_placeholder
+template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_placeholder
     : public __is_placeholder<typename remove_cv<_Tp>::type> {};
 
 namespace placeholders
@@ -1813,16 +1827,16 @@ namespace placeholders
 
 template <int _Np> struct __ph {};
 
-extern __ph<1>   _1;
-extern __ph<2>   _2;
-extern __ph<3>   _3;
-extern __ph<4>   _4;
-extern __ph<5>   _5;
-extern __ph<6>   _6;
-extern __ph<7>   _7;
-extern __ph<8>   _8;
-extern __ph<9>   _9;
-extern __ph<10> _10;
+_LIBCPP_FUNC_VIS extern __ph<1>   _1;
+_LIBCPP_FUNC_VIS extern __ph<2>   _2;
+_LIBCPP_FUNC_VIS extern __ph<3>   _3;
+_LIBCPP_FUNC_VIS extern __ph<4>   _4;
+_LIBCPP_FUNC_VIS extern __ph<5>   _5;
+_LIBCPP_FUNC_VIS extern __ph<6>   _6;
+_LIBCPP_FUNC_VIS extern __ph<7>   _7;
+_LIBCPP_FUNC_VIS extern __ph<8>   _8;
+_LIBCPP_FUNC_VIS extern __ph<9>   _9;
+_LIBCPP_FUNC_VIS extern __ph<10> _10;
 
 }  // placeholders
 
@@ -2184,7 +2198,7 @@ bind(_Fp&& __f, _BoundArgs&&... __bound_args)
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<bool>
+struct _LIBCPP_TYPE_VIS_ONLY hash<bool>
     : public unary_function<bool, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2192,7 +2206,7 @@ struct _LIBCPP_TYPE_VIS hash<bool>
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<char>
+struct _LIBCPP_TYPE_VIS_ONLY hash<char>
     : public unary_function<char, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2200,7 +2214,7 @@ struct _LIBCPP_TYPE_VIS hash<char>
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<signed char>
+struct _LIBCPP_TYPE_VIS_ONLY hash<signed char>
     : public unary_function<signed char, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2208,7 +2222,7 @@ struct _LIBCPP_TYPE_VIS hash<signed char>
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<unsigned char>
+struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned char>
     : public unary_function<unsigned char, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2218,7 +2232,7 @@ struct _LIBCPP_TYPE_VIS hash<unsigned char>
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<char16_t>
+struct _LIBCPP_TYPE_VIS_ONLY hash<char16_t>
     : public unary_function<char16_t, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2226,7 +2240,7 @@ struct _LIBCPP_TYPE_VIS hash<char16_t>
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<char32_t>
+struct _LIBCPP_TYPE_VIS_ONLY hash<char32_t>
     : public unary_function<char32_t, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2236,7 +2250,7 @@ struct _LIBCPP_TYPE_VIS hash<char32_t>
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<wchar_t>
+struct _LIBCPP_TYPE_VIS_ONLY hash<wchar_t>
     : public unary_function<wchar_t, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2244,7 +2258,7 @@ struct _LIBCPP_TYPE_VIS hash<wchar_t>
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<short>
+struct _LIBCPP_TYPE_VIS_ONLY hash<short>
     : public unary_function<short, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2252,7 +2266,7 @@ struct _LIBCPP_TYPE_VIS hash<short>
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<unsigned short>
+struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned short>
     : public unary_function<unsigned short, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2260,7 +2274,7 @@ struct _LIBCPP_TYPE_VIS hash<unsigned short>
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<int>
+struct _LIBCPP_TYPE_VIS_ONLY hash<int>
     : public unary_function<int, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2268,7 +2282,7 @@ struct _LIBCPP_TYPE_VIS hash<int>
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<unsigned int>
+struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned int>
     : public unary_function<unsigned int, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2276,7 +2290,7 @@ struct _LIBCPP_TYPE_VIS hash<unsigned int>
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<long>
+struct _LIBCPP_TYPE_VIS_ONLY hash<long>
     : public unary_function<long, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2284,7 +2298,7 @@ struct _LIBCPP_TYPE_VIS hash<long>
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<unsigned long>
+struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned long>
     : public unary_function<unsigned long, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2292,19 +2306,19 @@ struct _LIBCPP_TYPE_VIS hash<unsigned long>
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<long long>
+struct _LIBCPP_TYPE_VIS_ONLY hash<long long>
     : public __scalar_hash<long long>
 {
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<unsigned long long>
+struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned long long>
     : public __scalar_hash<unsigned long long>
 {
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<float>
+struct _LIBCPP_TYPE_VIS_ONLY hash<float>
     : public __scalar_hash<float>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2318,7 +2332,7 @@ struct _LIBCPP_TYPE_VIS hash<float>
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<double>
+struct _LIBCPP_TYPE_VIS_ONLY hash<double>
     : public __scalar_hash<double>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2332,7 +2346,7 @@ struct _LIBCPP_TYPE_VIS hash<double>
 };
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<long double>
+struct _LIBCPP_TYPE_VIS_ONLY hash<long double>
     : public __scalar_hash<long double>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2381,6 +2395,22 @@ struct _LIBCPP_TYPE_VIS hash<long double>
     }
 };
 
+#if _LIBCPP_STD_VER > 11
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY hash
+    : public unary_function<_Tp, size_t>
+{
+    static_assert(is_enum<_Tp>::value, "This hash only works for enumeration types");
+
+    _LIBCPP_INLINE_VISIBILITY
+    size_t operator()(_Tp __v) const _NOEXCEPT
+    {
+        typedef typename underlying_type<_Tp>::type type;
+        return hash<type>{}(static_cast<type>(__v));
+    }
+};
+#endif
+
 // struct hash<T*> in <memory>
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/system/include/libcxx/future b/system/include/libcxx/future
index dae1a4b805ec6..73d5456d71780 100644
--- a/system/include/libcxx/future
+++ b/system/include/libcxx/future
@@ -19,10 +19,10 @@ namespace std
 
 enum class future_errc
 {
-    broken_promise,
-    future_already_retrieved,
+    future_already_retrieved = 1,
     promise_already_satisfied,
-    no_state
+    no_state,
+    broken_promise
 };
 
 enum class launch
@@ -309,11 +309,11 @@ public:
 };
 
 template <class F, class... Args>
-  future<typename result_of<F(Args...)>::type>
+  future<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
   async(F&& f, Args&&... args);
 
 template <class F, class... Args>
-  future<typename result_of<F(Args...)>::type>
+  future<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
   async(launch policy, F&& f, Args&&... args);
 
 template <class> class packaged_task; // undefined
@@ -379,19 +379,19 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 //enum class future_errc
 _LIBCPP_DECLARE_STRONG_ENUM(future_errc)
 {
-    broken_promise,
-    future_already_retrieved,
+    future_already_retrieved = 1,
     promise_already_satisfied,
-    no_state
+    no_state,
+    broken_promise
 };
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc)
 
 template <>
-struct _LIBCPP_TYPE_VIS is_error_code_enum<future_errc> : public true_type {};
+struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum<future_errc> : public true_type {};
 
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 template <>
-struct _LIBCPP_TYPE_VIS is_error_code_enum<future_errc::__lx> : public true_type { };
+struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum<future_errc::__lx> : public true_type { };
 #endif
 
 //enum class launch
@@ -508,7 +508,7 @@ public:
     virtual ~future_error() _NOEXCEPT;
 };
 
-class __assoc_sub_state
+class _LIBCPP_TYPE_VIS __assoc_sub_state
     : public __shared_count
 {
 protected:
@@ -542,14 +542,14 @@ public:
         __state_ |= __future_attached;
     }
     _LIBCPP_INLINE_VISIBILITY
-    bool __has_future_attached() const {return __state_ & __future_attached;}
+    bool __has_future_attached() const {return (__state_ & __future_attached) != 0;}
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_deferred() {__state_ |= deferred;}
 
     void __make_ready();
     _LIBCPP_INLINE_VISIBILITY
-    bool __is_ready() const {return __state_ & ready;}
+    bool __is_ready() const {return (__state_ & ready) != 0;}
 
     void set_value();
     void set_value_at_thread_exit();
@@ -727,7 +727,7 @@ __assoc_state<_Rp&>::set_value(_Rp& __arg)
     if (this->__has_value())
         throw future_error(make_error_code(future_errc::promise_already_satisfied));
 #endif
-    __value_ = &__arg;
+    __value_ = _VSTD::addressof(__arg);
     this->__state_ |= base::__constructed | base::ready;
     __lk.unlock();
     __cv_.notify_all();
@@ -742,7 +742,7 @@ __assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg)
     if (this->__has_value())
         throw future_error(make_error_code(future_errc::promise_already_satisfied));
 #endif
-    __value_ = &__arg;
+    __value_ = _VSTD::addressof(__arg);
     this->__state_ |= base::__constructed;
     __thread_local_data()->__make_ready_at_thread_exit(this);
     __lk.unlock();
@@ -778,7 +778,7 @@ void
 __assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT
 {
     if (this->__state_ & base::__constructed)
-        reinterpret_cast<_Rp*>(&this->__value_)->~_Rp();
+        reinterpret_cast<_Rp*>(_VSTD::addressof(this->__value_))->~_Rp();
     typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_);
     this->~__assoc_state_alloc();
     __a.deallocate(this, 1);
@@ -1032,12 +1032,12 @@ __async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT
     base::__on_zero_shared();
 }
 
-template <class _Rp> class _LIBCPP_TYPE_VIS promise;
-template <class _Rp> class _LIBCPP_TYPE_VIS shared_future;
+template <class _Rp> class _LIBCPP_TYPE_VIS_ONLY promise;
+template <class _Rp> class _LIBCPP_TYPE_VIS_ONLY shared_future;
 
 // future
 
-template <class _Rp> class _LIBCPP_TYPE_VIS future;
+template <class _Rp> class _LIBCPP_TYPE_VIS_ONLY future;
 
 template <class _Rp, class _Fp>
 future<_Rp>
@@ -1056,7 +1056,7 @@ __make_async_assoc_state(_Fp __f);
 #endif
 
 template <class _Rp>
-class _LIBCPP_TYPE_VIS future
+class _LIBCPP_TYPE_VIS_ONLY future
 {
     __assoc_state<_Rp>* __state_;
 
@@ -1160,7 +1160,7 @@ future<_Rp>::get()
 }
 
 template <class _Rp>
-class _LIBCPP_TYPE_VIS future<_Rp&>
+class _LIBCPP_TYPE_VIS_ONLY future<_Rp&>
 {
     __assoc_state<_Rp&>* __state_;
 
@@ -1341,7 +1341,7 @@ swap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT
 template <class _Callable> class packaged_task;
 
 template <class _Rp>
-class _LIBCPP_TYPE_VIS promise
+class _LIBCPP_TYPE_VIS_ONLY promise
 {
     __assoc_state<_Rp>* __state_;
 
@@ -1519,7 +1519,7 @@ promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p)
 // promise<R&>
 
 template <class _Rp>
-class _LIBCPP_TYPE_VIS promise<_Rp&>
+class _LIBCPP_TYPE_VIS_ONLY promise<_Rp&>
 {
     __assoc_state<_Rp&>* __state_;
 
@@ -1736,7 +1736,7 @@ swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT
 }
 
 template <class _Rp, class _Alloc>
-    struct _LIBCPP_TYPE_VIS uses_allocator<promise<_Rp>, _Alloc>
+    struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<promise<_Rp>, _Alloc>
         : public true_type {};
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
@@ -2000,7 +2000,7 @@ __packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) cons
 }
 
 template<class _Rp, class ..._ArgTypes>
-class _LIBCPP_TYPE_VIS packaged_task<_Rp(_ArgTypes...)>
+class _LIBCPP_TYPE_VIS_ONLY packaged_task<_Rp(_ArgTypes...)>
 {
 public:
     typedef _Rp result_type;
@@ -2013,10 +2013,26 @@ public:
     // construction and destruction
     _LIBCPP_INLINE_VISIBILITY
     packaged_task() _NOEXCEPT : __p_(nullptr) {}
-    template <class _Fp>
+    template <class _Fp,
+              class = typename enable_if
+              <
+                  !is_same<
+                      typename decay<_Fp>::type, 
+                      packaged_task
+                      >::value
+                  >::type
+             >
         _LIBCPP_INLINE_VISIBILITY
         explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
-    template <class _Fp, class _Allocator>
+    template <class _Fp, class _Allocator,
+              class = typename enable_if
+              <
+                  !is_same<
+                      typename decay<_Fp>::type, 
+                      packaged_task
+                      >::value
+                  >::type
+              >
         _LIBCPP_INLINE_VISIBILITY
         explicit packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
              : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
@@ -2115,7 +2131,7 @@ packaged_task<_Rp(_ArgTypes...)>::reset()
 }
 
 template<class ..._ArgTypes>
-class _LIBCPP_TYPE_VIS packaged_task<void(_ArgTypes...)>
+class _LIBCPP_TYPE_VIS_ONLY packaged_task<void(_ArgTypes...)>
 {
 public:
     typedef void result_type;
@@ -2128,10 +2144,26 @@ public:
     // construction and destruction
     _LIBCPP_INLINE_VISIBILITY
     packaged_task() _NOEXCEPT : __p_(nullptr) {}
-    template <class _Fp>
+    template <class _Fp,
+              class = typename enable_if
+              <
+                  !is_same<
+                      typename decay<_Fp>::type, 
+                      packaged_task
+                      >::value
+                  >::type
+              >
         _LIBCPP_INLINE_VISIBILITY
         explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
-    template <class _Fp, class _Allocator>
+    template <class _Fp, class _Allocator,
+              class = typename enable_if
+              <
+                  !is_same<
+                      typename decay<_Fp>::type, 
+                      packaged_task
+                      >::value
+                  >::type
+              >    
         _LIBCPP_INLINE_VISIBILITY
         explicit packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
              : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
@@ -2240,7 +2272,7 @@ swap(packaged_task<_Callable>& __x, packaged_task<_Callable>& __y) _NOEXCEPT
 }
 
 template <class _Callable, class _Alloc>
-struct _LIBCPP_TYPE_VIS uses_allocator<packaged_task<_Callable>, _Alloc>
+struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<packaged_task<_Callable>, _Alloc>
     : public true_type {};
 
 template <class _Rp, class _Fp>
@@ -2299,20 +2331,32 @@ private:
     }
 };
 
+inline _LIBCPP_INLINE_VISIBILITY bool __does_policy_contain(launch __policy, launch __value )
+{ return (int(__policy) & int(__value)) != 0; }
+
 template <class _Fp, class... _Args>
 future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>
 async(launch __policy, _Fp&& __f, _Args&&... __args)
 {
     typedef __async_func<typename decay<_Fp>::type, typename decay<_Args>::type...> _BF;
     typedef typename _BF::_Rp _Rp;
-    future<_Rp> __r;
-    if (int(__policy) & int(launch::async))
-        __r = _VSTD::__make_async_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
+
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    try
+    {
+#endif
+        if (__does_policy_contain(__policy, launch::async))
+        return _VSTD::__make_async_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
                                                      __decay_copy(_VSTD::forward<_Args>(__args))...));
-    else if (int(__policy) & int(launch::deferred))
-        __r = _VSTD::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    }
+    catch ( ... ) { if (__policy == launch::async) throw ; }
+#endif
+
+    if (__does_policy_contain(__policy, launch::deferred))
+        return _VSTD::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
                                                         __decay_copy(_VSTD::forward<_Args>(__args))...));
-    return __r;
+    return future<_Rp>{};
 }
 
 template <class _Fp, class... _Args>
@@ -2329,7 +2373,7 @@ async(_Fp&& __f, _Args&&... __args)
 // shared_future
 
 template <class _Rp>
-class _LIBCPP_TYPE_VIS shared_future
+class _LIBCPP_TYPE_VIS_ONLY shared_future
 {
     __assoc_state<_Rp>* __state_;
 
@@ -2403,7 +2447,7 @@ shared_future<_Rp>::operator=(const shared_future& __rhs)
 }
 
 template <class _Rp>
-class _LIBCPP_TYPE_VIS shared_future<_Rp&>
+class _LIBCPP_TYPE_VIS_ONLY shared_future<_Rp&>
 {
     __assoc_state<_Rp&>* __state_;
 
diff --git a/system/include/libcxx/initializer_list b/system/include/libcxx/initializer_list
index 181313d1704b2..663e49b6ee43e 100644
--- a/system/include/libcxx/initializer_list
+++ b/system/include/libcxx/initializer_list
@@ -29,15 +29,15 @@ public:
     typedef const E* iterator;
     typedef const E* const_iterator;
 
-    initializer_list() noexcept;
+    initializer_list() noexcept; // constexpr in C++14
 
-    size_t   size()  const noexcept;
-    const E* begin() const noexcept;
-    const E* end()   const noexcept;
+    size_t   size()  const noexcept; // constexpr in C++14
+    const E* begin() const noexcept; // constexpr in C++14
+    const E* end()   const noexcept; // constexpr in C++14
 };
 
-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) noexcept; // constexpr in C++14
+template<class E> const E* end(initializer_list<E> il) noexcept; // constexpr in C++14
 
 }  // std
 
@@ -56,12 +56,13 @@ namespace std  // purposefully not versioned
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template<class _Ep>
-class _LIBCPP_TYPE_VIS initializer_list
+class _LIBCPP_TYPE_VIS_ONLY initializer_list
 {
     const _Ep* __begin_;
     size_t    __size_;
 
     _LIBCPP_ALWAYS_INLINE
+    _LIBCPP_CONSTEXPR_AFTER_CXX11
     initializer_list(const _Ep* __b, size_t __s) _NOEXCEPT
         : __begin_(__b),
           __size_(__s)
@@ -75,15 +76,26 @@ public:
     typedef const _Ep* iterator;
     typedef const _Ep* const_iterator;
 
-    _LIBCPP_ALWAYS_INLINE initializer_list() _NOEXCEPT : __begin_(nullptr), __size_(0) {}
+    _LIBCPP_ALWAYS_INLINE
+    _LIBCPP_CONSTEXPR_AFTER_CXX11
+    initializer_list() _NOEXCEPT : __begin_(nullptr), __size_(0) {}
 
-    _LIBCPP_ALWAYS_INLINE size_t    size()  const _NOEXCEPT {return __size_;}
-    _LIBCPP_ALWAYS_INLINE const _Ep* begin() const _NOEXCEPT {return __begin_;}
-    _LIBCPP_ALWAYS_INLINE const _Ep* end()   const _NOEXCEPT {return __begin_ + __size_;}
+    _LIBCPP_ALWAYS_INLINE
+    _LIBCPP_CONSTEXPR_AFTER_CXX11
+    size_t    size()  const _NOEXCEPT {return __size_;}
+    
+    _LIBCPP_ALWAYS_INLINE
+    _LIBCPP_CONSTEXPR_AFTER_CXX11
+    const _Ep* begin() const _NOEXCEPT {return __begin_;}
+
+    _LIBCPP_ALWAYS_INLINE
+    _LIBCPP_CONSTEXPR_AFTER_CXX11
+    const _Ep* end()   const _NOEXCEPT {return __begin_ + __size_;}
 };
 
 template<class _Ep>
 inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR_AFTER_CXX11
 const _Ep*
 begin(initializer_list<_Ep> __il) _NOEXCEPT
 {
@@ -92,6 +104,7 @@ begin(initializer_list<_Ep> __il) _NOEXCEPT
 
 template<class _Ep>
 inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR_AFTER_CXX11
 const _Ep*
 end(initializer_list<_Ep> __il) _NOEXCEPT
 {
diff --git a/system/include/libcxx/iomanip b/system/include/libcxx/iomanip
index 0c58e1980f3f3..cdb0d5f0dbf17 100644
--- a/system/include/libcxx/iomanip
+++ b/system/include/libcxx/iomanip
@@ -26,6 +26,17 @@ template <class charT, class moneyT> T8 put_money(const moneyT& mon, bool intl =
 template <class charT> T9 get_time(struct tm* tmb, const charT* fmt);
 template <class charT> T10 put_time(const struct tm* tmb, const charT* fmt);
 
+template <class charT>
+  T11 quoted(const charT* s, charT delim=charT('"'), charT escape=charT('\\')); // C++14
+
+template <class charT, class traits, class Allocator>
+  T12 quoted(const basic_string<charT, traits, Allocator>& s,
+             charT delim=charT('"'), charT escape=charT('\\')); // C++14
+
+template <class charT, class traits, class Allocator>
+  T13 quoted(basic_string<charT, traits, Allocator>& s,
+             charT delim=charT('"'), charT escape=charT('\\')); // C++14
+
 }  // std
 
 */
@@ -499,6 +510,142 @@ put_time(const tm* __tm, const _CharT* __fmt)
     return __iom_t10<_CharT>(__tm, __fmt);
 }
 
+#if _LIBCPP_STD_VER > 11
+
+template <class _CharT, class _Traits, class _ForwardIterator>
+std::basic_ostream<_CharT, _Traits> &
+__quoted_output ( basic_ostream<_CharT, _Traits> &__os, 
+        _ForwardIterator __first, _ForwardIterator __last, _CharT __delim, _CharT __escape )
+{
+    __os << __delim;
+    for ( ; __first != __last; ++ __first )
+    {
+        if (_Traits::eq (*__first, __escape) || _Traits::eq (*__first, __delim))
+            __os << __escape;
+        __os << *__first;
+    }
+    __os << __delim;
+    return __os;
+}
+
+template <class _CharT, class _Traits, class _String>
+basic_istream<_CharT, _Traits> &
+__quoted_input ( basic_istream<_CharT, _Traits> &__is, _String & __string, _CharT __delim, _CharT __escape )
+{
+    __string.clear ();
+    _CharT __c;
+    __is >> __c;
+    if ( __is.fail ())
+        return __is;
+
+    if (!_Traits::eq (__c, __delim))    // no delimiter, read the whole string
+    {
+        __is.unget ();
+        __is >> __string;
+        return __is;
+    }
+
+    __save_flags<_CharT, _Traits> sf(__is);
+    noskipws (__is);
+    while (true)
+        {
+        __is >> __c;
+        if ( __is.fail ())
+            break;
+        if (_Traits::eq (__c, __escape))
+        {
+            __is >> __c;
+            if ( __is.fail ())
+                break;
+        }
+        else if (_Traits::eq (__c, __delim))
+            break;
+        __string.push_back ( __c );
+        }
+    return __is;
+}
+
+
+template <class _CharT, class _Iter, class _Traits=char_traits<_CharT>>
+struct __quoted_output_proxy
+{
+    _Iter  __first;
+    _Iter  __last;
+    _CharT  __delim;
+    _CharT  __escape;
+
+    __quoted_output_proxy(_Iter __f, _Iter __l, _CharT __d, _CharT __e)
+    : __first(__f), __last(__l), __delim(__d), __escape(__e) {}
+    //  This would be a nice place for a string_ref 
+};
+
+template <class _CharT, class _Traits, class _Iter>
+basic_ostream<_CharT, _Traits>& operator<<(
+         basic_ostream<_CharT, _Traits>& __os, 
+         const __quoted_output_proxy<_CharT, _Iter, _Traits> & __proxy)
+{
+    return __quoted_output (__os, __proxy.__first, __proxy.__last, __proxy.__delim, __proxy.__escape);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+struct __quoted_proxy
+{
+    basic_string<_CharT, _Traits, _Allocator> &__string;
+    _CharT  __delim;
+    _CharT  __escape;
+
+    __quoted_proxy(basic_string<_CharT, _Traits, _Allocator> &__s, _CharT __d, _CharT __e)
+    : __string(__s), __delim(__d), __escape(__e) {}
+};
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY
+basic_ostream<_CharT, _Traits>& operator<<(
+        basic_ostream<_CharT, _Traits>& __os, 
+        const __quoted_proxy<_CharT, _Traits, _Allocator> & __proxy)
+{
+    return __quoted_output (__os, __proxy.string.cbegin (), __proxy.string.cend (), __proxy.__delim, __proxy.__escape);
+}
+
+//  extractor for non-const basic_string& proxies
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY
+basic_istream<_CharT, _Traits>& operator>>(
+        basic_istream<_CharT, _Traits>& __is, 
+        const __quoted_proxy<_CharT, _Traits, _Allocator> & __proxy)
+{
+    return __quoted_input ( __is, __proxy.__string, __proxy.__delim, __proxy.__escape );
+}
+
+
+template <class _CharT>
+_LIBCPP_INLINE_VISIBILITY
+__quoted_output_proxy<_CharT, const _CharT *>
+quoted ( const _CharT *__s, _CharT __delim = _CharT('"'), _CharT __escape =_CharT('\\'))
+{
+    const _CharT *__end = __s;
+    while ( *__end ) ++__end;
+    return __quoted_output_proxy<_CharT, const _CharT *> ( __s, __end, __delim, __escape );
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY
+__quoted_output_proxy<_CharT, typename basic_string <_CharT, _Traits, _Allocator>::const_iterator>
+quoted ( const basic_string <_CharT, _Traits, _Allocator> &__s, _CharT __delim = _CharT('"'), _CharT __escape=_CharT('\\'))
+{
+    return __quoted_output_proxy<_CharT, 
+            typename basic_string <_CharT, _Traits, _Allocator>::const_iterator> 
+                    ( __s.cbegin(), __s.cend (), __delim, __escape );
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+__quoted_proxy<_CharT, _Traits, _Allocator>
+quoted ( basic_string <_CharT, _Traits, _Allocator> &__s, _CharT __delim = _CharT('"'), _CharT __escape=_CharT('\\'))
+{
+    return __quoted_proxy<_CharT, _Traits, _Allocator>( __s, __delim, __escape );
+}
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_IOMANIP
diff --git a/system/include/libcxx/ios b/system/include/libcxx/ios
index c10003d0f4988..d95f18a5e1e0f 100644
--- a/system/include/libcxx/ios
+++ b/system/include/libcxx/ios
@@ -203,9 +203,9 @@ enum class io_errc
 };
 
 concept_map ErrorCodeEnum<io_errc> { };
-error_code make_error_code(io_errc e);
-error_condition make_error_condition(io_errc e);
-storage-class-specifier const error_category& iostream_category;
+error_code make_error_code(io_errc e) noexcept; 
+error_condition make_error_condition(io_errc e) noexcept; 
+storage-class-specifier const error_category& iostream_category() noexcept;
 
 }  // std
 
@@ -216,6 +216,10 @@ storage-class-specifier const error_category& iostream_category;
 #include <__locale>
 #include <system_error>
 
+#if __has_feature(cxx_atomic)
+#include <atomic>     // for __xindex_
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
@@ -319,7 +323,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY bool bad() const;
 
     _LIBCPP_INLINE_VISIBILITY iostate exceptions() const;
-    _LIBCPP_INLINE_VISIBILITY void exceptions(iostate __except);
+    _LIBCPP_INLINE_VISIBILITY void exceptions(iostate __iostate);
 
     void __set_badbit_and_consider_rethrow();
     void __set_failbit_and_consider_rethrow();
@@ -363,7 +367,11 @@ private:
     int*            __index_;
     size_t          __event_size_;
     size_t          __event_cap_;
+#if __has_feature(cxx_atomic)
+    static atomic<int> __xindex_;
+#else
     static int      __xindex_;
+#endif
     long*           __iarray_;
     size_t          __iarray_size_;
     size_t          __iarray_cap_;
@@ -380,26 +388,26 @@ _LIBCPP_DECLARE_STRONG_ENUM(io_errc)
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc)
 
 template <>
-struct _LIBCPP_TYPE_VIS is_error_code_enum<io_errc> : public true_type { };
+struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum<io_errc> : public true_type { };
 
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 template <>
-struct _LIBCPP_TYPE_VIS is_error_code_enum<io_errc::__lx> : public true_type { };
+struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum<io_errc::__lx> : public true_type { };
 #endif
 
 _LIBCPP_FUNC_VIS
-const error_category& iostream_category();
+const error_category& iostream_category() _NOEXCEPT;
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_code
-make_error_code(io_errc __e)
+make_error_code(io_errc __e) _NOEXCEPT
 {
     return error_code(static_cast<int>(__e), iostream_category());
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_condition
-make_error_condition(io_errc __e)
+make_error_condition(io_errc __e) _NOEXCEPT
 {
     return error_condition(static_cast<int>(__e), iostream_category());
 }
@@ -527,21 +535,21 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 ios_base::eof() const
 {
-    return __rdstate_ & eofbit;
+    return (__rdstate_ & eofbit) != 0;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 ios_base::fail() const
 {
-    return __rdstate_ & (failbit | badbit);
+    return (__rdstate_ & (failbit | badbit)) != 0;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 ios_base::bad() const
 {
-    return __rdstate_ & badbit;
+    return (__rdstate_ & badbit) != 0;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
@@ -553,14 +561,14 @@ ios_base::exceptions() const
 
 inline _LIBCPP_INLINE_VISIBILITY
 void
-ios_base::exceptions(iostate __except)
+ios_base::exceptions(iostate __iostate)
 {
-    __exceptions_ = __except;
+    __exceptions_ = __iostate;
     clear(__rdstate_);
 }
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS basic_ios
+class _LIBCPP_TYPE_VIS_ONLY basic_ios
     : public ios_base
 {
 public:
@@ -585,7 +593,7 @@ public:
     _LIBCPP_ALWAYS_INLINE bool bad() const  {return ios_base::bad();}
 
     _LIBCPP_ALWAYS_INLINE iostate exceptions() const {return ios_base::exceptions();}
-    _LIBCPP_ALWAYS_INLINE void exceptions(iostate __except) {ios_base::exceptions(__except);}
+    _LIBCPP_ALWAYS_INLINE void exceptions(iostate __iostate) {ios_base::exceptions(__iostate);}
 
     // 27.5.4.1 Constructor/destructor:
     _LIBCPP_INLINE_VISIBILITY
diff --git a/system/include/libcxx/iosfwd b/system/include/libcxx/iosfwd
index 849d7e5170266..d24c227bef798 100644
--- a/system/include/libcxx/iosfwd
+++ b/system/include/libcxx/iosfwd
@@ -97,47 +97,47 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TYPE_VIS ios_base;
 
-template<class _CharT>  struct _LIBCPP_TYPE_VIS char_traits;
-template<class _Tp>     class _LIBCPP_TYPE_VIS allocator;
+template<class _CharT>  struct _LIBCPP_TYPE_VIS_ONLY char_traits;
+template<class _Tp>     class _LIBCPP_TYPE_VIS_ONLY allocator;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS basic_ios;
+    class _LIBCPP_TYPE_VIS_ONLY basic_ios;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS basic_streambuf;
+    class _LIBCPP_TYPE_VIS_ONLY basic_streambuf;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS basic_istream;
+    class _LIBCPP_TYPE_VIS_ONLY basic_istream;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS basic_ostream;
+    class _LIBCPP_TYPE_VIS_ONLY basic_ostream;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS basic_iostream;
+    class _LIBCPP_TYPE_VIS_ONLY basic_iostream;
 
 template <class _CharT, class _Traits = char_traits<_CharT>,
           class _Allocator = allocator<_CharT> >
-    class _LIBCPP_TYPE_VIS basic_stringbuf;
+    class _LIBCPP_TYPE_VIS_ONLY basic_stringbuf;
 template <class _CharT, class _Traits = char_traits<_CharT>,
           class _Allocator = allocator<_CharT> >
-    class _LIBCPP_TYPE_VIS basic_istringstream;
+    class _LIBCPP_TYPE_VIS_ONLY basic_istringstream;
 template <class _CharT, class _Traits = char_traits<_CharT>,
           class _Allocator = allocator<_CharT> >
-    class _LIBCPP_TYPE_VIS basic_ostringstream;
+    class _LIBCPP_TYPE_VIS_ONLY basic_ostringstream;
 template <class _CharT, class _Traits = char_traits<_CharT>,
           class _Allocator = allocator<_CharT> >
-    class _LIBCPP_TYPE_VIS basic_stringstream;
+    class _LIBCPP_TYPE_VIS_ONLY basic_stringstream;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS basic_filebuf;
+    class _LIBCPP_TYPE_VIS_ONLY basic_filebuf;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS basic_ifstream;
+    class _LIBCPP_TYPE_VIS_ONLY basic_ifstream;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS basic_ofstream;
+    class _LIBCPP_TYPE_VIS_ONLY basic_ofstream;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS basic_fstream;
+    class _LIBCPP_TYPE_VIS_ONLY basic_fstream;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS istreambuf_iterator;
+    class _LIBCPP_TYPE_VIS_ONLY istreambuf_iterator;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TYPE_VIS ostreambuf_iterator;
+    class _LIBCPP_TYPE_VIS_ONLY ostreambuf_iterator;
 
 typedef basic_ios<char>              ios;
 typedef basic_ios<wchar_t>           wios;
@@ -172,7 +172,7 @@ typedef basic_ifstream<wchar_t>      wifstream;
 typedef basic_ofstream<wchar_t>      wofstream;
 typedef basic_fstream<wchar_t>       wfstream;
 
-template <class _State>             class _LIBCPP_TYPE_VIS fpos;
+template <class _State>             class _LIBCPP_TYPE_VIS_ONLY fpos;
 typedef fpos<mbstate_t>    streampos;
 typedef fpos<mbstate_t>    wstreampos;
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
@@ -185,7 +185,7 @@ 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_TYPE_VIS basic_string;
+    class _LIBCPP_TYPE_VIS_ONLY 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;
 
diff --git a/system/include/libcxx/istream b/system/include/libcxx/istream
index f3e74c382e6ba..14fa466057cfc 100644
--- a/system/include/libcxx/istream
+++ b/system/include/libcxx/istream
@@ -164,7 +164,7 @@ template <class charT, class traits, class T>
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS basic_istream
+class _LIBCPP_TYPE_VIS_ONLY basic_istream
     : virtual public basic_ios<_CharT, _Traits>
 {
     streamsize __gc_;
@@ -194,7 +194,7 @@ protected:
 public:
 
     // 27.7.1.1.3 Prefix/suffix:
-    class _LIBCPP_TYPE_VIS sentry;
+    class _LIBCPP_TYPE_VIS_ONLY sentry;
 
     // 27.7.1.2 Formatted input:
     basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&));
@@ -244,7 +244,7 @@ public:
 };
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS basic_istream<_CharT, _Traits>::sentry
+class _LIBCPP_TYPE_VIS_ONLY basic_istream<_CharT, _Traits>::sentry
 {
     bool __ok_;
 
@@ -1369,8 +1369,10 @@ basic_istream<_CharT, _Traits>::seekg(pos_type __pos)
         this->clear(this->rdstate() & ~ios_base::eofbit);
         sentry __sen(*this, true);
         if (__sen)
+        {
             if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1))
                 this->setstate(ios_base::failbit);
+        }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
@@ -1391,7 +1393,10 @@ basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir)
 #endif  // _LIBCPP_NO_EXCEPTIONS
         sentry __sen(*this, true);
         if (__sen)
-            this->rdbuf()->pubseekoff(__off, __dir, ios_base::in);
+        {
+            if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::in) == pos_type(-1))
+                this->setstate(ios_base::failbit);
+        }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
@@ -1451,7 +1456,7 @@ operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS basic_iostream
+class _LIBCPP_TYPE_VIS_ONLY basic_iostream
     : public basic_istream<_CharT, _Traits>,
       public basic_ostream<_CharT, _Traits>
 {
@@ -1702,9 +1707,9 @@ operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
     return __is;
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class basic_istream<char>)
-_LIBCPP_EXTERN_TEMPLATE(class basic_istream<wchar_t>)
-_LIBCPP_EXTERN_TEMPLATE(class basic_iostream<char>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_istream<char>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_istream<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_iostream<char>)
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/system/include/libcxx/iterator b/system/include/libcxx/iterator
index 858510d15625c..d16aa2aa95fb3 100644
--- a/system/include/libcxx/iterator
+++ b/system/include/libcxx/iterator
@@ -309,6 +309,19 @@ template <class C> auto end(const C& c) -> decltype(c.end());
 template <class T, size_t N> T* begin(T (&array)[N]);
 template <class T, size_t N> T* end(T (&array)[N]);
 
+template <class C> auto cbegin(const C& c) -> decltype(std::begin(c));        // C++14
+template <class C> auto cend(const C& c) -> decltype(std::end(c));            // C++14
+template <class C> auto rbegin(C& c) -> decltype(c.rbegin());                 // C++14
+template <class C> auto rbegin(const C& c) -> decltype(c.rbegin());           // C++14
+template <class C> auto rend(C& c) -> decltype(c.rend());                     // C++14
+template <class C> auto rend(const C& c) -> decltype(c.rend());               // C++14
+template <class E> reverse_iterator<const E*> rbegin(initializer_list<E> il); // C++14
+template <class E> reverse_iterator<const E*> rend(initializer_list<E> il);   // C++14
+template <class T, size_t N> reverse_iterator<T*> rbegin(T (&array)[N]);      // C++14
+template <class T, size_t N> reverse_iterator<T*> rend(T (&array)[N]);        // C++14
+template <class C> auto crbegin(const C& c) -> decltype(std::rbegin(c));      // C++14
+template <class C> auto crend(const C& c) -> decltype(std::rend(c));          // C++14
+
 }  // std
 
 */
@@ -317,11 +330,12 @@ template <class T, size_t N> T* end(T (&array)[N]);
 #include <type_traits>
 #include <cstddef>
 #include <iosfwd>
+#include <initializer_list>
 #ifdef __APPLE__
 #include <Availability.h>
 #endif
 
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
 #   include <__debug>
 #else
 #   define _LIBCPP_ASSERT(x, m) ((void)0)
@@ -333,11 +347,11 @@ template <class T, size_t N> T* end(T (&array)[N]);
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct _LIBCPP_TYPE_VIS input_iterator_tag {};
-struct _LIBCPP_TYPE_VIS output_iterator_tag {};
-struct _LIBCPP_TYPE_VIS forward_iterator_tag       : public input_iterator_tag {};
-struct _LIBCPP_TYPE_VIS bidirectional_iterator_tag : public forward_iterator_tag {};
-struct _LIBCPP_TYPE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {};
+struct _LIBCPP_TYPE_VIS_ONLY input_iterator_tag {};
+struct _LIBCPP_TYPE_VIS_ONLY output_iterator_tag {};
+struct _LIBCPP_TYPE_VIS_ONLY forward_iterator_tag       : public input_iterator_tag {};
+struct _LIBCPP_TYPE_VIS_ONLY bidirectional_iterator_tag : public forward_iterator_tag {};
+struct _LIBCPP_TYPE_VIS_ONLY random_access_iterator_tag : public bidirectional_iterator_tag {};
 
 template <class _Tp>
 struct __has_iterator_category
@@ -380,11 +394,11 @@ struct __iterator_traits<_Iter, true>
 //    the client expects instead of failing at compile time.
 
 template <class _Iter>
-struct _LIBCPP_TYPE_VIS iterator_traits
+struct _LIBCPP_TYPE_VIS_ONLY iterator_traits
     : __iterator_traits<_Iter, __has_iterator_category<_Iter>::value> {};
 
 template<class _Tp>
-struct _LIBCPP_TYPE_VIS iterator_traits<_Tp*>
+struct _LIBCPP_TYPE_VIS_ONLY iterator_traits<_Tp*>
 {
     typedef ptrdiff_t difference_type;
     typedef typename remove_const<_Tp>::type value_type;
@@ -415,7 +429,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_TYPE_VIS iterator
+struct _LIBCPP_TYPE_VIS_ONLY iterator
 {
     typedef _Tp        value_type;
     typedef _Distance  difference_type;
@@ -512,7 +526,7 @@ prev(_BidiretionalIter __x,
 }
 
 template <class _Iter>
-class _LIBCPP_TYPE_VIS reverse_iterator
+class _LIBCPP_TYPE_VIS_ONLY reverse_iterator
     : public iterator<typename iterator_traits<_Iter>::iterator_category,
                       typename iterator_traits<_Iter>::value_type,
                       typename iterator_traits<_Iter>::difference_type,
@@ -619,7 +633,7 @@ operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_i
 }
 
 template <class _Container>
-class _LIBCPP_TYPE_VIS back_insert_iterator
+class _LIBCPP_TYPE_VIS_ONLY back_insert_iterator
     : public iterator<output_iterator_tag,
                       void,
                       void,
@@ -652,7 +666,7 @@ back_inserter(_Container& __x)
 }
 
 template <class _Container>
-class _LIBCPP_TYPE_VIS front_insert_iterator
+class _LIBCPP_TYPE_VIS_ONLY front_insert_iterator
     : public iterator<output_iterator_tag,
                       void,
                       void,
@@ -685,7 +699,7 @@ front_inserter(_Container& __x)
 }
 
 template <class _Container>
-class _LIBCPP_TYPE_VIS insert_iterator
+class _LIBCPP_TYPE_VIS_ONLY insert_iterator
     : public iterator<output_iterator_tag,
                       void,
                       void,
@@ -721,7 +735,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_TYPE_VIS istream_iterator
+class _LIBCPP_TYPE_VIS_ONLY istream_iterator
     : public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&>
 {
 public:
@@ -760,7 +774,7 @@ public:
 };
 
 template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> >
-class _LIBCPP_TYPE_VIS ostream_iterator
+class _LIBCPP_TYPE_VIS_ONLY ostream_iterator
     : public iterator<output_iterator_tag, void, void, void, void>
 {
 public:
@@ -789,7 +803,7 @@ public:
 };
 
 template<class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS istreambuf_iterator
+class _LIBCPP_TYPE_VIS_ONLY istreambuf_iterator
     : public iterator<input_iterator_tag, _CharT,
                       typename _Traits::off_type, _CharT*,
                       _CharT>
@@ -860,7 +874,7 @@ bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a,
                 {return !__a.equal(__b);}
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS ostreambuf_iterator
+class _LIBCPP_TYPE_VIS_ONLY ostreambuf_iterator
     : public iterator<output_iterator_tag, void, void, void, void>
 {
 public:
@@ -901,7 +915,7 @@ public:
 };
 
 template <class _Iter>
-class _LIBCPP_TYPE_VIS move_iterator
+class _LIBCPP_TYPE_VIS_ONLY move_iterator
 {
 private:
     _Iter __i;
@@ -1016,7 +1030,7 @@ operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterato
 template <class _Iter>
 inline _LIBCPP_INLINE_VISIBILITY
 move_iterator<_Iter>
-make_move_iterator(const _Iter& __i)
+make_move_iterator(_Iter __i)
 {
     return move_iterator<_Iter>(__i);
 }
@@ -1197,12 +1211,13 @@ public:
     _LIBCPP_INLINE_VISIBILITY iterator_type base() const _NOEXCEPT {return __i;}
 
 private:
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter(iterator_type __x) _NOEXCEPT : __i(__x) {}
 #if _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_INLINE_VISIBILITY __wrap_iter(const void* __p, iterator_type __x) : __i(__x)
     {
         __get_db()->__insert_ic(this, __p);
     }
+#else
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter(iterator_type __x) _NOEXCEPT : __i(__x) {}
 #endif
 
     template <class _Up> friend class __wrap_iter;
@@ -1370,456 +1385,101 @@ operator+(typename __wrap_iter<_Iter>::difference_type __n,
     return __x;
 }
 
-#ifdef _LIBCPP_DEBUG
-
-// __debug_iter
-
-template <class _Container, class _Iter> class __debug_iter;
-
-template <class _Container, class _Iter1, class _Iter2>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
-
-template <class _Container, class _Iter1, class _Iter2>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator<(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
-
-template <class _Container, class _Iter1, class _Iter2>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
-
-template <class _Container, class _Iter1, class _Iter2>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator>(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
-
-template <class _Container, class _Iter1, class _Iter2>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
-
-template <class _Container, class _Iter1, class _Iter2>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
-
-template <class _Container, class _Iter1, class _Iter2>
-_LIBCPP_INLINE_VISIBILITY
-typename __debug_iter<_Container, _Iter1>::difference_type
-operator-(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
-
-template <class _Container, class _Iter>
-_LIBCPP_INLINE_VISIBILITY
-__debug_iter<_Container, _Iter>
-operator+(typename __debug_iter<_Container, _Iter>::difference_type, const __debug_iter<_Container, _Iter>&);
-
-template <class _Container, class _Iter>
-class __debug_iter
-{
-public:
-    typedef _Iter                                                      iterator_type;
-    typedef _Container                                                 __container_type;
-    typedef typename iterator_traits<iterator_type>::iterator_category iterator_category;
-    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;
-    typedef typename iterator_traits<iterator_type>::reference         reference;
-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)
-        : __i(__x.base()), __next(0), __cont(0) {__set_owner(__x.__cont);}
-    __debug_iter& operator=(const __debug_iter& __x);
-    template <class _Up> _LIBCPP_INLINE_VISIBILITY __debug_iter(const __debug_iter<_Container, _Up>& __u,
-        typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = 0)
-        : __i(__u.base()), __next(0), __cont(0) {__set_owner(__u.__cont);}
-    _LIBCPP_INLINE_VISIBILITY ~__debug_iter() {__remove_owner();}
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const {assert(__is_deref()); return *__i;}
-    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const {return &(operator*());}
-    _LIBCPP_INLINE_VISIBILITY __debug_iter& operator++() {assert(__can_increment()); ++__i; return *this;}
-    _LIBCPP_INLINE_VISIBILITY __debug_iter  operator++(int)
-        {__debug_iter __tmp(*this); operator++(); return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY __debug_iter& operator--() {assert(__can_decrement()); --__i; return *this;}
-    _LIBCPP_INLINE_VISIBILITY __debug_iter  operator--(int)
-        {__debug_iter __tmp(*this); operator--(); return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY __debug_iter  operator+ (difference_type __n) const
-        {__debug_iter __t(*this); __t += __n; return __t;}
-    __debug_iter& operator+=(difference_type __n);
-    _LIBCPP_INLINE_VISIBILITY __debug_iter  operator- (difference_type __n) const
-        {__debug_iter __t(*this); __t -= __n; return __t;}
-    _LIBCPP_INLINE_VISIBILITY __debug_iter& operator-=(difference_type __n)
-        {*this += -__n; return *this;}
-    _LIBCPP_INLINE_VISIBILITY reference        operator[](difference_type __n) const
-        {return *(*this + __n);}
-
-private:
-    _LIBCPP_INLINE_VISIBILITY __debug_iter(const __container_type* __c, iterator_type __x)
-        : __i(__x), __next(0), __cont(0) {__set_owner(__c);}
-    _LIBCPP_INLINE_VISIBILITY iterator_type base() const {return __i;}
-
-    void __set_owner(const __container_type* __c);
-    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;
-    bool __is_deref(true_type) const;
-    _LIBCPP_INLINE_VISIBILITY bool __can_decrement() const
-        {return __can_decrement(integral_constant<int, is_pointer<iterator_type>::value ? 2:
-                                                       __is_random_access_iterator<iterator_type>::value ? 1 : 0>());}
-    bool __can_decrement(integral_constant<int, 0>) const;
-    bool __can_decrement(integral_constant<int, 1>) const;
-    bool __can_decrement(integral_constant<int, 2>) const;
-    _LIBCPP_INLINE_VISIBILITY bool __can_increment() const
-        {return __can_increment(integral_constant<int, is_pointer<iterator_type>::value ? 2:
-                                                       __is_random_access_iterator<iterator_type>::value ? 1 : 0>());}
-    bool __can_increment(integral_constant<int, 0>) const;
-    bool __can_increment(integral_constant<int, 1>) const;
-    bool __can_increment(integral_constant<int, 2>) const;
-
-    _LIBCPP_INLINE_VISIBILITY bool __can_add(difference_type __n) const
-        {return __can_add(__n, is_pointer<iterator_type>());}
-    bool __can_add(difference_type __n, false_type) const;
-    bool __can_add(difference_type __n, true_type) const;
-
-    template <class _Cp, class _Up> friend class __debug_iter;
-    friend class _Container::__self;
-
-    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
-    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>
-    operator+(typename __debug_iter<_Cp, _Iter1>::difference_type, const __debug_iter<_Cp, _Iter1>&);
-};
-
-template <class _Container, class _Iter>
-__debug_iter<_Container, _Iter>&
-__debug_iter<_Container, _Iter>::operator=(const __debug_iter& __x)
-{
-    if (this != &__x)
-    {
-        __remove_owner();
-        __i = __x.__i;
-        __set_owner(__x.__cont);
-    }
-    return *this;
-}
-
-template <class _Container, class _Iter>
-void
-__debug_iter<_Container, _Iter>::__set_owner(const __container_type* __c)
-{
-    __cont = const_cast<__container_type*>(__c);
-    __debug_iter*& __head = __cont->__get_iterator_list(this);
-    __next = __head;
-    __head = this;
-}
-
-template <class _Container, class _Iter>
-void
-__debug_iter<_Container, _Iter>::__remove_owner()
-{
-    if (__cont)
-    {
-        __debug_iter*& __head = __cont->__get_iterator_list(this);
-        if (__head == this)
-            __head = __next;
-        else
-        {
-            __debug_iter* __prev = __head;
-            for (__debug_iter* __p = __head->__next; __p != this; __p = __p->__next)
-                __prev = __p;
-            __prev->__next = __next;
-        }
-        __cont = 0;
-    }
-}
-
-template <class _Container, class _Iter>
-void
-__debug_iter<_Container, _Iter>::__remove_all(__container_type* __c)
-{
-    __debug_iter*& __head = __c->__get_iterator_list((__debug_iter*)0);
-    __debug_iter* __p = __head;
-    __head = 0;
-    while (__p)
-    {
-        __p->__cont = 0;
-        __debug_iter* __n = __p->__next;
-        __p->__next = 0;
-        __p = __n;
-    }
-}
-
-template <class _Container, class _Iter>
-void
-__debug_iter<_Container, _Iter>::swap(__container_type* __x, __container_type* __y)
-{
-    __debug_iter*& __head_x = __x->__get_iterator_list((__debug_iter*)0);
-    __debug_iter*& __head_y = __y->__get_iterator_list((__debug_iter*)0);
-    __debug_iter* __p = __head_x;
-    __head_x = __head_y;
-    __head_y = __p;
-    for (__p = __head_x; __p; __p = __p->__next)
-        __p->__cont = __x;
-    for (__p = __head_y; __p; __p = __p->__next)
-        __p->__cont = __y;
-}
-
-template <class _Container, class _Iter>
-bool
-__debug_iter<_Container, _Iter>::__is_deref(false_type) const
-{
-    if (__cont == 0)
-        return false;
-    return __i != __cont->end().base();
-}
-
-template <class _Container, class _Iter>
-bool
-__debug_iter<_Container, _Iter>::__is_deref(true_type) const
-{
-    if (__cont == 0)
-        return false;
-    return __i < __cont->end().base();
-}
-
-template <class _Container, class _Iter>
-bool
-__debug_iter<_Container, _Iter>::__can_decrement(integral_constant<int, 0>) const
-{
-    if (__cont == 0)
-        return false;
-    return __i != __cont->begin().base();
-}
-
-template <class _Container, class _Iter>
-bool
-__debug_iter<_Container, _Iter>::__can_decrement(integral_constant<int, 1>) const
-{
-    if (__cont == 0)
-        return false;
-    iterator_type __b = __cont->begin().base();
-    return __b < __i && __i <= __b + __cont->size();
-}
-
-template <class _Container, class _Iter>
-bool
-__debug_iter<_Container, _Iter>::__can_decrement(integral_constant<int, 2>) const
-{
-    if (__cont == 0)
-        return false;
-    iterator_type __b = __cont->begin().base();
-    return __b < __i && __i <= __b + __cont->size();
-}
-
-template <class _Container, class _Iter>
-bool
-__debug_iter<_Container, _Iter>::__can_increment(integral_constant<int, 0>) const
-{
-    if (__cont == 0)
-        return false;
-    return __i != __cont->end().base();
-}
-
-template <class _Container, class _Iter>
-bool
-__debug_iter<_Container, _Iter>::__can_increment(integral_constant<int, 1>) const
-{
-    if (__cont == 0)
-        return false;
-    iterator_type __b = __cont->begin().base();
-    return __b <= __i && __i < __b + __cont->size();
-}
-
-template <class _Container, class _Iter>
-bool
-__debug_iter<_Container, _Iter>::__can_increment(integral_constant<int, 2>) const
-{
-    if (__cont == 0)
-        return false;
-    iterator_type __b = __cont->begin().base();
-    return __b <= __i && __i < __b + __cont->size();
-}
-
-template <class _Container, class _Iter>
-bool
-__debug_iter<_Container, _Iter>::__can_add(difference_type __n, false_type) const
-{
-    if (__cont == 0)
-        return false;
-    iterator_type __b = __cont->begin().base();
-    iterator_type __j = __i + __n;
-    return __b <= __j && __j <= __b + __cont->size();
-}
-
-template <class _Container, class _Iter>
-bool
-__debug_iter<_Container, _Iter>::__can_add(difference_type __n, true_type) const
-{
-    if (__cont == 0)
-        return false;
-    iterator_type __b = __cont->begin().base();
-    iterator_type __j = __i + __n;
-    return __b <= __j && __j <= __b + __cont->size();
-}
-
-template <class _Container, class _Iter>
-__debug_iter<_Container, _Iter>&
-__debug_iter<_Container, _Iter>::operator+=(difference_type __n)
-{
-    assert(__can_add(__n));
-    __i += __n;
-    return *this;
-}
+#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
 
-template <class _Container, class _Iter1, class _Iter2>
+template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const __debug_iter<_Container, _Iter1>& __x, const __debug_iter<_Container, _Iter2>& __y)
+auto
+begin(_Cp& __c) -> decltype(__c.begin())
 {
-    assert(__x.__cont && __x.__cont == __y.__cont);
-    return __x.base() == __y.base();
+    return __c.begin();
 }
 
-template <class _Container, class _Iter1, class _Iter2>
+template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const __debug_iter<_Container, _Iter1>& __x, const __debug_iter<_Container, _Iter2>& __y)
+auto
+begin(const _Cp& __c) -> decltype(__c.begin())
 {
-    return !(__x == __y);
+    return __c.begin();
 }
 
-template <class _Container, class _Iter1, class _Iter2>
+template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(const __debug_iter<_Container, _Iter1>& __x, const __debug_iter<_Container, _Iter2>& __y)
+auto
+end(_Cp& __c) -> decltype(__c.end())
 {
-    assert(__x.__cont && __x.__cont == __y.__cont);
-    return __x.base() < __y.base();
+    return __c.end();
 }
 
-template <class _Container, class _Iter1, class _Iter2>
+template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>(const __debug_iter<_Container, _Iter1>& __x, const __debug_iter<_Container, _Iter2>& __y)
+auto
+end(const _Cp& __c) -> decltype(__c.end())
 {
-    return __y < __x;
+    return __c.end();
 }
 
-template <class _Container, class _Iter1, class _Iter2>
+#if _LIBCPP_STD_VER > 11
+
+template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const __debug_iter<_Container, _Iter1>& __x, const __debug_iter<_Container, _Iter2>& __y)
+auto cbegin(const _Cp& __c) -> decltype(begin(__c))
 {
-    return !(__x < __y);
+    return __c.begin();
 }
 
-template <class _Container, class _Iter1, class _Iter2>
+template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const __debug_iter<_Container, _Iter1>& __x, const __debug_iter<_Container, _Iter2>& __y)
+auto cend(const _Cp& __c) -> decltype(end(__c))
 {
-    return !(__y < __x);
+    return __c.end();
 }
 
-template <class _Container, class _Iter1, class _Iter2>
+template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
-typename __debug_iter<_Container, _Iter1>::difference_type
-operator-(const __debug_iter<_Container, _Iter1>& __x, const __debug_iter<_Container, _Iter2>& __y)
+auto rbegin(_Cp& __c) -> decltype(__c.rbegin())
 {
-    assert(__x.__cont && __x.__cont == __y.__cont);
-    return __x.base() - __y.base();
+    return __c.rbegin();
 }
 
-template <class _Container, class _Iter>
+template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
-__debug_iter<_Container, _Iter>
-operator+(typename __debug_iter<_Container, _Iter>::difference_type __n,
-          const __debug_iter<_Container, _Iter>& __x)
+auto rbegin(const _Cp& __c) -> decltype(__c.rbegin())
 {
-    return __x + __n;
+    return __c.rbegin();
 }
 
-#endif  // _LIBCPP_DEBUG
-
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
-
 template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
-begin(_Cp& __c) -> decltype(__c.begin())
+auto rend(_Cp& __c) -> decltype(__c.rend())
 {
-    return __c.begin();
+    return __c.rend();
 }
 
 template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
-begin(const _Cp& __c) -> decltype(__c.begin())
+auto rend(const _Cp& __c) -> decltype(__c.rend())
 {
-    return __c.begin();
+    return __c.rend();
 }
 
 template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
-end(_Cp& __c) -> decltype(__c.end())
+auto crbegin(const _Cp& __c) -> decltype(rbegin(__c))
 {
-    return __c.end();
+    return rbegin(__c);
 }
 
 template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
-end(const _Cp& __c) -> decltype(__c.end())
+auto crend(const _Cp& __c) -> decltype(rend(__c))
 {
-    return __c.end();
+    return rend(__c);
 }
 
+#endif
+
+
 #else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
 
 template <class _Cp>
@@ -1872,6 +1532,37 @@ end(_Tp (&__array)[_Np])
     return __array + _Np;
 }
 
+#if _LIBCPP_STD_VER > 11
+template <class _Tp, size_t _Np>
+inline _LIBCPP_INLINE_VISIBILITY
+reverse_iterator<_Tp*> rbegin(_Tp (&__array)[_Np])
+{
+    return reverse_iterator<_Tp*>(__array + _Np);
+}
+
+template <class _Tp, size_t _Np>
+inline _LIBCPP_INLINE_VISIBILITY
+reverse_iterator<_Tp*> rend(_Tp (&__array)[_Np])
+{
+    return reverse_iterator<_Tp*>(__array);
+}
+
+template <class _Ep>
+inline _LIBCPP_INLINE_VISIBILITY
+reverse_iterator<const _Ep*> rbegin(initializer_list<_Ep> __il)
+{
+    return reverse_iterator<const _Ep*>(__il.end());
+}
+
+template <class _Ep>
+inline _LIBCPP_INLINE_VISIBILITY
+reverse_iterator<const _Ep*> rend(initializer_list<_Ep> __il)
+{
+    return reverse_iterator<const _Ep*>(__il.begin());
+}
+
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_ITERATOR
diff --git a/system/include/libcxx/limits b/system/include/libcxx/limits
index c995ef5985bd4..d917c577f1480 100644
--- a/system/include/libcxx/limits
+++ b/system/include/libcxx/limits
@@ -115,6 +115,10 @@ template<> class numeric_limits<cv long double>;
 #include "support/win32/limits_win32.h"
 #endif // _LIBCPP_MSVCRT
 
+#if defined(__IBMCPP__)
+#include "support/ibm/limits.h"
+#endif // __IBMCPP__
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 enum float_round_style
@@ -433,7 +437,7 @@ protected:
 };
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS numeric_limits
+class _LIBCPP_TYPE_VIS_ONLY numeric_limits
     : private __libcpp_numeric_limits<typename remove_cv<_Tp>::type>
 {
     typedef __libcpp_numeric_limits<typename remove_cv<_Tp>::type> __base;
@@ -526,7 +530,7 @@ template <class _Tp>
     _LIBCPP_CONSTEXPR const float_round_style numeric_limits<_Tp>::round_style;
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS numeric_limits<const _Tp>
+class _LIBCPP_TYPE_VIS_ONLY numeric_limits<const _Tp>
     : private numeric_limits<_Tp>
 {
     typedef numeric_limits<_Tp> __base;
@@ -619,7 +623,7 @@ template <class _Tp>
     _LIBCPP_CONSTEXPR const float_round_style numeric_limits<const _Tp>::round_style;
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS numeric_limits<volatile _Tp>
+class _LIBCPP_TYPE_VIS_ONLY numeric_limits<volatile _Tp>
     : private numeric_limits<_Tp>
 {
     typedef numeric_limits<_Tp> __base;
@@ -712,7 +716,7 @@ template <class _Tp>
     _LIBCPP_CONSTEXPR const float_round_style numeric_limits<volatile _Tp>::round_style;
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS numeric_limits<const volatile _Tp>
+class _LIBCPP_TYPE_VIS_ONLY numeric_limits<const volatile _Tp>
     : private numeric_limits<_Tp>
 {
     typedef numeric_limits<_Tp> __base;
diff --git a/system/include/libcxx/list b/system/include/libcxx/list
index 4b1272a8ea411..800a1a3f5aa82 100644
--- a/system/include/libcxx/list
+++ b/system/include/libcxx/list
@@ -40,6 +40,7 @@ public:
         noexcept(is_nothrow_default_constructible<allocator_type>::value);
     explicit list(const allocator_type& a);
     explicit list(size_type n);
+    explicit list(size_type n, const allocator_type& a); // C++14
     list(size_type n, const value_type& value);
     list(size_type n, const value_type& value, const allocator_type& a);
     template <class Iter>
@@ -178,7 +179,7 @@ template <class T, class Alloc>
 
 #include <__undef_min_max>
 
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
 #   include <__debug>
 #else
 #   define _LIBCPP_ASSERT(x, m) ((void)0)
@@ -226,12 +227,12 @@ struct __list_node
     _Tp __value_;
 };
 
-template <class _Tp, class _Alloc> class _LIBCPP_TYPE_VIS list;
+template <class _Tp, class _Alloc> class _LIBCPP_TYPE_VIS_ONLY list;
 template <class _Tp, class _Alloc> class __list_imp;
-template <class _Tp, class _VoidPtr> class _LIBCPP_TYPE_VIS __list_const_iterator;
+template <class _Tp, class _VoidPtr> class _LIBCPP_TYPE_VIS_ONLY __list_const_iterator;
 
 template <class _Tp, class _VoidPtr>
-class _LIBCPP_TYPE_VIS __list_iterator
+class _LIBCPP_TYPE_VIS_ONLY __list_iterator
 {
     typedef typename pointer_traits<_VoidPtr>::template
 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@@ -364,7 +365,7 @@ public:
 };
 
 template <class _Tp, class _VoidPtr>
-class _LIBCPP_TYPE_VIS __list_const_iterator
+class _LIBCPP_TYPE_VIS_ONLY __list_const_iterator
 {
     typedef typename pointer_traits<_VoidPtr>::template
 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@@ -806,7 +807,7 @@ __list_imp<_Tp, _Alloc>::swap(__list_imp& __c)
 }
 
 template <class _Tp, class _Alloc = allocator<_Tp> >
-class _LIBCPP_TYPE_VIS list
+class _LIBCPP_TYPE_VIS_ONLY list
     : private __list_imp<_Tp, _Alloc>
 {
     typedef __list_imp<_Tp, _Alloc> base;
@@ -842,13 +843,16 @@ public:
 #endif
     }
     _LIBCPP_INLINE_VISIBILITY
-    list(const allocator_type& __a) : base(__a)
+    explicit list(const allocator_type& __a) : base(__a)
     {
 #if _LIBCPP_DEBUG_LEVEL >= 2
         __get_db()->__insert_c(this);
 #endif
     }
-    list(size_type __n);
+    explicit list(size_type __n);
+#if _LIBCPP_STD_VER > 11
+    explicit list(size_type __n, const allocator_type& __a);
+#endif
     list(size_type __n, const value_type& __x);
     list(size_type __n, const value_type& __x, const allocator_type& __a);
     template <class _InpIter>
@@ -1100,6 +1104,22 @@ list<_Tp, _Alloc>::list(size_type __n)
 #endif
 }
 
+#if _LIBCPP_STD_VER > 11
+template <class _Tp, class _Alloc>
+list<_Tp, _Alloc>::list(size_type __n, const allocator_type& __a) : base(__a)
+{
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
+    for (; __n > 0; --__n)
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+        emplace_back();
+#else
+        push_back(value_type());
+#endif
+}
+#endif
+
 template <class _Tp, class _Alloc>
 list<_Tp, _Alloc>::list(size_type __n, const value_type& __x)
 {
diff --git a/system/include/libcxx/locale b/system/include/libcxx/locale
index f5f5fff9cc98c..ac3ae7ead92f5 100644
--- a/system/include/libcxx/locale
+++ b/system/include/libcxx/locale
@@ -93,10 +93,12 @@ public:
     typedef typename Codecvt::state_type                      state_type;
     typedef typename wide_string::traits_type::int_type       int_type;
 
-    wstring_convert(Codecvt* pcvt = new Codecvt);
+    explicit wstring_convert(Codecvt* pcvt = new Codecvt);          // explicit in C++14
     wstring_convert(Codecvt* pcvt, state_type state);
-    wstring_convert(const byte_string& byte_err,
+    explicit wstring_convert(const byte_string& byte_err,           // explicit in C++14
                     const wide_string& wide_err = wide_string());
+    wstring_convert(const wstring_convert&) = delete;               // C++14
+    wstring_convert & operator=(const wstring_convert &) = delete;  // C++14
     ~wstring_convert();
 
     wide_string from_bytes(char byte);
@@ -109,7 +111,7 @@ public:
     byte_string to_bytes(const wide_string& wstr);
     byte_string to_bytes(const Elem* first, const Elem* last);
 
-    size_t converted() const;
+    size_t converted() const; // noexcept in C++14
     state_type state() const;
 };
 
@@ -120,9 +122,12 @@ class wbuffer_convert
 public:
     typedef typename Tr::state_type state_type;
 
-    wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt,
-                    state_type state = state_type());
-
+    explicit wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt,
+                    state_type state = state_type());       // explicit in C++14
+    wbuffer_convert(const wbuffer_convert&) = delete;               // C++14
+    wbuffer_convert & operator=(const wbuffer_convert &) = delete;  // C++14
+    ~wbuffer_convert();                                             // C++14
+    
     streambuf* rdbuf() const;
     streambuf* rdbuf(streambuf* bytebuf);
 
@@ -186,7 +191,7 @@ template <class charT> class messages_byname;
 #endif
 #include <cstdlib>
 #include <ctime>
-#ifdef _LIBCPP_MSVCRT
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
 #include <support/win32/locale_win32.h>
 #else // _LIBCPP_MSVCRT
 #include <nl_types.h>
@@ -211,7 +216,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #else
 #  define _LIBCPP_GET_C_LOCALE __cloc()
    // Get the C locale object
-   locale_t __cloc();
+   _LIBCPP_FUNC_VIS locale_t __cloc();
 #define __cloc_defined
 #endif
 
@@ -224,7 +229,7 @@ typedef _VSTD::unique_ptr<__locale_struct, decltype(&uselocale)> __locale_raii;
 // OSX has nice foo_l() functions that let you turn off use of the global
 // locale.  Linux, not so much.  The following functions avoid the locale when
 // that's possible and otherwise do the wrong thing.  FIXME.
-#if defined(__linux__) || defined(__EMSCRIPTEN__)
+#if defined(__linux__) || defined(__EMSCRIPTEN__) || defined(_AIX)
 
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
 decltype(MB_CUR_MAX_L(_VSTD::declval<locale_t>()))
@@ -234,7 +239,7 @@ __mb_cur_max_l(locale_t __l)
   return MB_CUR_MAX_L(__l);
 }
 #else  // _LIBCPP_LOCALE__L_EXTENSIONS
-_LIBCPP_ALWAYS_INLINE inline
+inline _LIBCPP_ALWAYS_INLINE
 decltype(MB_CUR_MAX) __mb_cur_max_l(locale_t __l)
 {
   __locale_raii __current(uselocale(__l), uselocale);
@@ -242,7 +247,7 @@ decltype(MB_CUR_MAX) __mb_cur_max_l(locale_t __l)
 }
 #endif // _LIBCPP_LOCALE__L_EXTENSIONS
 
-_LIBCPP_ALWAYS_INLINE inline
+inline _LIBCPP_ALWAYS_INLINE
 wint_t __btowc_l(int __c, locale_t __l)
 {
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
@@ -253,7 +258,7 @@ wint_t __btowc_l(int __c, locale_t __l)
 #endif
 }
 
-_LIBCPP_ALWAYS_INLINE inline
+inline _LIBCPP_ALWAYS_INLINE
 int __wctob_l(wint_t __c, locale_t __l)
 {
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
@@ -264,7 +269,7 @@ int __wctob_l(wint_t __c, locale_t __l)
 #endif
 }
 
-_LIBCPP_ALWAYS_INLINE inline
+inline _LIBCPP_ALWAYS_INLINE
 size_t __wcsnrtombs_l(char *__dest, const wchar_t **__src, size_t __nwc,
                       size_t __len, mbstate_t *__ps, locale_t __l)
 {
@@ -276,7 +281,7 @@ size_t __wcsnrtombs_l(char *__dest, const wchar_t **__src, size_t __nwc,
 #endif
 }
 
-_LIBCPP_ALWAYS_INLINE inline
+inline _LIBCPP_ALWAYS_INLINE
 size_t __wcrtomb_l(char *__s, wchar_t __wc, mbstate_t *__ps, locale_t __l)
 {
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
@@ -287,7 +292,7 @@ size_t __wcrtomb_l(char *__s, wchar_t __wc, mbstate_t *__ps, locale_t __l)
 #endif
 }
 
-_LIBCPP_ALWAYS_INLINE inline
+inline _LIBCPP_ALWAYS_INLINE
 size_t __mbsnrtowcs_l(wchar_t * __dest, const char **__src, size_t __nms,
                       size_t __len, mbstate_t *__ps, locale_t __l)
 {
@@ -299,7 +304,7 @@ size_t __mbsnrtowcs_l(wchar_t * __dest, const char **__src, size_t __nms,
 #endif
 }
 
-_LIBCPP_ALWAYS_INLINE inline
+inline _LIBCPP_ALWAYS_INLINE
 size_t __mbrtowc_l(wchar_t *__pwc, const char *__s, size_t __n,
                    mbstate_t *__ps, locale_t __l)
 {
@@ -311,7 +316,7 @@ size_t __mbrtowc_l(wchar_t *__pwc, const char *__s, size_t __n,
 #endif
 }
 
-_LIBCPP_ALWAYS_INLINE inline
+inline _LIBCPP_ALWAYS_INLINE
 int __mbtowc_l(wchar_t *__pwc, const char *__pmb, size_t __max, locale_t __l)
 {
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
@@ -322,7 +327,7 @@ int __mbtowc_l(wchar_t *__pwc, const char *__pmb, size_t __max, locale_t __l)
 #endif
 }
 
-_LIBCPP_ALWAYS_INLINE inline
+inline _LIBCPP_ALWAYS_INLINE
 size_t __mbrlen_l(const char *__s, size_t __n, mbstate_t *__ps, locale_t __l)
 {
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
@@ -333,7 +338,7 @@ size_t __mbrlen_l(const char *__s, size_t __n, mbstate_t *__ps, locale_t __l)
 #endif
 }
 
-_LIBCPP_ALWAYS_INLINE inline
+inline _LIBCPP_ALWAYS_INLINE
 lconv *__localeconv_l(locale_t __l)
 {
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
@@ -344,7 +349,7 @@ lconv *__localeconv_l(locale_t __l)
 #endif
 }
 
-_LIBCPP_ALWAYS_INLINE inline
+inline _LIBCPP_ALWAYS_INLINE
 size_t __mbsrtowcs_l(wchar_t *__dest, const char **__src, size_t __len,
                      mbstate_t *__ps, locale_t __l)
 {
@@ -528,7 +533,7 @@ __scan_keyword(_InputIterator& __b, _InputIterator __e,
     return __kb;
 }
 
-struct __num_get_base
+struct _LIBCPP_TYPE_VIS __num_get_base
 {
     static const int __num_get_buf_sz = 40;
 
@@ -536,6 +541,7 @@ struct __num_get_base
     static const char __src[33];
 };
 
+_LIBCPP_FUNC_VIS
 void __check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end,
                       ios_base::iostate& __err);
 
@@ -686,11 +692,11 @@ __num_get<_CharT>::__stage2_float_loop(_CharT __ct, bool& __in_units, char& __ex
     return 0;
 }
 
-_LIBCPP_EXTERN_TEMPLATE(struct __num_get<char>)
-_LIBCPP_EXTERN_TEMPLATE(struct __num_get<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_TYPE_VIS __num_get<char>)
+_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_TYPE_VIS __num_get<wchar_t>)
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS num_get
+class _LIBCPP_TYPE_VIS_ONLY num_get
     : public locale::facet,
       private __num_get<_CharT>
 {
@@ -785,26 +791,61 @@ protected:
     _LIBCPP_ALWAYS_INLINE
     ~num_get() {}
 
+    template <class _Fp>
+    iter_type __do_get_floating_point
+                            (iter_type __b, iter_type __e, ios_base& __iob,
+                             ios_base::iostate& __err, _Fp& __v) const;
+
+    template <class _Signed>
+    iter_type __do_get_signed
+                            (iter_type __b, iter_type __e, ios_base& __iob,
+                             ios_base::iostate& __err, _Signed& __v) const;
+
+    template <class _Unsigned>
+    iter_type __do_get_unsigned
+                            (iter_type __b, iter_type __e, ios_base& __iob,
+                             ios_base::iostate& __err, _Unsigned& __v) const;
+
+
     virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
                              ios_base::iostate& __err, bool& __v) const;
+
     virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, long& __v) const;
+                             ios_base::iostate& __err, long& __v) const
+    { return this->__do_get_signed ( __b, __e, __iob, __err, __v ); }
+
     virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, long long& __v) const;
+                             ios_base::iostate& __err, long long& __v) const
+    { return this->__do_get_signed ( __b, __e, __iob, __err, __v ); }
+
     virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, unsigned short& __v) const;
+                             ios_base::iostate& __err, unsigned short& __v) const
+    { return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }
+
     virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, unsigned int& __v) const;
+                             ios_base::iostate& __err, unsigned int& __v) const
+    { return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }
+
     virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, unsigned long& __v) const;
+                             ios_base::iostate& __err, unsigned long& __v) const
+    { return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }
+
     virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, unsigned long long& __v) const;
+                             ios_base::iostate& __err, unsigned long long& __v) const
+    { return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }
+
     virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, float& __v) const;
+                             ios_base::iostate& __err, float& __v) const
+    { return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); }
+
     virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, double& __v) const;
+                             ios_base::iostate& __err, double& __v) const
+    { return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); }
+
     virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, long double& __v) const;
+                             ios_base::iostate& __err, long double& __v) const
+    { return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); }
+
     virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
                              ios_base::iostate& __err, void*& __v) const;
 };
@@ -946,153 +987,15 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     return __b;
 }
 
-template <class _CharT, class _InputIterator>
-_InputIterator
-num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
-                                        ios_base& __iob,
-                                        ios_base::iostate& __err,
-                                        long& __v) const
-{
-    // Stage 1
-    int __base = this->__get_base(__iob);
-    // Stage 2
-    char_type __atoms[26];
-    char_type __thousands_sep;
-    string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
-    string __buf;
-    __buf.resize(__buf.capacity());
-    char* __a = &__buf[0];
-    char* __a_end = __a;
-    unsigned __g[__num_get_base::__num_get_buf_sz];
-    unsigned* __g_end = __g;
-    unsigned __dc = 0;
-    for (; __b != __e; ++__b)
-    {
-        if (__a_end - __a == __buf.size())
-        {
-            size_t __tmp = __buf.size();
-            __buf.resize(2*__buf.size());
-            __buf.resize(__buf.capacity());
-            __a = &__buf[0];
-            __a_end = __a + __tmp;
-        }
-        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)
-        *__g_end++ = __dc;
-    // Stage 3
-    __v = __num_get_signed_integral<long>(__a, __a_end, __err, __base);
-    // Digit grouping checked
-    __check_grouping(__grouping, __g, __g_end, __err);
-    // EOF checked
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __b;
-}
-
-template <class _CharT, class _InputIterator>
-_InputIterator
-num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
-                                        ios_base& __iob,
-                                        ios_base::iostate& __err,
-                                        long long& __v) const
-{
-    // Stage 1
-    int __base = this->__get_base(__iob);
-    // Stage 2
-    char_type __atoms[26];
-    char_type __thousands_sep;
-    string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
-    string __buf;
-    __buf.resize(__buf.capacity());
-    char* __a = &__buf[0];
-    char* __a_end = __a;
-    unsigned __g[__num_get_base::__num_get_buf_sz];
-    unsigned* __g_end = __g;
-    unsigned __dc = 0;
-    for (; __b != __e; ++__b)
-    {
-        if (__a_end - __a == __buf.size())
-        {
-            size_t __tmp = __buf.size();
-            __buf.resize(2*__buf.size());
-            __buf.resize(__buf.capacity());
-            __a = &__buf[0];
-            __a_end = __a + __tmp;
-        }
-        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)
-        *__g_end++ = __dc;
-    // Stage 3
-    __v = __num_get_signed_integral<long long>(__a, __a_end, __err, __base);
-    // Digit grouping checked
-    __check_grouping(__grouping, __g, __g_end, __err);
-    // EOF checked
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __b;
-}
-
-template <class _CharT, class _InputIterator>
-_InputIterator
-num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
-                                        ios_base& __iob,
-                                        ios_base::iostate& __err,
-                                        unsigned short& __v) const
-{
-    // Stage 1
-    int __base = this->__get_base(__iob);
-    // Stage 2
-    char_type __atoms[26];
-    char_type __thousands_sep;
-    string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
-    string __buf;
-    __buf.resize(__buf.capacity());
-    char* __a = &__buf[0];
-    char* __a_end = __a;
-    unsigned __g[__num_get_base::__num_get_buf_sz];
-    unsigned* __g_end = __g;
-    unsigned __dc = 0;
-    for (; __b != __e; ++__b)
-    {
-        if (__a_end - __a == __buf.size())
-        {
-            size_t __tmp = __buf.size();
-            __buf.resize(2*__buf.size());
-            __buf.resize(__buf.capacity());
-            __a = &__buf[0];
-            __a_end = __a + __tmp;
-        }
-        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)
-        *__g_end++ = __dc;
-    // Stage 3
-    __v = __num_get_unsigned_integral<unsigned short>(__a, __a_end, __err, __base);
-    // Digit grouping checked
-    __check_grouping(__grouping, __g, __g_end, __err);
-    // EOF checked
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __b;
-}
+// signed
 
 template <class _CharT, class _InputIterator>
+template <class _Signed>
 _InputIterator
-num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
+num_get<_CharT, _InputIterator>::__do_get_signed(iter_type __b, iter_type __e,
                                         ios_base& __iob,
                                         ios_base::iostate& __err,
-                                        unsigned int& __v) const
+                                        _Signed& __v) const
 {
     // Stage 1
     int __base = this->__get_base(__iob);
@@ -1125,7 +1028,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz)
         *__g_end++ = __dc;
     // Stage 3
-    __v = __num_get_unsigned_integral<unsigned int>(__a, __a_end, __err, __base);
+    __v = __num_get_signed_integral<_Signed>(__a, __a_end, __err, __base);
     // Digit grouping checked
     __check_grouping(__grouping, __g, __g_end, __err);
     // EOF checked
@@ -1134,59 +1037,15 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     return __b;
 }
 
-template <class _CharT, class _InputIterator>
-_InputIterator
-num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
-                                        ios_base& __iob,
-                                        ios_base::iostate& __err,
-                                        unsigned long& __v) const
-{
-    // Stage 1
-    int __base = this->__get_base(__iob);
-    // Stage 2
-    char_type __atoms[26];
-    char_type __thousands_sep;
-    string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
-    string __buf;
-    __buf.resize(__buf.capacity());
-    char* __a = &__buf[0];
-    char* __a_end = __a;
-    unsigned __g[__num_get_base::__num_get_buf_sz];
-    unsigned* __g_end = __g;
-    unsigned __dc = 0;
-    for (; __b != __e; ++__b)
-    {
-        if (__a_end - __a == __buf.size())
-        {
-            size_t __tmp = __buf.size();
-            __buf.resize(2*__buf.size());
-            __buf.resize(__buf.capacity());
-            __a = &__buf[0];
-            __a_end = __a + __tmp;
-        }
-        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)
-        *__g_end++ = __dc;
-    // Stage 3
-    __v = __num_get_unsigned_integral<unsigned long>(__a, __a_end, __err, __base);
-    // Digit grouping checked
-    __check_grouping(__grouping, __g, __g_end, __err);
-    // EOF checked
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __b;
-}
+// unsigned
 
 template <class _CharT, class _InputIterator>
+template <class _Unsigned>
 _InputIterator
-num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
+num_get<_CharT, _InputIterator>::__do_get_unsigned(iter_type __b, iter_type __e,
                                         ios_base& __iob,
                                         ios_base::iostate& __err,
-                                        unsigned long long& __v) const
+                                        _Unsigned& __v) const
 {
     // Stage 1
     int __base = this->__get_base(__iob);
@@ -1219,59 +1078,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz)
         *__g_end++ = __dc;
     // Stage 3
-    __v = __num_get_unsigned_integral<unsigned long long>(__a, __a_end, __err, __base);
-    // Digit grouping checked
-    __check_grouping(__grouping, __g, __g_end, __err);
-    // EOF checked
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __b;
-}
-
-template <class _CharT, class _InputIterator>
-_InputIterator
-num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
-                                        ios_base& __iob,
-                                        ios_base::iostate& __err,
-                                        float& __v) const
-{
-    // Stage 1, nothing to do
-    // Stage 2
-    char_type __atoms[32];
-    char_type __decimal_point;
-    char_type __thousands_sep;
-    string __grouping = this->__stage2_float_prep(__iob, __atoms,
-                                                  __decimal_point,
-                                                  __thousands_sep);
-    string __buf;
-    __buf.resize(__buf.capacity());
-    char* __a = &__buf[0];
-    char* __a_end = __a;
-    unsigned __g[__num_get_base::__num_get_buf_sz];
-    unsigned* __g_end = __g;
-    unsigned __dc = 0;
-    bool __in_units = true;
-    char __exp = 'E';
-    for (; __b != __e; ++__b)
-    {
-        if (__a_end - __a == __buf.size())
-        {
-            size_t __tmp = __buf.size();
-            __buf.resize(2*__buf.size());
-            __buf.resize(__buf.capacity());
-            __a = &__buf[0];
-            __a_end = __a + __tmp;
-        }
-        if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
-                                      __decimal_point, __thousands_sep,
-                                      __grouping, __g, __g_end,
-                                      __dc, __atoms))
-            break;
-    }
-    if (__grouping.size() != 0 && __in_units && __g_end-__g < __num_get_base::__num_get_buf_sz)
-        *__g_end++ = __dc;
-    // Stage 3
-    __v = __num_get_float<float>(__a, __a_end, __err);
+    __v = __num_get_unsigned_integral<_Unsigned>(__a, __a_end, __err, __base);
     // Digit grouping checked
     __check_grouping(__grouping, __g, __g_end, __err);
     // EOF checked
@@ -1280,64 +1087,15 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     return __b;
 }
 
-template <class _CharT, class _InputIterator>
-_InputIterator
-num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
-                                        ios_base& __iob,
-                                        ios_base::iostate& __err,
-                                        double& __v) const
-{
-    // Stage 1, nothing to do
-    // Stage 2
-    char_type __atoms[32];
-    char_type __decimal_point;
-    char_type __thousands_sep;
-    string __grouping = this->__stage2_float_prep(__iob, __atoms,
-                                                  __decimal_point,
-                                                  __thousands_sep);
-    string __buf;
-    __buf.resize(__buf.capacity());
-    char* __a = &__buf[0];
-    char* __a_end = __a;
-    unsigned __g[__num_get_base::__num_get_buf_sz];
-    unsigned* __g_end = __g;
-    unsigned __dc = 0;
-    bool __in_units = true;
-    char __exp = 'E';
-    for (; __b != __e; ++__b)
-    {
-        if (__a_end - __a == __buf.size())
-        {
-            size_t __tmp = __buf.size();
-            __buf.resize(2*__buf.size());
-            __buf.resize(__buf.capacity());
-            __a = &__buf[0];
-            __a_end = __a + __tmp;
-        }
-        if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
-                                      __decimal_point, __thousands_sep,
-                                      __grouping, __g, __g_end,
-                                      __dc, __atoms))
-            break;
-    }
-    if (__grouping.size() != 0 && __in_units && __g_end-__g < __num_get_base::__num_get_buf_sz)
-        *__g_end++ = __dc;
-    // Stage 3
-    __v = __num_get_float<double>(__a, __a_end, __err);
-    // Digit grouping checked
-    __check_grouping(__grouping, __g, __g_end, __err);
-    // EOF checked
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __b;
-}
+// floating point
 
 template <class _CharT, class _InputIterator>
+template <class _Fp>
 _InputIterator
-num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
+num_get<_CharT, _InputIterator>::__do_get_floating_point(iter_type __b, iter_type __e,
                                         ios_base& __iob,
                                         ios_base::iostate& __err,
-                                        long double& __v) const
+                                        _Fp& __v) const
 {
     // Stage 1, nothing to do
     // Stage 2
@@ -1375,7 +1133,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     if (__grouping.size() != 0 && __in_units && __g_end-__g < __num_get_base::__num_get_buf_sz)
         *__g_end++ = __dc;
     // Stage 3
-    __v = __num_get_float<long double>(__a, __a_end, __err);
+    __v = __num_get_float<_Fp>(__a, __a_end, __err);
     // Digit grouping checked
     __check_grouping(__grouping, __g, __g_end, __err);
     // EOF checked
@@ -1435,10 +1193,10 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     return __b;
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class num_get<char>)
-_LIBCPP_EXTERN_TEMPLATE(class num_get<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS num_get<char>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS num_get<wchar_t>)
 
-struct __num_put_base
+struct _LIBCPP_TYPE_VIS __num_put_base
 {
 protected:
     static void __format_int(char* __fmt, const char* __len, bool __signd,
@@ -1585,11 +1343,11 @@ __num_put<_CharT>::__widen_and_group_float(char* __nb, char* __np, char* __ne,
         __op = __ob + (__np - __nb);
 }
 
-_LIBCPP_EXTERN_TEMPLATE(struct __num_put<char>)
-_LIBCPP_EXTERN_TEMPLATE(struct __num_put<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_TYPE_VIS __num_put<char>)
+_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_TYPE_VIS __num_put<wchar_t>)
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS num_put
+class _LIBCPP_TYPE_VIS_ONLY num_put
     : public locale::facet,
       private __num_put<_CharT>
 {
@@ -1769,7 +1527,12 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
         return do_put(__s, __iob, __fl, (unsigned long)__v);
     const numpunct<char_type>& __np = use_facet<numpunct<char_type> >(__iob.getloc());
     typedef typename numpunct<char_type>::string_type string_type;
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    string_type __tmp(__v ? __np.truename() : __np.falsename());
+    string_type __nm = _VSTD::move(__tmp);
+#else
     string_type __nm = __v ? __np.truename() : __np.falsename();
+#endif
     for (typename string_type::iterator __i = __nm.begin(); __i != __nm.end(); ++__i, ++__s)
         *__s = *__i;
     return __s;
@@ -2065,8 +1828,8 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
     return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class num_put<char>)
-_LIBCPP_EXTERN_TEMPLATE(class num_put<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS num_put<char>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS num_put<wchar_t>)
 
 template <class _CharT, class _InputIterator>
 _LIBCPP_HIDDEN
@@ -2108,7 +1871,7 @@ public:
 };
 
 template <class _CharT>
-class __time_get_c_storage  // purposefully not decorated
+class _LIBCPP_TYPE_VIS __time_get_c_storage
 {
 protected:
     typedef basic_string<_CharT> string_type;
@@ -2123,7 +1886,7 @@ protected:
 };
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS time_get
+class _LIBCPP_TYPE_VIS_ONLY time_get
     : public locale::facet,
       public time_base,
       private __time_get_c_storage<_CharT>
@@ -2732,10 +2495,10 @@ time_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     return __b;
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class time_get<char>)
-_LIBCPP_EXTERN_TEMPLATE(class time_get<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_get<char>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_get<wchar_t>)
 
-class __time_get
+class _LIBCPP_TYPE_VIS __time_get
 {
 protected:
     locale_t __loc_;
@@ -2746,7 +2509,7 @@ protected:
 };
 
 template <class _CharT>
-class __time_get_storage
+class _LIBCPP_TYPE_VIS __time_get_storage
     : public __time_get
 {
 protected:
@@ -2773,7 +2536,7 @@ private:
 };
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS time_get_byname
+class _LIBCPP_TYPE_VIS_ONLY time_get_byname
     : public time_get<_CharT, _InputIterator>,
       private __time_get_storage<_CharT>
 {
@@ -2815,10 +2578,10 @@ private:
     virtual const string_type& __X() const      {return this->__X_;}
 };
 
-_LIBCPP_EXTERN_TEMPLATE(class time_get_byname<char>)
-_LIBCPP_EXTERN_TEMPLATE(class time_get_byname<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_get_byname<char>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_get_byname<wchar_t>)
 
-class __time_put
+class _LIBCPP_TYPE_VIS __time_put
 {
     locale_t __loc_;
 protected:
@@ -2833,7 +2596,7 @@ protected:
 };
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS time_put
+class _LIBCPP_TYPE_VIS_ONLY time_put
     : public locale::facet,
       private __time_put
 {
@@ -2928,11 +2691,11 @@ time_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base&,
     return _VSTD::copy(__nb, __ne, __s);
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class time_put<char>)
-_LIBCPP_EXTERN_TEMPLATE(class time_put<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_put<char>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_put<wchar_t>)
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS time_put_byname
+class _LIBCPP_TYPE_VIS_ONLY time_put_byname
     : public time_put<_CharT, _OutputIterator>
 {
 public:
@@ -2949,8 +2712,8 @@ protected:
     ~time_put_byname() {}
 };
 
-_LIBCPP_EXTERN_TEMPLATE(class time_put_byname<char>)
-_LIBCPP_EXTERN_TEMPLATE(class time_put_byname<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_put_byname<char>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS time_put_byname<wchar_t>)
 
 // money_base
 
@@ -2966,7 +2729,7 @@ public:
 // moneypunct
 
 template <class _CharT, bool _International = false>
-class _LIBCPP_TYPE_VIS moneypunct
+class _LIBCPP_TYPE_VIS_ONLY moneypunct
     : public locale::facet,
       public money_base
 {
@@ -3016,15 +2779,15 @@ template <class _CharT, bool _International>
 const bool
 moneypunct<_CharT, _International>::intl;
 
-_LIBCPP_EXTERN_TEMPLATE(class moneypunct<char, false>)
-_LIBCPP_EXTERN_TEMPLATE(class moneypunct<char, true>)
-_LIBCPP_EXTERN_TEMPLATE(class moneypunct<wchar_t, false>)
-_LIBCPP_EXTERN_TEMPLATE(class moneypunct<wchar_t, true>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct<char, false>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct<char, true>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct<wchar_t, false>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct<wchar_t, true>)
 
 // moneypunct_byname
 
 template <class _CharT, bool _International = false>
-class _LIBCPP_TYPE_VIS moneypunct_byname
+class _LIBCPP_TYPE_VIS_ONLY moneypunct_byname
     : public moneypunct<_CharT, _International>
 {
 public:
@@ -3073,10 +2836,10 @@ template<> void moneypunct_byname<char, true>::init(const char*);
 template<> void moneypunct_byname<wchar_t, false>::init(const char*);
 template<> void moneypunct_byname<wchar_t, true>::init(const char*);
 
-_LIBCPP_EXTERN_TEMPLATE(class moneypunct_byname<char, false>)
-_LIBCPP_EXTERN_TEMPLATE(class moneypunct_byname<char, true>)
-_LIBCPP_EXTERN_TEMPLATE(class moneypunct_byname<wchar_t, false>)
-_LIBCPP_EXTERN_TEMPLATE(class moneypunct_byname<wchar_t, true>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct_byname<char, false>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct_byname<char, true>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct_byname<wchar_t, false>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS moneypunct_byname<wchar_t, true>)
 
 // money_get
 
@@ -3132,11 +2895,11 @@ __money_get<_CharT>::__gather_info(bool __intl, const locale& __loc,
     }
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class __money_get<char>)
-_LIBCPP_EXTERN_TEMPLATE(class __money_get<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS __money_get<char>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS __money_get<wchar_t>)
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS money_get
+class _LIBCPP_TYPE_VIS_ONLY money_get
     : public locale::facet,
       private __money_get<_CharT>
 {
@@ -3190,7 +2953,7 @@ template <class _CharT, class _InputIterator>
 locale::id
 money_get<_CharT, _InputIterator>::id;
 
-void __do_nothing(void*);
+_LIBCPP_FUNC_VIS void __do_nothing(void*);
 
 template <class _Tp>
 _LIBCPP_HIDDEN
@@ -3320,7 +3083,7 @@ money_get<_CharT, _InputIterator>::__do_get(iter_type& __b, iter_type __e,
             bool __more_needed = __trailing_sign ||
                                  (__p < 2)       ||
                                  (__p == 2 && __pat.field[3] != static_cast<char>(money_base::none));
-            bool __sb = __flags & ios_base::showbase;
+            bool __sb = (__flags & ios_base::showbase) != 0;
             if (__sb || __more_needed)
             {
                 typename string_type::const_iterator __sym_space_end = __sym.begin();
@@ -3513,8 +3276,8 @@ money_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
     return __b;
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class money_get<char>)
-_LIBCPP_EXTERN_TEMPLATE(class money_get<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS money_get<char>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS money_get<wchar_t>)
 
 // money_put
 
@@ -3688,11 +3451,11 @@ __money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __m
         __mi = __mb;
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class __money_put<char>)
-_LIBCPP_EXTERN_TEMPLATE(class __money_put<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS __money_put<char>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS __money_put<wchar_t>)
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_TYPE_VIS money_put
+class _LIBCPP_TYPE_VIS_ONLY money_put
     : public locale::facet,
       private __money_put<_CharT>
 {
@@ -3845,8 +3608,8 @@ money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
     return __pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class money_put<char>)
-_LIBCPP_EXTERN_TEMPLATE(class money_put<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS money_put<char>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS money_put<wchar_t>)
 
 // messages
 
@@ -3859,7 +3622,7 @@ public:
 };
 
 template <class _CharT>
-class _LIBCPP_TYPE_VIS messages
+class _LIBCPP_TYPE_VIS_ONLY messages
     : public locale::facet,
       public messages_base
 {
@@ -3955,11 +3718,11 @@ messages<_CharT>::do_close(catalog __c) const
 #endif // !_WIN32
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class messages<char>)
-_LIBCPP_EXTERN_TEMPLATE(class messages<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS messages<char>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS messages<wchar_t>)
 
 template <class _CharT>
-class _LIBCPP_TYPE_VIS messages_byname
+class _LIBCPP_TYPE_VIS_ONLY messages_byname
     : public messages<_CharT>
 {
 public:
@@ -3979,13 +3742,13 @@ protected:
     ~messages_byname() {}
 };
 
-_LIBCPP_EXTERN_TEMPLATE(class messages_byname<char>)
-_LIBCPP_EXTERN_TEMPLATE(class messages_byname<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS messages_byname<char>)
+_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS messages_byname<wchar_t>)
 
 template<class _Codecvt, class _Elem = wchar_t,
          class _Wide_alloc = allocator<_Elem>,
          class _Byte_alloc = allocator<char> >
-class _LIBCPP_TYPE_VIS wstring_convert
+class _LIBCPP_TYPE_VIS_ONLY wstring_convert
 {
 public:
     typedef basic_string<char, char_traits<char>, _Byte_alloc>   byte_string;
@@ -4003,9 +3766,9 @@ private:
     wstring_convert(const wstring_convert& __wc);
     wstring_convert& operator=(const wstring_convert& __wc);
 public:
-    wstring_convert(_Codecvt* __pcvt = new _Codecvt);
+    _LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(_Codecvt* __pcvt = new _Codecvt);
     wstring_convert(_Codecvt* __pcvt, state_type __state);
-    wstring_convert(const byte_string& __byte_err,
+    _LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(const byte_string& __byte_err,
                     const wide_string& __wide_err = wide_string());
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     wstring_convert(wstring_convert&& __wc);
@@ -4035,7 +3798,7 @@ public:
     byte_string to_bytes(const _Elem* __first, const _Elem* __last);
 
     _LIBCPP_ALWAYS_INLINE
-    size_t converted() const {return __cvtcount_;}
+    size_t converted() const _NOEXCEPT {return __cvtcount_;}
     _LIBCPP_ALWAYS_INLINE
     state_type state() const {return __cvtstate_;}
 };
@@ -4238,7 +4001,7 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
 }
 
 template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> >
-class _LIBCPP_TYPE_VIS wbuffer_convert
+class _LIBCPP_TYPE_VIS_ONLY wbuffer_convert
     : public basic_streambuf<_Elem, _Tr>
 {
 public:
@@ -4269,8 +4032,8 @@ private:
     wbuffer_convert(const wbuffer_convert&);
     wbuffer_convert& operator=(const wbuffer_convert&);
 public:
-    wbuffer_convert(streambuf* __bytebuf = 0, _Codecvt* __pcvt = new _Codecvt,
-                    state_type __state = state_type());
+    _LIBCPP_EXPLICIT_AFTER_CXX11 wbuffer_convert(streambuf* __bytebuf = 0, 
+            _Codecvt* __pcvt = new _Codecvt, state_type __state = state_type());
     ~wbuffer_convert();
 
     _LIBCPP_INLINE_VISIBILITY
diff --git a/system/include/libcxx/map b/system/include/libcxx/map
index 953743a6c7409..009e8e2162c5f 100644
--- a/system/include/libcxx/map
+++ b/system/include/libcxx/map
@@ -77,7 +77,12 @@ public:
     map(map&& m, const allocator_type& a);
     map(initializer_list<value_type> il, const key_compare& comp = key_compare());
     map(initializer_list<value_type> il, const key_compare& comp, const allocator_type& a);
-    ~map();
+    template <class InputIterator>
+        map(InputIterator first, InputIterator last, const allocator_type& a)
+            : map(first, last, Compare(), a) {}  // C++14
+    map(initializer_list<value_type> il, const allocator_type& a)
+        : map(il, Compare(), a) {}  // C++14
+   ~map();
 
     map& operator=(const map& m);
     map& operator=(map&& m)
@@ -149,13 +154,34 @@ public:
     // map operations:
           iterator find(const key_type& k);
     const_iterator find(const key_type& k) const;
+    template<typename K>
+        iterator find(const K& x);              // C++14
+    template<typename K>
+        const_iterator find(const K& x) const;  // C++14
+    template<typename K>
+      size_type count(const K& x) const;
+
     size_type      count(const key_type& k) const;
           iterator lower_bound(const key_type& k);
     const_iterator lower_bound(const key_type& k) const;
+    template<typename K>
+        iterator lower_bound(const K& x);              // C++14
+    template<typename K>
+        const_iterator lower_bound(const K& x) const;  // C++14
+
           iterator upper_bound(const key_type& k);
     const_iterator upper_bound(const key_type& k) const;
+    template<typename K>
+        iterator upper_bound(const K& x);              // C++14
+    template<typename K>
+        const_iterator upper_bound(const K& x) const;  // C++14
+
     pair<iterator,iterator>             equal_range(const key_type& k);
     pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
+    template<typename K>
+        pair<iterator,iterator>             equal_range(const K& x);        // C++14
+    template<typename K>
+        pair<const_iterator,const_iterator> equal_range(const K& x) const;  // C++14
 };
 
 template <class Key, class T, class Compare, class Allocator>
@@ -252,6 +278,11 @@ public:
     multimap(initializer_list<value_type> il, const key_compare& comp = key_compare());
     multimap(initializer_list<value_type> il, const key_compare& comp,
              const allocator_type& a);
+    template <class InputIterator>
+        multimap(InputIterator first, InputIterator last, const allocator_type& a)
+            : multimap(first, last, Compare(), a) {} // C++14
+    multimap(initializer_list<value_type> il, const allocator_type& a)
+        : multimap(il, Compare(), a) {} // C++14
     ~multimap();
 
     multimap& operator=(const multimap& m);
@@ -317,13 +348,34 @@ public:
     // map operations:
           iterator find(const key_type& k);
     const_iterator find(const key_type& k) const;
+    template<typename K>
+        iterator find(const K& x);              // C++14
+    template<typename K>
+        const_iterator find(const K& x) const;  // C++14
+    template<typename K>
+      size_type count(const K& x) const;
+
     size_type      count(const key_type& k) const;
           iterator lower_bound(const key_type& k);
     const_iterator lower_bound(const key_type& k) const;
+    template<typename K>
+        iterator lower_bound(const K& x);              // C++14
+    template<typename K>
+        const_iterator lower_bound(const K& x) const;  // C++14
+
           iterator upper_bound(const key_type& k);
     const_iterator upper_bound(const key_type& k) const;
+    template<typename K>
+        iterator upper_bound(const K& x);              // C++14
+    template<typename K>
+        const_iterator upper_bound(const K& x) const;  // C++14
+
     pair<iterator,iterator>             equal_range(const key_type& k);
     pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
+    template<typename K>
+        pair<iterator,iterator>             equal_range(const K& x);        // C++14
+    template<typename K>
+        pair<const_iterator,const_iterator> equal_range(const K& x) const;  // C++14
 };
 
 template <class Key, class T, class Compare, class Allocator>
@@ -409,6 +461,20 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Key& __x, const _CP& __y) const
         {return static_cast<const _Compare&>(*this)(__x, __y.__cc.first);}
+
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
+    operator () ( const _K2& __x, const _CP& __y ) const
+        {return static_cast<const _Compare&>(*this) (__x, __y.__cc.first);}
+
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
+    operator () (const _CP& __x, const _K2& __y) const
+        {return static_cast<const _Compare&>(*this) (__x.__cc.first, __y);}
+#endif
 };
 
 template <class _Key, class _CP, class _Compare>
@@ -437,6 +503,20 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Key& __x, const _CP& __y) const
         {return comp(__x, __y.__cc.first);}
+
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
+    operator () ( const _K2& __x, const _CP& __y ) const
+        {return comp (__x, __y.__cc.first);}
+
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
+    operator () (const _CP& __x, const _K2& __y) const
+        {return comp (__x.__cc.first, __y);}
+#endif
 };
 
 template <class _Allocator>
@@ -495,8 +575,77 @@ template <class _Key, class _Tp, class _Compare, class _Allocator>
     class multimap;
 template <class _TreeIterator> class __map_const_iterator;
 
+#if __cplusplus >= 201103L
+
+template <class _Key, class _Tp>
+union __value_type
+{
+    typedef _Key                                     key_type;
+    typedef _Tp                                      mapped_type;
+    typedef pair<const key_type, mapped_type>        value_type;
+    typedef pair<key_type, mapped_type>              __nc_value_type;
+
+    value_type __cc;
+    __nc_value_type __nc;
+
+    template <class ..._Args>
+    _LIBCPP_INLINE_VISIBILITY
+    __value_type(_Args&& ...__args)
+        : __cc(std::forward<_Args>(__args)...) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __value_type(const __value_type& __v)
+        : __cc(__v.__cc) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __value_type(__value_type& __v)
+        : __cc(__v.__cc) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __value_type(__value_type&& __v)
+        : __nc(std::move(__v.__nc)) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __value_type& operator=(const __value_type& __v)
+        {__nc = __v.__cc; return *this;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __value_type& operator=(__value_type&& __v)
+        {__nc = std::move(__v.__nc); return *this;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    ~__value_type() {__cc.~value_type();}
+};
+
+#else
+
+template <class _Key, class _Tp>
+struct __value_type
+{
+    typedef _Key                                     key_type;
+    typedef _Tp                                      mapped_type;
+    typedef pair<const key_type, mapped_type>        value_type;
+
+    value_type __cc;
+
+    _LIBCPP_INLINE_VISIBILITY
+    __value_type() {}
+
+    template <class _A0>
+    _LIBCPP_INLINE_VISIBILITY
+    __value_type(const _A0& __a0)
+        : __cc(__a0) {}
+
+    template <class _A0, class _A1>
+    _LIBCPP_INLINE_VISIBILITY
+    __value_type(const _A0& __a0, const _A1& __a1)
+        : __cc(__a0, __a1) {}
+};
+
+#endif
+
 template <class _TreeIterator>
-class _LIBCPP_TYPE_VIS __map_iterator
+class _LIBCPP_TYPE_VIS_ONLY __map_iterator
 {
     _TreeIterator __i_;
 
@@ -555,13 +704,13 @@ public:
     bool operator!=(const __map_iterator& __x, const __map_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS multimap;
-    template <class> friend class _LIBCPP_TYPE_VIS __map_const_iterator;
+    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY map;
+    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multimap;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __map_const_iterator;
 };
 
 template <class _TreeIterator>
-class _LIBCPP_TYPE_VIS __map_const_iterator
+class _LIBCPP_TYPE_VIS_ONLY __map_const_iterator
 {
     _TreeIterator __i_;
 
@@ -624,14 +773,14 @@ public:
     bool operator!=(const __map_const_iterator& __x, const __map_const_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS multimap;
-    template <class, class, class> friend class _LIBCPP_TYPE_VIS __tree_const_iterator;
+    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY map;
+    template <class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY multimap;
+    template <class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY __tree_const_iterator;
 };
 
 template <class _Key, class _Tp, class _Compare = less<_Key>,
           class _Allocator = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TYPE_VIS map
+class _LIBCPP_TYPE_VIS_ONLY map
 {
 public:
     // types:
@@ -644,7 +793,7 @@ public:
     typedef value_type&                              reference;
     typedef const value_type&                        const_reference;
 
-    class _LIBCPP_TYPE_VIS value_compare
+    class _LIBCPP_TYPE_VIS_ONLY value_compare
         : public binary_function<value_type, value_type, bool>
     {
         friend class map;
@@ -660,49 +809,7 @@ public:
 
 private:
 
-#if __cplusplus >= 201103L
-    union __value_type
-    {
-        typedef typename map::value_type value_type;
-        typedef typename map::__nc_value_type __nc_value_type;
-        value_type __cc;
-        __nc_value_type __nc;
-
-        template <class ..._Args>
-        __value_type(_Args&& ...__args)
-            : __cc(std::forward<_Args>(__args)...) {}
-
-        __value_type(const __value_type& __v)
-            : __cc(std::move(__v.__cc)) {}
-
-        __value_type(__value_type&& __v)
-            : __nc(std::move(__v.__nc)) {}
-
-        __value_type& operator=(const __value_type& __v)
-            {__nc = __v.__cc; return *this;}
-
-        __value_type& operator=(__value_type&& __v)
-            {__nc = std::move(__v.__nc); return *this;}
-
-        ~__value_type() {__cc.~value_type();}
-    };
-#else
-    struct __value_type
-    {
-        typedef typename map::value_type value_type;
-        value_type __cc;
-
-        __value_type() {}
-
-        template <class _A0>
-        __value_type(const _A0& __a0)
-            : __cc(__a0) {}
-
-        template <class _A0, class _A1>
-        __value_type(const _A0& __a0, const _A1& __a1)
-            : __cc(__a0, __a1) {}
-    };
-#endif
+    typedef _VSTD::__value_type<key_type, mapped_type>             __value_type;
     typedef __map_value_compare<key_type, __value_type, key_compare> __vc;
     typedef typename allocator_traits<allocator_type>::template
 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@@ -757,6 +864,13 @@ public:
             insert(__f, __l);
         }
 
+#if _LIBCPP_STD_VER > 11
+    template <class _InputIterator>
+    _LIBCPP_INLINE_VISIBILITY 
+    map(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
+        : map(__f, __l, key_compare(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     map(const map& __m)
         : __tree_(__m.__tree_)
@@ -815,6 +929,12 @@ public:
             insert(__il.begin(), __il.end());
         }
 
+#if _LIBCPP_STD_VER > 11
+    _LIBCPP_INLINE_VISIBILITY 
+    map(initializer_list<value_type> __il, const allocator_type& __a)
+        : map(__il, key_compare(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     map& operator=(initializer_list<value_type> __il)
         {
@@ -961,6 +1081,17 @@ public:
     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);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    find(const _K2& __k)                           {return __tree_.find(__k);}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    find(const _K2& __k) const                     {return __tree_.find(__k);}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     size_type      count(const key_type& __k) const
         {return __tree_.__count_unique(__k);}
@@ -970,18 +1101,51 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     const_iterator lower_bound(const key_type& __k) const
         {return __tree_.lower_bound(__k);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    lower_bound(const _K2& __k)       {return __tree_.lower_bound(__k);}
+
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
+#endif
+
     _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);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    upper_bound(const _K2& __k)       {return __tree_.upper_bound(__k);}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
+#endif
+
     _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);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
+    equal_range(const _K2& __k)       {return __tree_.__equal_range_unique(__k);}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
+    equal_range(const _K2& __k) const {return __tree_.__equal_range_unique(__k);}
+#endif
 
 private:
     typedef typename __base::__node                    __node;
@@ -1152,7 +1316,7 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node_with_key(key_type&& __k)
     __h.get_deleter().__first_constructed = true;
     __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second));
     __h.get_deleter().__second_constructed = true;
-    return _VSTD::move(__h);
+    return __h;
 }
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
@@ -1186,7 +1350,7 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node_with_key(const key_type&
     __h.get_deleter().__first_constructed = true;
     __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second));
     __h.get_deleter().__second_constructed = true;
-    return _VSTD::move(__h);
+    return _VSTD::move(__h);  // explicitly moved for C++03
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
@@ -1346,7 +1510,7 @@ swap(map<_Key, _Tp, _Compare, _Allocator>& __x,
 
 template <class _Key, class _Tp, class _Compare = less<_Key>,
           class _Allocator = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TYPE_VIS multimap
+class _LIBCPP_TYPE_VIS_ONLY multimap
 {
 public:
     // types:
@@ -1359,7 +1523,7 @@ public:
     typedef value_type&                              reference;
     typedef const value_type&                        const_reference;
 
-    class _LIBCPP_TYPE_VIS value_compare
+    class _LIBCPP_TYPE_VIS_ONLY value_compare
         : public binary_function<value_type, value_type, bool>
     {
         friend class multimap;
@@ -1375,49 +1539,8 @@ public:
     };
 
 private:
-#if __cplusplus >= 201103L
-    union __value_type
-    {
-        typedef typename multimap::value_type value_type;
-        typedef typename multimap::__nc_value_type __nc_value_type;
-        value_type __cc;
-        __nc_value_type __nc;
-
-        template <class ..._Args>
-        __value_type(_Args&& ...__args)
-            : __cc(std::forward<_Args>(__args)...) {}
 
-        __value_type(const __value_type& __v)
-            : __cc(std::move(__v.__cc)) {}
-
-        __value_type(__value_type&& __v)
-            : __nc(std::move(__v.__nc)) {}
-
-        __value_type& operator=(const __value_type& __v)
-            {__nc = __v.__cc; return *this;}
-
-        __value_type& operator=(__value_type&& __v)
-            {__nc = std::move(__v.__nc); return *this;}
-
-        ~__value_type() {__cc.~value_type();}
-    };
-#else
-    struct __value_type
-    {
-        typedef typename multimap::value_type value_type;
-        value_type __cc;
-
-        __value_type() {}
-
-        template <class _A0>
-        __value_type(const _A0& __a0)
-            : __cc(__a0) {}
-
-        template <class _A0, class _A1>
-        __value_type(const _A0& __a0, const _A1& __a1)
-            : __cc(__a0, __a1) {}
-    };
-#endif
+    typedef _VSTD::__value_type<key_type, mapped_type>             __value_type;
     typedef __map_value_compare<key_type, __value_type, key_compare> __vc;
     typedef typename allocator_traits<allocator_type>::template
 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@@ -1472,6 +1595,13 @@ public:
             insert(__f, __l);
         }
 
+#if _LIBCPP_STD_VER > 11
+    template <class _InputIterator>
+    _LIBCPP_INLINE_VISIBILITY 
+    multimap(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
+        : multimap(__f, __l, key_compare(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     multimap(const multimap& __m)
         : __tree_(__m.__tree_.value_comp(),
@@ -1531,6 +1661,12 @@ public:
             insert(__il.begin(), __il.end());
         }
 
+#if _LIBCPP_STD_VER > 11
+    _LIBCPP_INLINE_VISIBILITY 
+    multimap(initializer_list<value_type> __il, const allocator_type& __a)
+        : multimap(__il, key_compare(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     multimap& operator=(initializer_list<value_type> __il)
         {
@@ -1666,6 +1802,17 @@ public:
     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);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    find(const _K2& __k)                           {return __tree_.find(__k);}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    find(const _K2& __k) const                     {return __tree_.find(__k);}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     size_type      count(const key_type& __k) const
         {return __tree_.__count_multi(__k);}
@@ -1675,18 +1822,51 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     const_iterator lower_bound(const key_type& __k) const
             {return __tree_.lower_bound(__k);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    lower_bound(const _K2& __k)       {return __tree_.lower_bound(__k);}
+
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
+#endif
+
     _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);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    upper_bound(const _K2& __k)       {return __tree_.upper_bound(__k);}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
+#endif
+
     _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);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
+    equal_range(const _K2& __k)       {return __tree_.__equal_range_multi(__k);}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
+    equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
+#endif
 
 private:
     typedef typename __base::__node                    __node;
diff --git a/system/include/libcxx/memory b/system/include/libcxx/memory
index ffd0cd0ce77d5..bf44837fc2a6c 100644
--- a/system/include/libcxx/memory
+++ b/system/include/libcxx/memory
@@ -90,7 +90,7 @@ struct allocator_traits
     template <class T>
         static void destroy(allocator_type& a, T* p);
 
-    static size_type max_size(const allocator_type& a);
+    static size_type max_size(const allocator_type& a); // noexcept in C++14
 
     static allocator_type
         select_on_container_copy_construction(const allocator_type& a);
@@ -496,8 +496,8 @@ public:
     long use_count() const noexcept;
     bool expired() const noexcept;
     shared_ptr<T> lock() const noexcept;
-    template<class U> bool owner_before(shared_ptr<U> const& b);
-    template<class U> bool owner_before(weak_ptr<U> const& b);
+    template<class U> bool owner_before(shared_ptr<U> const& b) const;
+    template<class U> bool owner_before(weak_ptr<U> const& b) const;
 };
 
 // weak_ptr specialized algorithms:
@@ -618,60 +618,12 @@ void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-// addressof
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp*
-addressof(_Tp& __x) _NOEXCEPT
-{
-    return (_Tp*)&reinterpret_cast<const volatile char&>(__x);
-}
-
-#if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF)
-// Objective-C++ Automatic Reference Counting uses qualified pointers
-// that require special addressof() signatures. When
-// _LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF is defined, the compiler
-// itself is providing these definitions. Otherwise, we provide them.
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-__strong _Tp*
-addressof(__strong _Tp& __x) _NOEXCEPT
-{
-  return &__x;
-}
-
-#ifdef _LIBCPP_HAS_OBJC_ARC_WEAK
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-__weak _Tp*
-addressof(__weak _Tp& __x) _NOEXCEPT
-{
-  return &__x;
-}
-#endif
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-__autoreleasing _Tp*
-addressof(__autoreleasing _Tp& __x) _NOEXCEPT
-{
-  return &__x;
-}
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-__unsafe_unretained _Tp*
-addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT
-{
-  return &__x;
-}
-#endif
+// addressof moved to <__functional_base>
 
 template <class _Tp> class allocator;
 
 template <>
-class _LIBCPP_TYPE_VIS allocator<void>
+class _LIBCPP_TYPE_VIS_ONLY allocator<void>
 {
 public:
     typedef void*             pointer;
@@ -682,7 +634,7 @@ public:
 };
 
 template <>
-class _LIBCPP_TYPE_VIS allocator<const void>
+class _LIBCPP_TYPE_VIS_ONLY allocator<const void>
 {
 public:
     typedef const void*       pointer;
@@ -917,7 +869,7 @@ struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, false>
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Ptr>
-struct _LIBCPP_TYPE_VIS pointer_traits
+struct _LIBCPP_TYPE_VIS_ONLY pointer_traits
 {
     typedef _Ptr                                                     pointer;
     typedef typename __pointer_traits_element_type<pointer>::type    element_type;
@@ -940,7 +892,7 @@ public:
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS pointer_traits<_Tp*>
+struct _LIBCPP_TYPE_VIS_ONLY pointer_traits<_Tp*>
 {
     typedef _Tp*      pointer;
     typedef _Tp       element_type;
@@ -965,13 +917,13 @@ public:
 
 namespace __has_pointer_type_imp
 {
-    template <class _Up> static __two test(...);
-    template <class _Up> static char test(typename _Up::pointer* = 0);
+    template <class _Up> static __two __test(...);
+    template <class _Up> static char __test(typename _Up::pointer* = 0);
 }
 
 template <class _Tp>
 struct __has_pointer_type
-    : public integral_constant<bool, sizeof(__has_pointer_type_imp::test<_Tp>(0)) == 1>
+    : public integral_constant<bool, sizeof(__has_pointer_type_imp::__test<_Tp>(0)) == 1>
 {
 };
 
@@ -1447,7 +1399,7 @@ struct __alloc_traits_difference_type<_Alloc, _Ptr, true>
 };
 
 template <class _Alloc>
-struct _LIBCPP_TYPE_VIS allocator_traits
+struct _LIBCPP_TYPE_VIS_ONLY allocator_traits
 {
     typedef _Alloc                              allocator_type;
     typedef typename allocator_type::value_type value_type;
@@ -1531,7 +1483,7 @@ struct _LIBCPP_TYPE_VIS allocator_traits
             {__destroy(__has_destroy<allocator_type, _Tp*>(), __a, __p);}
 
     _LIBCPP_INLINE_VISIBILITY
-    static size_type max_size(const allocator_type& __a)
+    static size_type max_size(const allocator_type& __a) _NOEXCEPT
         {return __max_size(__has_max_size<const allocator_type>(), __a);}
 
     _LIBCPP_INLINE_VISIBILITY
@@ -1653,7 +1605,7 @@ private:
 // allocator
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS allocator
+class _LIBCPP_TYPE_VIS_ONLY allocator
 {
 public:
     typedef size_t            size_type;
@@ -1745,7 +1697,7 @@ public:
 };
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS allocator<const _Tp>
+class _LIBCPP_TYPE_VIS_ONLY allocator<const _Tp>
 {
 public:
     typedef size_t            size_type;
@@ -1843,7 +1795,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;}
 
 template <class _OutputIterator, class _Tp>
-class _LIBCPP_TYPE_VIS raw_storage_iterator
+class _LIBCPP_TYPE_VIS_ONLY raw_storage_iterator
     : public iterator<output_iterator_tag,
                       _Tp,                                         // purposefully not C++03
                       ptrdiff_t,                                   // purposefully not C++03
@@ -1896,7 +1848,7 @@ struct auto_ptr_ref
 };
 
 template<class _Tp>
-class _LIBCPP_TYPE_VIS auto_ptr
+class _LIBCPP_TYPE_VIS_ONLY auto_ptr
 {
 private:
     _Tp* __ptr_;
@@ -1940,7 +1892,7 @@ public:
 };
 
 template <>
-class _LIBCPP_TYPE_VIS auto_ptr<void>
+class _LIBCPP_TYPE_VIS_ONLY auto_ptr<void>
 {
 public:
     typedef void element_type;
@@ -2476,7 +2428,7 @@ struct __same_or_less_cv_qualified<_Ptr1, _Ptr2, true>
 // default_delete
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS default_delete
+struct _LIBCPP_TYPE_VIS_ONLY default_delete
 {
 #ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT = default;
@@ -2495,7 +2447,7 @@ struct _LIBCPP_TYPE_VIS default_delete
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS default_delete<_Tp[]>
+struct _LIBCPP_TYPE_VIS_ONLY default_delete<_Tp[]>
 {
 public:
 #ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
@@ -2518,7 +2470,7 @@ public:
 };
 
 template <class _Tp, class _Dp = default_delete<_Tp> >
-class _LIBCPP_TYPE_VIS unique_ptr
+class _LIBCPP_TYPE_VIS_ONLY unique_ptr
 {
 public:
     typedef _Tp element_type;
@@ -2697,7 +2649,7 @@ public:
 };
 
 template <class _Tp, class _Dp>
-class _LIBCPP_TYPE_VIS unique_ptr<_Tp[], _Dp>
+class _LIBCPP_TYPE_VIS_ONLY unique_ptr<_Tp[], _Dp>
 {
 public:
     typedef _Tp element_type;
@@ -3452,7 +3404,7 @@ struct __scalar_hash<_Tp, 4>
 };
 
 template<class _Tp>
-struct _LIBCPP_TYPE_VIS hash<_Tp*>
+struct _LIBCPP_TYPE_VIS_ONLY hash<_Tp*>
     : public unary_function<_Tp*, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -3469,7 +3421,7 @@ struct _LIBCPP_TYPE_VIS hash<_Tp*>
 };
 
 template <class _Tp, class _Dp>
-struct _LIBCPP_TYPE_VIS hash<unique_ptr<_Tp, _Dp> >
+struct _LIBCPP_TYPE_VIS_ONLY hash<unique_ptr<_Tp, _Dp> >
 {
     typedef unique_ptr<_Tp, _Dp> argument_type;
     typedef size_t               result_type;
@@ -3642,9 +3594,9 @@ public:
     virtual const char* what() const  _NOEXCEPT;
 };
 
-template<class _Tp> class _LIBCPP_TYPE_VIS weak_ptr;
+template<class _Tp> class _LIBCPP_TYPE_VIS_ONLY weak_ptr;
 
-class __shared_count
+class _LIBCPP_TYPE_VIS __shared_count
 {
     __shared_count(const __shared_count&);
     __shared_count& operator=(const __shared_count&);
@@ -3666,7 +3618,7 @@ public:
     long use_count() const _NOEXCEPT {return __shared_owners_ + 1;}
 };
 
-class __shared_weak_count
+class _LIBCPP_TYPE_VIS __shared_weak_count
     : private __shared_count
 {
     long __shared_weak_owners_;
@@ -3811,10 +3763,10 @@ __shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT
     __a.deallocate(this, 1);
 }
 
-template<class _Tp> class _LIBCPP_TYPE_VIS enable_shared_from_this;
+template<class _Tp> class _LIBCPP_TYPE_VIS_ONLY enable_shared_from_this;
 
 template<class _Tp>
-class _LIBCPP_TYPE_VIS shared_ptr
+class _LIBCPP_TYPE_VIS_ONLY shared_ptr
 {
 public:
     typedef _Tp element_type;
@@ -3943,8 +3895,8 @@ public:
         <
             !is_array<_Yp>::value &&
             is_convertible<_Yp*, element_type*>::value,
-            shared_ptr&
-        >::type
+            shared_ptr
+        >::type&
         operator=(auto_ptr<_Yp>&& __r);
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template<class _Yp>
@@ -4083,8 +4035,8 @@ private:
     _LIBCPP_INLINE_VISIBILITY
     void __enable_weak_this(const void*) _NOEXCEPT {}
 
-    template <class _Up> friend class _LIBCPP_TYPE_VIS shared_ptr;
-    template <class _Up> friend class _LIBCPP_TYPE_VIS weak_ptr;
+    template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY shared_ptr;
+    template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY weak_ptr;
 };
 
 template<class _Tp>
@@ -4570,8 +4522,8 @@ typename enable_if
 <
     !is_array<_Yp>::value &&
     is_convertible<_Yp*, _Tp*>::value,
-    shared_ptr<_Tp>&
->::type
+    shared_ptr<_Tp>
+>::type&
 shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r)
 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
@@ -4980,7 +4932,7 @@ get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT
 #endif  // _LIBCPP_NO_RTTI
 
 template<class _Tp>
-class _LIBCPP_TYPE_VIS weak_ptr
+class _LIBCPP_TYPE_VIS_ONLY weak_ptr
 {
 public:
     typedef _Tp element_type;
@@ -5055,8 +5007,8 @@ public:
         bool owner_before(const weak_ptr<_Up>& __r) const
         {return __cntrl_ < __r.__cntrl_;}
 
-    template <class _Up> friend class _LIBCPP_TYPE_VIS weak_ptr;
-    template <class _Up> friend class _LIBCPP_TYPE_VIS shared_ptr;
+    template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY weak_ptr;
+    template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY shared_ptr;
 };
 
 template<class _Tp>
@@ -5256,7 +5208,7 @@ weak_ptr<_Tp>::lock() const _NOEXCEPT
 template <class _Tp> struct owner_less;
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS owner_less<shared_ptr<_Tp> >
+struct _LIBCPP_TYPE_VIS_ONLY owner_less<shared_ptr<_Tp> >
     : binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool>
 {
     typedef bool result_type;
@@ -5272,7 +5224,7 @@ struct _LIBCPP_TYPE_VIS owner_less<shared_ptr<_Tp> >
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS owner_less<weak_ptr<_Tp> >
+struct _LIBCPP_TYPE_VIS_ONLY owner_less<weak_ptr<_Tp> >
     : binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool>
 {
     typedef bool result_type;
@@ -5288,7 +5240,7 @@ struct _LIBCPP_TYPE_VIS owner_less<weak_ptr<_Tp> >
 };
 
 template<class _Tp>
-class _LIBCPP_TYPE_VIS enable_shared_from_this
+class _LIBCPP_TYPE_VIS_ONLY enable_shared_from_this
 {
     mutable weak_ptr<_Tp> __weak_this_;
 protected:
@@ -5313,7 +5265,7 @@ public:
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS hash<shared_ptr<_Tp> >
+struct _LIBCPP_TYPE_VIS_ONLY hash<shared_ptr<_Tp> >
 {
     typedef shared_ptr<_Tp>      argument_type;
     typedef size_t               result_type;
@@ -5331,7 +5283,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p);
 
 #if __has_feature(cxx_atomic)
 
-class __sp_mut
+class _LIBCPP_TYPE_VIS __sp_mut
 {
     void* __lx;
 public:
@@ -5475,11 +5427,11 @@ struct _LIBCPP_TYPE_VIS pointer_safety
     operator int() const {return __v_;}
 };
 
-void declare_reachable(void* __p);
-void declare_no_pointers(char* __p, size_t __n);
-void undeclare_no_pointers(char* __p, size_t __n);
-pointer_safety get_pointer_safety() _NOEXCEPT;
-void* __undeclare_reachable(void* __p);
+_LIBCPP_FUNC_VIS void declare_reachable(void* __p);
+_LIBCPP_FUNC_VIS void declare_no_pointers(char* __p, size_t __n);
+_LIBCPP_FUNC_VIS void undeclare_no_pointers(char* __p, size_t __n);
+_LIBCPP_FUNC_VIS pointer_safety get_pointer_safety() _NOEXCEPT;
+_LIBCPP_FUNC_VIS void* __undeclare_reachable(void* __p);
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -5489,7 +5441,7 @@ undeclare_reachable(_Tp* __p)
     return static_cast<_Tp*>(__undeclare_reachable(__p));
 }
 
-void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
+_LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/system/include/libcxx/mutex b/system/include/libcxx/mutex
index e2b5d6bfd9736..e0c02adb59ed1 100644
--- a/system/include/libcxx/mutex
+++ b/system/include/libcxx/mutex
@@ -441,7 +441,7 @@ void call_once(once_flag&, _Callable);
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
-struct _LIBCPP_TYPE_VIS once_flag
+struct _LIBCPP_TYPE_VIS_ONLY once_flag
 {
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR
@@ -527,7 +527,7 @@ __call_once_proxy(void* __vp)
     (*__p)();
 }
 
-void __call_once(volatile unsigned long&, void*, void(*)(void*));
+_LIBCPP_FUNC_VIS void __call_once(volatile unsigned long&, void*, void(*)(void*));
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
diff --git a/system/include/libcxx/new b/system/include/libcxx/new
index 1e85798b5c461..31bb5982eed06 100644
--- a/system/include/libcxx/new
+++ b/system/include/libcxx/new
@@ -27,6 +27,18 @@ public:
     virtual const char* what() const noexcept;
 };
 
+class bad_array_length : public bad_alloc // C++14
+{
+public:
+    bad_array_length() noexcept;
+};
+
+class bad_array_new_length : public bad_alloc
+{
+public:
+    bad_array_new_length() noexcept;
+};
+
 struct nothrow_t {};
 extern const nothrow_t nothrow;
 typedef void (*new_handler)();
@@ -81,7 +93,18 @@ public:
     virtual const char* what() const _NOEXCEPT;
 };
 
-void __throw_bad_alloc();  // not in C++ spec
+#if defined(_LIBCPP_BUILDING_NEW) || (_LIBCPP_STD_VER > 11)
+class _LIBCPP_EXCEPTION_ABI bad_array_length
+    : public bad_alloc
+{
+public:
+    bad_array_length() _NOEXCEPT;
+    virtual ~bad_array_length() _NOEXCEPT;
+    virtual const char* what() const _NOEXCEPT;
+};
+#endif
+
+_LIBCPP_FUNC_VIS void __throw_bad_alloc();  // not in C++ spec
 
 struct _LIBCPP_TYPE_VIS nothrow_t {};
 extern _LIBCPP_FUNC_VIS const nothrow_t nothrow;
@@ -91,27 +114,33 @@ _LIBCPP_FUNC_VIS new_handler get_new_handler() _NOEXCEPT;
 
 }  // std
 
-_LIBCPP_FUNC_VIS void* operator new(std::size_t __sz)
+#if defined(_WIN32) && !defined(cxx_EXPORTS)
+# define _LIBCPP_NEW_DELETE_VIS _LIBCPP_FUNC_VIS_ONLY
+#else
+# define _LIBCPP_NEW_DELETE_VIS _LIBCPP_FUNC_VIS
+#endif
+
+_LIBCPP_NEW_DELETE_VIS void* operator new(std::size_t __sz)
 #if !__has_feature(cxx_noexcept)
     throw(std::bad_alloc)
 #endif
 ;
-_LIBCPP_FUNC_VIS void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
-_LIBCPP_FUNC_VIS void  operator delete(void* __p) _NOEXCEPT;
-_LIBCPP_FUNC_VIS void  operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT;
+_LIBCPP_NEW_DELETE_VIS void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
+_LIBCPP_NEW_DELETE_VIS void  operator delete(void* __p) _NOEXCEPT;
+_LIBCPP_NEW_DELETE_VIS void  operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT;
 
-_LIBCPP_FUNC_VIS void* operator new[](std::size_t __sz)
+_LIBCPP_NEW_DELETE_VIS void* operator new[](std::size_t __sz)
 #if !__has_feature(cxx_noexcept)
     throw(std::bad_alloc)
 #endif
 ;
-_LIBCPP_FUNC_VIS void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
-_LIBCPP_FUNC_VIS void  operator delete[](void* __p) _NOEXCEPT;
-_LIBCPP_FUNC_VIS void  operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT;
-
-_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_NEW_DELETE_VIS void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
+_LIBCPP_NEW_DELETE_VIS void  operator delete[](void* __p) _NOEXCEPT;
+_LIBCPP_NEW_DELETE_VIS void  operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT;
+
+inline _LIBCPP_INLINE_VISIBILITY void* operator new  (std::size_t, void* __p) _NOEXCEPT {return __p;}
+inline _LIBCPP_INLINE_VISIBILITY void* operator new[](std::size_t, void* __p) _NOEXCEPT {return __p;}
+inline _LIBCPP_INLINE_VISIBILITY void  operator delete  (void*, void*) _NOEXCEPT {}
+inline _LIBCPP_INLINE_VISIBILITY void  operator delete[](void*, void*) _NOEXCEPT {}
 
 #endif  // _LIBCPP_NEW
diff --git a/system/include/libcxx/numeric b/system/include/libcxx/numeric
index c201a5f57cbbb..e520c8e0d7598 100644
--- a/system/include/libcxx/numeric
+++ b/system/include/libcxx/numeric
@@ -157,7 +157,7 @@ adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterat
         {
             typename iterator_traits<_InputIterator>::value_type __t2(*__first);
             *__result = __t2 - __t1;
-            __t1 = __t2;
+            __t1 = _VSTD::move(__t2);
         }
     }
     return __result;
@@ -177,7 +177,7 @@ adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterat
         {
             typename iterator_traits<_InputIterator>::value_type __t2(*__first);
             *__result = __binary_op(__t2, __t1);
-            __t1 = __t2;
+            __t1 = _VSTD::move(__t2);
         }
     }
     return __result;
diff --git a/system/include/libcxx/optional b/system/include/libcxx/optional
new file mode 100644
index 0000000000000..a8e6a99115db8
--- /dev/null
+++ b/system/include/libcxx/optional
@@ -0,0 +1,697 @@
+// -*- C++ -*-
+//===-------------------------- optional ----------------------------------===//
+//
+//                     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_OPTIONAL
+#define _LIBCPP_OPTIONAL
+
+/*
+    optional synopsis
+
+// C++1y
+
+#include <initializer_list>
+
+namespace std
+{
+
+// optional for object types
+template <class T>
+class optional
+{
+public:
+    typedef T value_type;
+
+    // constructors
+    constexpr optional() noexcept;
+    constexpr optional(nullopt_t) noexcept;
+    optional(const optional&);
+    optional(optional&&) noexcept(is_nothrow_move_constructible<T>::value);
+    constexpr optional(const T&);
+    constexpr optional(T&&);
+    template <class... Args> constexpr explicit optional(in_place_t, Args&&...);
+    template <class U, class... Args>
+        constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
+
+    // destructor
+    ~optional();
+
+    // assignment
+    optional& operator=(nullopt_t) noexcept;
+    optional& operator=(const optional&);
+    optional& operator=(optional&&)
+        noexcept(is_nothrow_move_assignable<T>::value &&
+                 is_nothrow_move_constructible<T>::value);
+    template <class U> optional& operator=(U&&);
+    template <class... Args> void emplace(Args&&...);
+    template <class U, class... Args> void emplace(initializer_list<U>, Args&&...);
+
+    // swap
+    void swap(optional&)
+        noexcept(is_nothrow_move_constructible<T>::value &&
+                 noexcept(swap(declval<T&>(), declval<T&>())));
+
+    // observers
+    constexpr T const* operator->() const;
+    T* operator->();
+    constexpr T const& operator*() const;
+    T& operator*();
+    constexpr explicit operator bool() const noexcept;
+    constexpr T const& value() const;
+    T& value();
+    template <class U> constexpr T value_or(U&&) const&;
+    template <class U> T value_or(U&&) &&;
+};
+
+// In-place construction
+struct in_place_t{};
+constexpr in_place_t in_place{};
+
+// Disengaged state indicator
+struct nullopt_t{see below};
+constexpr nullopt_t nullopt(unspecified);
+
+// class bad_optional_access
+class bad_optional_access
+    : public logic_error
+{
+public:
+    explicit bad_optional_access(const string& what_arg);
+    explicit bad_optional_access(const char* what_arg);
+};
+
+// Relational operators
+template <class T> constexpr bool operator==(const optional<T>&, const optional<T>&);
+template <class T> constexpr bool operator< (const optional<T>&, const optional<T>&);
+
+// Comparison with nullopt
+template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
+template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
+template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
+template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
+
+// Comparison with T
+template <class T> constexpr bool operator==(const optional<T>&, const T&);
+template <class T> constexpr bool operator==(const T&, const optional<T>&);
+template <class T> constexpr bool operator<(const optional<T>&, const T&);
+template <class T> constexpr bool operator<(const T&, const optional<T>&);
+
+// Specialized algorithms
+template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below);
+template <class T> constexpr optional<typename decay<T>::type> make_optional(T&&);
+
+// hash support
+template <class T> struct hash;
+template <class T> struct hash<optional<T>>;
+
+}  // std
+
+*/
+
+#include <__config>
+#include <functional>
+#include <stdexcept>
+
+namespace std  // purposefully not using versioning namespace
+{
+
+class _LIBCPP_EXCEPTION_ABI bad_optional_access
+    : public logic_error
+{
+public:
+#if _LIBCPP_STD_VER > 11
+    _LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const string& __arg)
+        : logic_error(__arg) {}
+    _LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const char* __arg)
+        : logic_error(__arg) {}
+    _LIBCPP_INLINE_VISIBILITY bad_optional_access(const bad_optional_access&) noexcept = default;
+    _LIBCPP_INLINE_VISIBILITY bad_optional_access& operator=(const bad_optional_access&) noexcept = default;
+#else
+private:
+    bad_optional_access(const bad_optional_access&);
+    bad_optional_access& operator=(const bad_optional_access&);
+public:
+#endif  // _LIBCPP_STD_VER > 11
+    // Get the key function ~bad_optional_access() into the dylib even if not compiling for C++1y
+    virtual ~bad_optional_access() _NOEXCEPT;
+};
+
+}  // std
+
+#if _LIBCPP_STD_VER > 11
+
+#include <initializer_list>
+#include <type_traits>
+#include <new>
+#include <__functional_base>
+
+#include <__undef_min_max>
+
+#ifdef _LIBCPP_DEBUG
+#   include <__debug>
+#else
+#   define _LIBCPP_ASSERT(x, m) ((void)0)
+#endif
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct in_place_t {};
+constexpr in_place_t in_place{};
+
+struct nullopt_t
+{
+    explicit constexpr nullopt_t(int) noexcept {}
+};
+
+constexpr nullopt_t nullopt{0};
+
+template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
+class __optional_storage
+{
+protected:
+    typedef _Tp value_type;
+    union
+    {
+        char __null_state_;
+        value_type __val_;
+    };
+    bool __engaged_ = false;
+
+    _LIBCPP_INLINE_VISIBILITY
+    ~__optional_storage()
+    {
+        if (__engaged_)
+            __val_.~value_type();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __optional_storage() noexcept
+        :  __null_state_('\0') {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_storage(const __optional_storage& __x)
+        :  __engaged_(__x.__engaged_)
+        {
+            if (__engaged_)
+                ::new(_VSTD::addressof(__val_)) value_type(__x.__val_);
+        }
+
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_storage(__optional_storage&& __x)
+                      noexcept(is_nothrow_move_constructible<value_type>::value)
+        :  __engaged_(__x.__engaged_)
+        {
+            if (__engaged_)
+                ::new(_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_));
+        }
+
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __optional_storage(const value_type& __v)
+        :  __val_(__v),
+           __engaged_(true) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __optional_storage(value_type&& __v)
+        :  __val_(_VSTD::move(__v)),
+           __engaged_(true) {}
+
+    template <class... _Args>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr
+    explicit __optional_storage(in_place_t, _Args&&... __args)
+       :  __val_(_VSTD::forward<_Args>(__args)...),
+           __engaged_(true) {}
+};
+
+template <class _Tp>
+class __optional_storage<_Tp, true>
+{
+protected:
+    typedef _Tp value_type;
+    union
+    {
+        char __null_state_;
+        value_type __val_;
+    };
+    bool __engaged_ = false;
+
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __optional_storage() noexcept
+        :  __null_state_('\0') {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_storage(const __optional_storage& __x)
+        :  __engaged_(__x.__engaged_)
+        {
+            if (__engaged_)
+                ::new(_VSTD::addressof(__val_)) value_type(__x.__val_);
+        }
+
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_storage(__optional_storage&& __x)
+                      noexcept(is_nothrow_move_constructible<value_type>::value)
+        :  __engaged_(__x.__engaged_)
+        {
+            if (__engaged_)
+                ::new(_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_));
+        }
+
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __optional_storage(const value_type& __v)
+        :  __val_(__v),
+           __engaged_(true) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __optional_storage(value_type&& __v)
+        :  __val_(_VSTD::move(__v)),
+           __engaged_(true) {}
+
+    template <class... _Args>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr
+    explicit __optional_storage(in_place_t, _Args&&... __args)
+       :  __val_(_VSTD::forward<_Args>(__args)...),
+           __engaged_(true) {}
+};
+
+template <class _Tp>
+class optional
+    : private __optional_storage<_Tp>
+{
+    typedef __optional_storage<_Tp> __base;
+public:
+    typedef _Tp value_type;
+
+    static_assert(!is_reference<value_type>::value,
+              "Instantiation of optional with a reference type is ill-formed.");
+    static_assert(!is_same<typename remove_cv<value_type>::type, in_place_t>::value,
+              "Instantiation of optional with a in_place_t type is ill-formed.");
+    static_assert(!is_same<typename remove_cv<value_type>::type, nullopt_t>::value,
+              "Instantiation of optional with a nullopt_t type is ill-formed.");
+    static_assert(is_object<value_type>::value,
+        "Instantiation of optional with a non-object type is undefined behavior.");
+    static_assert(is_nothrow_destructible<value_type>::value,
+        "Instantiation of optional with an object type that is not noexcept destructible is undefined behavior.");
+
+    _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {}
+    _LIBCPP_INLINE_VISIBILITY optional(const optional&) = default;
+    _LIBCPP_INLINE_VISIBILITY optional(optional&&) = default;
+    _LIBCPP_INLINE_VISIBILITY ~optional() = default;
+    _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {}
+    _LIBCPP_INLINE_VISIBILITY constexpr optional(const value_type& __v)
+        : __base(__v) {}
+    _LIBCPP_INLINE_VISIBILITY constexpr optional(value_type&& __v)
+        : __base(_VSTD::move(__v)) {}
+
+    template <class... _Args,
+              class = typename enable_if
+                      <
+                           is_constructible<value_type, _Args...>::value
+                      >::type
+             >
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr
+    explicit optional(in_place_t, _Args&&... __args)
+        : __base(in_place, _VSTD::forward<_Args>(__args)...) {}
+
+    template <class _Up, class... _Args,
+              class = typename enable_if
+                      <
+                           is_constructible<value_type, initializer_list<_Up>&, _Args...>::value
+                      >::type
+             >
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr
+    explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
+        : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    optional& operator=(nullopt_t) noexcept
+    {
+        if (this->__engaged_)
+        {
+            this->__val_.~value_type();
+            this->__engaged_ = false;
+        }
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    optional&
+    operator=(const optional& __opt)
+    {
+        if (this->__engaged_ == __opt.__engaged_)
+        {
+            if (this->__engaged_)
+                this->__val_ = __opt.__val_;
+        }
+        else
+        {
+            if (this->__engaged_)
+                this->__val_.~value_type();
+            else
+                ::new(_VSTD::addressof(this->__val_)) value_type(__opt.__val_);
+            this->__engaged_ = __opt.__engaged_;
+        }
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    optional&
+    operator=(optional&& __opt)
+        noexcept(is_nothrow_move_assignable<value_type>::value &&
+                 is_nothrow_move_constructible<value_type>::value)
+    {
+        if (this->__engaged_ == __opt.__engaged_)
+        {
+            if (this->__engaged_)
+                this->__val_ = _VSTD::move(__opt.__val_);
+        }
+        else
+        {
+            if (this->__engaged_)
+                this->__val_.~value_type();
+            else
+                ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_));
+            this->__engaged_ = __opt.__engaged_;
+        }
+        return *this;
+    }
+
+    template <class _Up,
+              class = typename enable_if
+                      <
+                          is_same<typename remove_reference<_Up>::type, value_type>::value &&
+                          is_constructible<value_type, _Up>::value &&
+                          is_assignable<value_type&, _Up>::value
+                      >::type
+             >
+    _LIBCPP_INLINE_VISIBILITY
+    optional&
+    operator=(_Up&& __v)
+    {
+        if (this->__engaged_)
+            this->__val_ = _VSTD::forward<_Up>(__v);
+        else
+        {
+            ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Up>(__v));
+            this->__engaged_ = true;
+        }
+        return *this;
+    }
+
+    template <class... _Args,
+              class = typename enable_if
+                      <
+                          is_constructible<value_type, _Args...>::value
+                      >::type
+             >
+    _LIBCPP_INLINE_VISIBILITY
+    void
+    emplace(_Args&&... __args)
+    {
+        *this = nullopt;
+        ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...);
+        this->__engaged_ = true;
+    }
+
+    template <class _Up, class... _Args,
+              class = typename enable_if
+                      <
+                          is_constructible<value_type, initializer_list<_Up>&, _Args...>::value
+                      >::type
+             >
+    _LIBCPP_INLINE_VISIBILITY
+    void
+    emplace(initializer_list<_Up> __il, _Args&&... __args)
+    {
+        *this = nullopt;
+        ::new(_VSTD::addressof(this->__val_)) value_type(__il, _VSTD::forward<_Args>(__args)...);
+        this->__engaged_ = true;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void
+    swap(optional& __opt)
+        noexcept(is_nothrow_move_constructible<value_type>::value &&
+                 __is_nothrow_swappable<value_type>::value)
+    {
+        using _VSTD::swap;
+        if (this->__engaged_ == __opt.__engaged_)
+        {
+            if (this->__engaged_)
+                swap(this->__val_, __opt.__val_);
+        }
+        else
+        {
+            if (this->__engaged_)
+            {
+                ::new(_VSTD::addressof(__opt.__val_)) value_type(_VSTD::move(this->__val_));
+                this->__val_.~value_type();
+            }
+            else
+            {
+                ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_));
+                __opt.__val_.~value_type();
+            }
+            swap(this->__engaged_, __opt.__engaged_);
+        }
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr
+    value_type const*
+    operator->() const
+    {
+        _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value");
+        return __operator_arrow(__has_operator_addressof<value_type>{});
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    value_type*
+    operator->()
+    {
+        _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value");
+        return _VSTD::addressof(this->__val_);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr
+    const value_type&
+    operator*() const
+    {
+        _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value");
+        return this->__val_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    value_type&
+    operator*()
+    {
+        _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value");
+        return this->__val_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr explicit operator bool() const noexcept {return this->__engaged_;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr value_type const& value() const
+    {
+        if (!this->__engaged_)
+            throw bad_optional_access("optional<T>::value: not engaged");
+        return this->__val_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    value_type& value()
+    {
+        if (!this->__engaged_)
+            throw bad_optional_access("optional<T>::value: not engaged");
+        return this->__val_;
+    }
+
+    template <class _Up>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr value_type value_or(_Up&& __v) const&
+    {
+        static_assert(is_copy_constructible<value_type>::value,
+                      "optional<T>::value_or: T must be copy constructible");
+        static_assert(is_convertible<_Up, value_type>::value,
+                      "optional<T>::value_or: U must be convertible to T");
+        return this->__engaged_ ? this->__val_ :
+                                  static_cast<value_type>(_VSTD::forward<_Up>(__v));
+    }
+
+    template <class _Up>
+    _LIBCPP_INLINE_VISIBILITY
+    value_type value_or(_Up&& __v) &&
+    {
+        static_assert(is_move_constructible<value_type>::value,
+                      "optional<T>::value_or: T must be move constructible");
+        static_assert(is_convertible<_Up, value_type>::value,
+                      "optional<T>::value_or: U must be convertible to T");
+        return this->__engaged_ ? _VSTD::move(this->__val_) :
+                                  static_cast<value_type>(_VSTD::forward<_Up>(__v));
+    }
+
+private:
+    _LIBCPP_INLINE_VISIBILITY
+    value_type const*
+    __operator_arrow(true_type) const
+    {
+        return _VSTD::addressof(this->__val_);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr
+    value_type const*
+    __operator_arrow(false_type) const
+    {
+        return &this->__val_;
+    }
+};
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator==(const optional<_Tp>& __x, const optional<_Tp>& __y)
+{
+    if (static_cast<bool>(__x) != static_cast<bool>(__y))
+        return false;
+    if (!static_cast<bool>(__x))
+        return true;
+    return *__x == *__y;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator<(const optional<_Tp>& __x, const optional<_Tp>& __y)
+{
+    if (!static_cast<bool>(__y))
+        return false;
+    if (!static_cast<bool>(__x))
+        return true;
+    return less<_Tp>{}(*__x, *__y);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator==(const optional<_Tp>& __x, nullopt_t) noexcept
+{
+    return !static_cast<bool>(__x);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator==(nullopt_t, const optional<_Tp>& __x) noexcept
+{
+    return !static_cast<bool>(__x);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator<(const optional<_Tp>&, nullopt_t) noexcept
+{
+    return false;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator<(nullopt_t, const optional<_Tp>& __x) noexcept
+{
+    return static_cast<bool>(__x);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator==(const optional<_Tp>& __x, const _Tp& __v)
+{
+    return static_cast<bool>(__x) ? *__x == __v : false;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator==(const _Tp& __v, const optional<_Tp>& __x)
+{
+    return static_cast<bool>(__x) ? *__x == __v : false;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator<(const optional<_Tp>& __x, const _Tp& __v)
+{
+    return static_cast<bool>(__x) ? less<_Tp>{}(*__x, __v) : true;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator<(const _Tp& __v, const optional<_Tp>& __x)
+{
+    return static_cast<bool>(__x) ? less<_Tp>{}(__v, *__x) : false;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
+{
+    __x.swap(__y);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+optional<typename decay<_Tp>::type>
+make_optional(_Tp&& __v)
+{
+    return optional<typename decay<_Tp>::type>(_VSTD::forward<_Tp>(__v));
+}
+
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY hash<optional<_Tp> >
+{
+    typedef optional<_Tp> argument_type;
+    typedef size_t        result_type;
+
+    _LIBCPP_INLINE_VISIBILITY
+    result_type operator()(const argument_type& __opt) const _NOEXCEPT
+    {
+        return static_cast<bool>(__opt) ? hash<_Tp>()(*__opt) : 0;
+    }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif  // _LIBCPP_STD_VER > 11
+
+#endif  // _LIBCPP_ARRAY
diff --git a/system/include/libcxx/ostream b/system/include/libcxx/ostream
index eac9c8f02f15e..041314acc7568 100644
--- a/system/include/libcxx/ostream
+++ b/system/include/libcxx/ostream
@@ -32,6 +32,7 @@ public:
     virtual ~basic_ostream();
 
     // 27.7.2.3 Assign/swap
+    basic_ostream& operator=(const basic_ostream& rhs) = delete; // C++14
     basic_ostream& operator=(basic_ostream&& rhs);
     void swap(basic_ostream& rhs);
 
@@ -140,7 +141,7 @@ template <class charT, class traits, class T>
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS basic_ostream
+class _LIBCPP_TYPE_VIS_ONLY basic_ostream
     : virtual public basic_ios<_CharT, _Traits>
 {
 public:
@@ -161,6 +162,9 @@ protected:
 #endif
 
     // 27.7.2.3 Assign/swap
+#if _LIBCPP_STD_VER > 11
+    basic_ostream& operator=(const basic_ostream&) = delete;
+#endif
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     basic_ostream& operator=(basic_ostream&& __rhs);
@@ -169,7 +173,7 @@ protected:
 public:
 
     // 27.7.2.4 Prefix/suffix:
-    class _LIBCPP_TYPE_VIS sentry;
+    class _LIBCPP_TYPE_VIS_ONLY sentry;
 
     // 27.7.2.6 Formatted output:
     basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&));
@@ -207,7 +211,7 @@ protected:
 };
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS basic_ostream<_CharT, _Traits>::sentry
+class _LIBCPP_TYPE_VIS_ONLY basic_ostream<_CharT, _Traits>::sentry
 {
     bool __ok_;
     basic_ostream<_CharT, _Traits>& __os_;
@@ -1155,7 +1159,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>&
 basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
 {
-    if (!this->fail())
+    sentry __s(*this);
+    if (__s)
     {
         if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1))
             this->setstate(ios_base::failbit);
@@ -1168,8 +1173,12 @@ inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>&
 basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir)
 {
-    if (!this->fail())
-        this->rdbuf()->pubseekoff(__off, __dir, ios_base::out);
+    sentry __s(*this);
+    if (__s)
+    {
+        if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1))
+            this->setstate(ios_base::failbit);
+    }
     return *this;
 }
 
@@ -1278,8 +1287,8 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
                          use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class basic_ostream<char>)
-_LIBCPP_EXTERN_TEMPLATE(class basic_ostream<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_ostream<char>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_ostream<wchar_t>)
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/system/include/libcxx/queue b/system/include/libcxx/queue
index 8d1a9dfc948b8..bdfd70603553a 100644
--- a/system/include/libcxx/queue
+++ b/system/include/libcxx/queue
@@ -177,7 +177,7 @@ template <class T, class Container, class Compare>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, class _Container> class _LIBCPP_TYPE_VIS queue;
+template <class _Tp, class _Container> class _LIBCPP_TYPE_VIS_ONLY queue;
 
 template <class _Tp, class _Container>
 _LIBCPP_INLINE_VISIBILITY
@@ -190,7 +190,7 @@ bool
 operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container = deque<_Tp> >
-class _LIBCPP_TYPE_VIS queue
+class _LIBCPP_TYPE_VIS_ONLY queue
 {
 public:
     typedef _Container                               container_type;
@@ -376,14 +376,14 @@ swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container, class _Alloc>
-struct _LIBCPP_TYPE_VIS uses_allocator<queue<_Tp, _Container>, _Alloc>
+struct _LIBCPP_TYPE_VIS_ONLY 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_TYPE_VIS priority_queue
+class _LIBCPP_TYPE_VIS_ONLY priority_queue
 {
 public:
     typedef _Container                               container_type;
@@ -707,7 +707,7 @@ swap(priority_queue<_Tp, _Container, _Compare>& __x,
 }
 
 template <class _Tp, class _Container, class _Compare, class _Alloc>
-struct _LIBCPP_TYPE_VIS uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc>
+struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc>
     : public uses_allocator<_Container, _Alloc>
 {
 };
diff --git a/system/include/libcxx/random b/system/include/libcxx/random
index 2e7a4854c1988..c0db1abacc0a0 100644
--- a/system/include/libcxx/random
+++ b/system/include/libcxx/random
@@ -1813,7 +1813,7 @@ struct __lce_ta<__a, __c, __m, (unsigned short)(~0), __b>
 };
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-class _LIBCPP_TYPE_VIS linear_congruential_engine;
+class _LIBCPP_TYPE_VIS_ONLY linear_congruential_engine;
 
 template <class _CharT, class _Traits,
           class _Up, _Up _Ap, _Up _Cp, _Up _Np>
@@ -1829,7 +1829,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
            linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-class _LIBCPP_TYPE_VIS linear_congruential_engine
+class _LIBCPP_TYPE_VIS_ONLY linear_congruential_engine
 {
 public:
     // types
@@ -2011,7 +2011,7 @@ typedef minstd_rand                                       default_random_engine;
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-class _LIBCPP_TYPE_VIS mersenne_twister_engine;
+class _LIBCPP_TYPE_VIS_ONLY mersenne_twister_engine;
 
 template <class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
           _UI _Ap, size_t _Up, _UI _Dp, size_t _Sp,
@@ -2053,7 +2053,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-class _LIBCPP_TYPE_VIS mersenne_twister_engine
+class _LIBCPP_TYPE_VIS_ONLY mersenne_twister_engine
 {
 public:
     // types
@@ -2499,7 +2499,7 @@ typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
 // subtract_with_carry_engine
 
 template<class _UIntType, size_t __w, size_t __s, size_t __r>
-class _LIBCPP_TYPE_VIS subtract_with_carry_engine;
+class _LIBCPP_TYPE_VIS_ONLY subtract_with_carry_engine;
 
 template<class _UI, size_t _Wp, size_t _Sp, size_t _Rp>
 bool
@@ -2527,7 +2527,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
            subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x);
 
 template<class _UIntType, size_t __w, size_t __s, size_t __r>
-class _LIBCPP_TYPE_VIS subtract_with_carry_engine
+class _LIBCPP_TYPE_VIS_ONLY subtract_with_carry_engine
 {
 public:
     // types
@@ -2810,7 +2810,7 @@ typedef subtract_with_carry_engine<uint_fast64_t, 48,  5, 12>     ranlux48_base;
 // discard_block_engine
 
 template<class _Engine, size_t __p, size_t __r>
-class _LIBCPP_TYPE_VIS discard_block_engine
+class _LIBCPP_TYPE_VIS_ONLY discard_block_engine
 {
     _Engine __e_;
     int     __n_;
@@ -2983,7 +2983,7 @@ typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
 // independent_bits_engine
 
 template<class _Engine, size_t __w, class _UIntType>
-class _LIBCPP_TYPE_VIS independent_bits_engine
+class _LIBCPP_TYPE_VIS_ONLY independent_bits_engine
 {
     template <class _UI, _UI _R0, size_t _Wp, size_t _Mp>
     class __get_n
@@ -3246,7 +3246,7 @@ public:
 };
 
 template<class _Engine, size_t __k>
-class _LIBCPP_TYPE_VIS shuffle_order_engine
+class _LIBCPP_TYPE_VIS_ONLY shuffle_order_engine
 {
     static_assert(0 < __k, "shuffle_order_engine invalid parameters");
 public:
@@ -3475,7 +3475,9 @@ typedef shuffle_order_engine<minstd_rand0, 256>                         knuth_b;
 
 class _LIBCPP_TYPE_VIS random_device
 {
+#if !defined(_WIN32)
     int __f_;
+#endif // defined(_WIN32)
 public:
     // types
     typedef unsigned result_type;
@@ -3507,7 +3509,7 @@ private:
 
 // seed_seq
 
-class _LIBCPP_TYPE_VIS seed_seq
+class _LIBCPP_TYPE_VIS_ONLY seed_seq
 {
 public:
     // types
@@ -3521,7 +3523,7 @@ private:
 public:
     // constructors
     _LIBCPP_INLINE_VISIBILITY
-    seed_seq() {}
+    seed_seq() _NOEXCEPT {}
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     template<class _Tp>
         _LIBCPP_INLINE_VISIBILITY
@@ -3539,7 +3541,7 @@ public:
 
     // property functions
     _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __v_.size();}
+    size_t size() const _NOEXCEPT {return __v_.size();}
     template<class _OutputIterator>
         _LIBCPP_INLINE_VISIBILITY
         void param(_OutputIterator __dest) const
@@ -3684,13 +3686,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // uniform_real_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS uniform_real_distribution
+class _LIBCPP_TYPE_VIS_ONLY uniform_real_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         result_type __a_;
         result_type __b_;
@@ -3805,13 +3807,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 
 // bernoulli_distribution
 
-class _LIBCPP_TYPE_VIS bernoulli_distribution
+class _LIBCPP_TYPE_VIS_ONLY bernoulli_distribution
 {
 public:
     // types
     typedef bool result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         double __p_;
     public:
@@ -3914,13 +3916,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, bernoulli_distribution& __x)
 // binomial_distribution
 
 template<class _IntType = int>
-class _LIBCPP_TYPE_VIS binomial_distribution
+class _LIBCPP_TYPE_VIS_ONLY binomial_distribution
 {
 public:
     // types
     typedef _IntType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         result_type __t_;
         double __p_;
@@ -4079,13 +4081,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // exponential_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS exponential_distribution
+class _LIBCPP_TYPE_VIS_ONLY exponential_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         result_type __lambda_;
     public:
@@ -4194,13 +4196,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // normal_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS normal_distribution
+class _LIBCPP_TYPE_VIS_ONLY normal_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         result_type __mean_;
         result_type __stddev_;
@@ -4362,13 +4364,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // lognormal_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS lognormal_distribution
+class _LIBCPP_TYPE_VIS_ONLY lognormal_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         normal_distribution<result_type> __nd_;
     public:
@@ -4487,13 +4489,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // poisson_distribution
 
 template<class _IntType = int>
-class _LIBCPP_TYPE_VIS poisson_distribution
+class _LIBCPP_TYPE_VIS_ONLY poisson_distribution
 {
 public:
     // types
     typedef _IntType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         double __mean_;
         double __s_;
@@ -4718,13 +4720,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // weibull_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS weibull_distribution
+class _LIBCPP_TYPE_VIS_ONLY weibull_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         result_type __a_;
         result_type __b_;
@@ -4832,13 +4834,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 }
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS extreme_value_distribution
+class _LIBCPP_TYPE_VIS_ONLY extreme_value_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         result_type __a_;
         result_type __b_;
@@ -4953,13 +4955,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // gamma_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS gamma_distribution
+class _LIBCPP_TYPE_VIS_ONLY gamma_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         result_type __alpha_;
         result_type __beta_;
@@ -5125,13 +5127,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // negative_binomial_distribution
 
 template<class _IntType = int>
-class _LIBCPP_TYPE_VIS negative_binomial_distribution
+class _LIBCPP_TYPE_VIS_ONLY negative_binomial_distribution
 {
 public:
     // types
     typedef _IntType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         result_type __k_;
         double __p_;
@@ -5260,13 +5262,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // geometric_distribution
 
 template<class _IntType = int>
-class _LIBCPP_TYPE_VIS geometric_distribution
+class _LIBCPP_TYPE_VIS_ONLY geometric_distribution
 {
 public:
     // types
     typedef _IntType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         double __p_;
     public:
@@ -5362,13 +5364,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // chi_squared_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS chi_squared_distribution
+class _LIBCPP_TYPE_VIS_ONLY chi_squared_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         result_type __n_;
     public:
@@ -5468,13 +5470,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // cauchy_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS cauchy_distribution
+class _LIBCPP_TYPE_VIS_ONLY cauchy_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         result_type __a_;
         result_type __b_;
@@ -5591,13 +5593,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // fisher_f_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS fisher_f_distribution
+class _LIBCPP_TYPE_VIS_ONLY fisher_f_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         result_type __m_;
         result_type __n_;
@@ -5713,13 +5715,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // student_t_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS student_t_distribution
+class _LIBCPP_TYPE_VIS_ONLY student_t_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         result_type __n_;
     public:
@@ -5826,13 +5828,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // discrete_distribution
 
 template<class _IntType = int>
-class _LIBCPP_TYPE_VIS discrete_distribution
+class _LIBCPP_TYPE_VIS_ONLY discrete_distribution
 {
 public:
     // types
     typedef _IntType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         vector<double> __p_;
     public:
@@ -5901,8 +5903,8 @@ public:
         discrete_distribution(size_t __nw, double __xmin, double __xmax,
                               _UnaryOperation __fw)
         : __p_(__nw, __xmin, __xmax, __fw) {}
-    explicit discrete_distribution(const param_type& __p)
     _LIBCPP_INLINE_VISIBILITY
+    explicit discrete_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
@@ -6057,13 +6059,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // piecewise_constant_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS piecewise_constant_distribution
+class _LIBCPP_TYPE_VIS_ONLY piecewise_constant_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         vector<result_type> __b_;
         vector<result_type> __densities_;
@@ -6381,13 +6383,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
 // piecewise_linear_distribution
 
 template<class _RealType = double>
-class _LIBCPP_TYPE_VIS piecewise_linear_distribution
+class _LIBCPP_TYPE_VIS_ONLY piecewise_linear_distribution
 {
 public:
     // types
     typedef _RealType result_type;
 
-    class _LIBCPP_TYPE_VIS param_type
+    class _LIBCPP_TYPE_VIS_ONLY param_type
     {
         vector<result_type> __b_;
         vector<result_type> __densities_;
diff --git a/system/include/libcxx/ratio b/system/include/libcxx/ratio
index f4e741e843e8f..48dcd81c1a72a 100644
--- a/system/include/libcxx/ratio
+++ b/system/include/libcxx/ratio
@@ -231,7 +231,7 @@ public:
 };
 
 template <intmax_t _Num, intmax_t _Den = 1>
-class _LIBCPP_TYPE_VIS ratio
+class _LIBCPP_TYPE_VIS_ONLY ratio
 {
     static_assert(__static_abs<_Num>::value >= 0, "ratio numerator is out of range");
     static_assert(_Den != 0, "ratio divide by 0");
@@ -292,7 +292,7 @@ template <class _R1, class _R2> using ratio_multiply
 #else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS ratio_multiply
+struct _LIBCPP_TYPE_VIS_ONLY ratio_multiply
     : public __ratio_multiply<_R1, _R2>::type {};
 
 #endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@@ -319,7 +319,7 @@ template <class _R1, class _R2> using ratio_divide
 #else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS ratio_divide
+struct _LIBCPP_TYPE_VIS_ONLY ratio_divide
     : public __ratio_divide<_R1, _R2>::type {};
 
 #endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@@ -354,7 +354,7 @@ template <class _R1, class _R2> using ratio_add
 #else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS ratio_add
+struct _LIBCPP_TYPE_VIS_ONLY ratio_add
     : public __ratio_add<_R1, _R2>::type {};
 
 #endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@@ -389,7 +389,7 @@ template <class _R1, class _R2> using ratio_subtract
 #else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS ratio_subtract
+struct _LIBCPP_TYPE_VIS_ONLY ratio_subtract
     : public __ratio_subtract<_R1, _R2>::type {};
 
 #endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@@ -397,11 +397,11 @@ struct _LIBCPP_TYPE_VIS ratio_subtract
 // ratio_equal
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS ratio_equal
+struct _LIBCPP_TYPE_VIS_ONLY ratio_equal
     : public integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den> {};
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS ratio_not_equal
+struct _LIBCPP_TYPE_VIS_ONLY ratio_not_equal
     : public integral_constant<bool, !ratio_equal<_R1, _R2>::value> {};
 
 // ratio_less
@@ -460,19 +460,19 @@ struct __ratio_less<_R1, _R2, -1LL, -1LL>
 };
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS ratio_less
+struct _LIBCPP_TYPE_VIS_ONLY ratio_less
     : public integral_constant<bool, __ratio_less<_R1, _R2>::value> {};
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS ratio_less_equal
+struct _LIBCPP_TYPE_VIS_ONLY ratio_less_equal
     : public integral_constant<bool, !ratio_less<_R2, _R1>::value> {};
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS ratio_greater
+struct _LIBCPP_TYPE_VIS_ONLY ratio_greater
     : public integral_constant<bool, ratio_less<_R2, _R1>::value> {};
 
 template <class _R1, class _R2>
-struct _LIBCPP_TYPE_VIS ratio_greater_equal
+struct _LIBCPP_TYPE_VIS_ONLY ratio_greater_equal
     : public integral_constant<bool, !ratio_less<_R1, _R2>::value> {};
 
 template <class _R1, class _R2>
diff --git a/system/include/libcxx/readme.txt b/system/include/libcxx/readme.txt
index 7687e5b2cd507..ae8090fd69a9d 100644
--- a/system/include/libcxx/readme.txt
+++ b/system/include/libcxx/readme.txt
@@ -1 +1 @@
-These files are from libc++, svn revision 187959, 2013-08-08.
+These files are from libc++, svn revision 194185, 2013-11-07.
diff --git a/system/include/libcxx/regex b/system/include/libcxx/regex
index bde3af7e455cb..ffe39cf1cffad 100644
--- a/system/include/libcxx/regex
+++ b/system/include/libcxx/regex
@@ -925,7 +925,7 @@ public:
 };
 
 template <class _CharT>
-struct _LIBCPP_TYPE_VIS regex_traits
+struct _LIBCPP_TYPE_VIS_ONLY regex_traits
 {
 public:
     typedef _CharT                  char_type;
@@ -970,7 +970,7 @@ public:
     bool isctype(char_type __c, char_class_type __m) const;
     _LIBCPP_INLINE_VISIBILITY
     int value(char_type __ch, int __radix) const
-        {return __value(__ch, __radix);}
+        {return __regex_traits_value(__ch, __radix);}
     locale_type imbue(locale_type __l);
     _LIBCPP_INLINE_VISIBILITY
     locale_type getloc()const {return __loc_;}
@@ -1001,11 +1001,11 @@ private:
         __lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
                            bool __icase, wchar_t) const;
 
-    static int __value(unsigned char __ch, int __radix);
+    static int __regex_traits_value(unsigned char __ch, int __radix);
     _LIBCPP_INLINE_VISIBILITY
-    int __value(char __ch, int __radix) const
-        {return __value(static_cast<unsigned char>(__ch), __radix);}
-    int __value(wchar_t __ch, int __radix) const;
+    int __regex_traits_value(char __ch, int __radix) const
+        {return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);}
+    int __regex_traits_value(wchar_t __ch, int __radix) const;
 };
 
 template <class _CharT>
@@ -1100,7 +1100,7 @@ regex_traits<_CharT>::__transform_primary(_ForwardIterator __f,
 
 // lookup_collatename is very FreeBSD-specific
 
-string __get_collation_name(const char* __s);
+_LIBCPP_FUNC_VIS string __get_collation_name(const char* __s);
 
 template <class _CharT>
 template <class _ForwardIterator>
@@ -1161,7 +1161,7 @@ regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f,
 
 // lookup_classname
 
-ctype_base::mask __get_classname(const char* __s, bool __icase);
+ctype_base::mask _LIBCPP_FUNC_VIS __get_classname(const char* __s, bool __icase);
 
 template <class _CharT>
 template <class _ForwardIterator>
@@ -1207,7 +1207,7 @@ regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const
 
 template <class _CharT>
 int
-regex_traits<_CharT>::__value(unsigned char __ch, int __radix)
+regex_traits<_CharT>::__regex_traits_value(unsigned char __ch, int __radix)
 {
     if ((__ch & 0xF8u) == 0x30)  // '0' <= __ch && __ch <= '7'
         return __ch - '0';
@@ -1228,18 +1228,18 @@ regex_traits<_CharT>::__value(unsigned char __ch, int __radix)
 template <class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 int
-regex_traits<_CharT>::__value(wchar_t __ch, int __radix) const
+regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const
 {
-    return __value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix);
+    return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix);
 }
 
 template <class _CharT> class __node;
 
-template <class _BidirectionalIterator> class _LIBCPP_TYPE_VIS sub_match;
+template <class _BidirectionalIterator> class _LIBCPP_TYPE_VIS_ONLY sub_match;
 
 template <class _BidirectionalIterator,
           class _Allocator = allocator<sub_match<_BidirectionalIterator> > >
-class _LIBCPP_TYPE_VIS match_results;
+class _LIBCPP_TYPE_VIS_ONLY match_results;
 
 template <class _CharT>
 struct __state
@@ -2014,6 +2014,9 @@ public:
     virtual void __exec(__state&) const;
 };
 
+template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<char>::__exec(__state&) const;
+template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<wchar_t>::__exec(__state&) const;
+
 // __match_char
 
 template <class _CharT>
@@ -2415,7 +2418,7 @@ __exit:
 template <class _CharT, class _Traits> class __lookahead;
 
 template <class _CharT, class _Traits = regex_traits<_CharT> >
-class _LIBCPP_TYPE_VIS basic_regex
+class _LIBCPP_TYPE_VIS_ONLY basic_regex
 {
 public:
     // types:
@@ -3782,7 +3785,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
                 }
                 __ml->__add_range(_VSTD::move(__start_range), _VSTD::move(__end_range));
             }
-            else
+            else if (!__start_range.empty())
             {
                 if (__start_range.size() == 1)
                     __ml->__add_char(__start_range[0]);
@@ -3790,7 +3793,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
                     __ml->__add_digraph(__start_range[0], __start_range[1]);
             }
         }
-        else
+        else if (!__start_range.empty())
         {
             if (__start_range.size() == 1)
                 __ml->__add_char(__start_range[0]);
@@ -4781,7 +4784,7 @@ typedef basic_regex<wchar_t> wregex;
 // sub_match
 
 template <class _BidirectionalIterator>
-class _LIBCPP_TYPE_VIS sub_match
+class _LIBCPP_TYPE_VIS_ONLY sub_match
     : public pair<_BidirectionalIterator, _BidirectionalIterator>
 {
 public:
@@ -5204,7 +5207,7 @@ operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m)
 }
 
 template <class _BidirectionalIterator, class _Allocator>
-class _LIBCPP_TYPE_VIS match_results
+class _LIBCPP_TYPE_VIS_ONLY match_results
 {
 public:
     typedef _Allocator                                        allocator_type;
@@ -6007,7 +6010,7 @@ regex_match(const basic_string<_CharT, _ST, _SA>& __s,
 template <class _BidirectionalIterator,
           class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
           class _Traits = regex_traits<_CharT> >
-class _LIBCPP_TYPE_VIS regex_iterator
+class _LIBCPP_TYPE_VIS_ONLY regex_iterator
 {
 public:
     typedef basic_regex<_CharT, _Traits>          regex_type;
@@ -6119,7 +6122,7 @@ typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
 template <class _BidirectionalIterator,
           class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
           class _Traits = regex_traits<_CharT> >
-class _LIBCPP_TYPE_VIS regex_token_iterator
+class _LIBCPP_TYPE_VIS_ONLY regex_token_iterator
 {
 public:
     typedef basic_regex<_CharT, _Traits>      regex_type;
diff --git a/system/include/libcxx/scoped_allocator b/system/include/libcxx/scoped_allocator
index 92532342075b6..aa8bece6d3313 100644
--- a/system/include/libcxx/scoped_allocator
+++ b/system/include/libcxx/scoped_allocator
@@ -365,7 +365,7 @@ struct __outermost<_Alloc, true>
 };
 
 template <class _OuterAlloc, class... _InnerAllocs>
-class _LIBCPP_TYPE_VIS scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>
+class _LIBCPP_TYPE_VIS_ONLY scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>
     : public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
 {
     typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> base;
diff --git a/system/include/libcxx/set b/system/include/libcxx/set
index 11ea9658bd6a5..a537c5fe3457b 100644
--- a/system/include/libcxx/set
+++ b/system/include/libcxx/set
@@ -66,6 +66,11 @@ public:
     set(initializer_list<value_type> il, const value_compare& comp = value_compare());
     set(initializer_list<value_type> il, const value_compare& comp,
         const allocator_type& a);
+    template <class InputIterator>
+        set(InputIterator first, InputIterator last, const allocator_type& a)
+            : set(first, last, Compare(), a) {}  // C++14
+    set(initializer_list<value_type> il, const allocator_type& a)
+        : set(il, Compare(), a) {}  // C++14
     ~set();
 
     set& operator=(const set& s);
@@ -129,13 +134,33 @@ public:
     // set operations:
           iterator find(const key_type& k);
     const_iterator find(const key_type& k) const;
+    template<typename K>
+        iterator find(const K& x);
+    template<typename K>
+        const_iterator find(const K& x) const;  // C++14
+    template<typename K>
+      size_type count(const K& x) const;        // C++14
+
     size_type      count(const key_type& k) const;
           iterator lower_bound(const key_type& k);
     const_iterator lower_bound(const key_type& k) const;
+    template<typename K>
+        iterator lower_bound(const K& x);              // C++14
+    template<typename K>
+        const_iterator lower_bound(const K& x) const;  // C++14
+
           iterator upper_bound(const key_type& k);
     const_iterator upper_bound(const key_type& k) const;
+    template<typename K>
+        iterator upper_bound(const K& x);              // C++14
+    template<typename K>
+        const_iterator upper_bound(const K& x) const;  // C++14
     pair<iterator,iterator>             equal_range(const key_type& k);
     pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
+    template<typename K>
+        pair<iterator,iterator>             equal_range(const K& x);        // C++14
+    template<typename K>
+        pair<const_iterator,const_iterator> equal_range(const K& x) const;  // C++14
 };
 
 template <class Key, class Compare, class Allocator>
@@ -222,6 +247,11 @@ public:
     multiset(initializer_list<value_type> il, const value_compare& comp = value_compare());
     multiset(initializer_list<value_type> il, const value_compare& comp,
              const allocator_type& a);
+    template <class InputIterator>
+        multiset(InputIterator first, InputIterator last, const allocator_type& a)
+            : set(first, last, Compare(), a) {}  // C++14
+    multiset(initializer_list<value_type> il, const allocator_type& a)
+        : set(il, Compare(), a) {}  // C++14
     ~multiset();
 
     multiset& operator=(const multiset& s);
@@ -285,13 +315,32 @@ public:
     // set operations:
           iterator find(const key_type& k);
     const_iterator find(const key_type& k) const;
+    template<typename K>
+        iterator find(const K& x);
+    template<typename K>
+        const_iterator find(const K& x) const;  // C++14
+
     size_type      count(const key_type& k) const;
           iterator lower_bound(const key_type& k);
     const_iterator lower_bound(const key_type& k) const;
+    template<typename K>
+        iterator lower_bound(const K& x);              // C++14
+    template<typename K>
+        const_iterator lower_bound(const K& x) const;  // C++14
+
           iterator upper_bound(const key_type& k);
     const_iterator upper_bound(const key_type& k) const;
+    template<typename K>
+        iterator upper_bound(const K& x);              // C++14
+    template<typename K>
+        const_iterator upper_bound(const K& x) const;  // C++14
+
     pair<iterator,iterator>             equal_range(const key_type& k);
     pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
+    template<typename K>
+        pair<iterator,iterator>             equal_range(const K& x);        // C++14
+    template<typename K>
+        pair<const_iterator,const_iterator> equal_range(const K& x) const;  // C++14
 };
 
 template <class Key, class Compare, class Allocator>
@@ -346,7 +395,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Key, class _Compare = less<_Key>,
           class _Allocator = allocator<_Key> >
-class _LIBCPP_TYPE_VIS set
+class _LIBCPP_TYPE_VIS_ONLY set
 {
 public:
     // types:
@@ -403,6 +452,13 @@ public:
             insert(__f, __l);
         }
 
+#if _LIBCPP_STD_VER > 11
+        template <class _InputIterator>
+        _LIBCPP_INLINE_VISIBILITY 
+        set(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
+            : set(__f, __l, key_compare(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     set(const set& __s)
         : __tree_(__s.__tree_)
@@ -455,6 +511,12 @@ public:
             insert(__il.begin(), __il.end());
         }
 
+#if _LIBCPP_STD_VER > 11
+    _LIBCPP_INLINE_VISIBILITY 
+    set(initializer_list<value_type> __il, const allocator_type& __a)
+        : set(__il, key_compare(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     set& operator=(initializer_list<value_type> __il)
         {
@@ -579,6 +641,17 @@ public:
     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);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    find(const _K2& __k)                           {return __tree_.find(__k);}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    find(const _K2& __k) const                     {return __tree_.find(__k);}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     size_type      count(const key_type& __k) const
         {return __tree_.__count_unique(__k);}
@@ -588,18 +661,51 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     const_iterator lower_bound(const key_type& __k) const
         {return __tree_.lower_bound(__k);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    lower_bound(const _K2& __k)       {return __tree_.lower_bound(__k);}
+
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
+#endif
+
     _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);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    upper_bound(const _K2& __k)       {return __tree_.upper_bound(__k);}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
+#endif
+
     _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);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
+    equal_range(const _K2& __k)       {return __tree_.__equal_range_unique(__k);}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
+    equal_range(const _K2& __k) const {return __tree_.__equal_range_unique(__k);}
+#endif
 };
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -685,7 +791,7 @@ swap(set<_Key, _Compare, _Allocator>& __x,
 
 template <class _Key, class _Compare = less<_Key>,
           class _Allocator = allocator<_Key> >
-class _LIBCPP_TYPE_VIS multiset
+class _LIBCPP_TYPE_VIS_ONLY multiset
 {
 public:
     // types:
@@ -734,6 +840,13 @@ public:
             insert(__f, __l);
         }
 
+#if _LIBCPP_STD_VER > 11
+        template <class _InputIterator>
+        _LIBCPP_INLINE_VISIBILITY 
+        multiset(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
+            : multiset(__f, __l, key_compare(), __a) {}
+#endif
+
     template <class _InputIterator>
         _LIBCPP_INLINE_VISIBILITY
         multiset(_InputIterator __f, _InputIterator __l,
@@ -793,6 +906,12 @@ public:
             insert(__il.begin(), __il.end());
         }
 
+#if _LIBCPP_STD_VER > 11
+    _LIBCPP_INLINE_VISIBILITY 
+    multiset(initializer_list<value_type> __il, const allocator_type& __a)
+        : multiset(__il, key_compare(), __a) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     multiset& operator=(initializer_list<value_type> __il)
         {
@@ -917,27 +1036,72 @@ public:
     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);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,iterator>::type
+    find(const _K2& __k)                           {return __tree_.find(__k);}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    find(const _K2& __k) const                     {return __tree_.find(__k);}
+#endif
+
     _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);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,iterator>::type
+    lower_bound(const _K2& __k)       {return __tree_.lower_bound(__k);}
+
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
+#endif
+
     _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);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,iterator>::type
+    upper_bound(const _K2& __k)       {return __tree_.upper_bound(__k);}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
+#endif
+
     _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);}
+#if _LIBCPP_STD_VER > 11
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
+    equal_range(const _K2& __k)       {return __tree_.__equal_range_multi(__k);}
+    template <typename _K2>
+    _LIBCPP_INLINE_VISIBILITY
+    typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
+    equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
+#endif
 };
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
diff --git a/system/include/libcxx/shared_mutex b/system/include/libcxx/shared_mutex
new file mode 100644
index 0000000000000..5b1f53aafe81e
--- /dev/null
+++ b/system/include/libcxx/shared_mutex
@@ -0,0 +1,419 @@
+// -*- C++ -*-
+//===------------------------ shared_mutex --------------------------------===//
+//
+//                     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_SHARED_MUTEX
+#define _LIBCPP_SHARED_MUTEX
+
+/*
+    shared_mutex synopsis
+
+// C++1y
+
+namespace std
+{
+
+class shared_mutex
+{
+public:
+    shared_mutex();
+    ~shared_mutex();
+
+    shared_mutex(const shared_mutex&) = delete;
+    shared_mutex& operator=(const shared_mutex&) = delete;
+
+    // Exclusive ownership
+    void lock(); // blocking
+    bool try_lock();
+    template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
+    template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
+    void unlock();
+
+    // Shared ownership
+    void lock_shared(); // blocking
+    bool try_lock_shared();
+    template <class Rep, class Period>
+        bool
+        try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time);
+    template <class Clock, class Duration>
+        bool
+        try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time);
+    void unlock_shared();
+};
+
+template <class Mutex>
+class shared_lock
+{
+public:
+    typedef Mutex mutex_type;
+
+    // Shared locking
+    shared_lock() noexcept;
+    explicit shared_lock(mutex_type& m); // blocking
+    shared_lock(mutex_type& m, defer_lock_t) noexcept;
+    shared_lock(mutex_type& m, try_to_lock_t);
+    shared_lock(mutex_type& m, adopt_lock_t);
+    template <class Clock, class Duration>
+        shared_lock(mutex_type& m,
+                    const chrono::time_point<Clock, Duration>& abs_time);
+    template <class Rep, class Period>
+        shared_lock(mutex_type& m,
+                    const chrono::duration<Rep, Period>& rel_time);
+    ~shared_lock();
+
+    shared_lock(shared_lock const&) = delete;
+    shared_lock& operator=(shared_lock const&) = delete;
+
+    shared_lock(shared_lock&& u) noexcept;
+    shared_lock& operator=(shared_lock&& u) noexcept;
+
+    void lock(); // blocking
+    bool try_lock();
+    template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
+    template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
+    void unlock();
+
+    // Setters
+    void swap(shared_lock& u) noexcept;
+    mutex_type* release() noexcept;
+
+    // Getters
+    bool owns_lock() const noexcept;
+    explicit operator bool () const noexcept;
+    mutex_type* mutex() const noexcept;
+};
+
+template <class Mutex>
+    void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
+
+}  // std
+
+*/
+
+#include <__config>
+
+#if _LIBCPP_STD_VER > 11 || defined(_LIBCPP_BUILDING_SHARED_MUTEX)
+
+#include <__mutex_base>
+
+#include <__undef_min_max>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class _LIBCPP_TYPE_VIS shared_mutex
+{
+    mutex               __mut_;
+    condition_variable  __gate1_;
+    condition_variable  __gate2_;
+    unsigned            __state_;
+
+    static const unsigned __write_entered_ = 1U << (sizeof(unsigned)*__CHAR_BIT__ - 1);
+    static const unsigned __n_readers_ = ~__write_entered_;
+public:
+    shared_mutex();
+    _LIBCPP_INLINE_VISIBILITY ~shared_mutex() = default;
+
+    shared_mutex(const shared_mutex&) = delete;
+    shared_mutex& operator=(const shared_mutex&) = delete;
+
+    // Exclusive ownership
+    void lock();
+    bool try_lock();
+    template <class _Rep, class _Period>
+        _LIBCPP_INLINE_VISIBILITY
+        bool
+        try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time)
+        {
+            return try_lock_until(chrono::steady_clock::now() + __rel_time);
+        }
+    template <class _Clock, class _Duration>
+        bool
+        try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
+    void unlock();
+
+    // Shared ownership
+    void lock_shared();
+    bool try_lock_shared();
+    template <class _Rep, class _Period>
+        _LIBCPP_INLINE_VISIBILITY
+        bool
+        try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rel_time)
+        {
+            return try_lock_shared_until(chrono::steady_clock::now() + __rel_time);
+        }
+    template <class _Clock, class _Duration>
+        bool
+        try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
+    void unlock_shared();
+};
+
+template <class _Clock, class _Duration>
+bool
+shared_mutex::try_lock_until(
+                        const chrono::time_point<_Clock, _Duration>& __abs_time)
+{
+    unique_lock<mutex> __lk(__mut_);
+    if (__state_ & __write_entered_)
+    {
+        while (true)
+        {
+            cv_status __status = __gate1_.wait_until(__lk, __abs_time);
+            if ((__state_ & __write_entered_) == 0)
+                break;
+            if (__status == cv_status::timeout)
+                return false;
+        }
+    }
+    __state_ |= __write_entered_;
+    if (__state_ & __n_readers_)
+    {
+        while (true)
+        {
+            cv_status __status = __gate2_.wait_until(__lk, __abs_time);
+            if ((__state_ & __n_readers_) == 0)
+                break;
+            if (__status == cv_status::timeout)
+            {
+                __state_ &= ~__write_entered_;
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+template <class _Clock, class _Duration>
+bool
+shared_mutex::try_lock_shared_until(
+                        const chrono::time_point<_Clock, _Duration>& __abs_time)
+{
+    unique_lock<mutex> __lk(__mut_);
+    if ((__state_ & __write_entered_) || (__state_ & __n_readers_) == __n_readers_)
+    {
+        while (true)
+        {
+            cv_status status = __gate1_.wait_until(__lk, __abs_time);
+            if ((__state_ & __write_entered_) == 0 &&
+                                       (__state_ & __n_readers_) < __n_readers_)
+                break;
+            if (status == cv_status::timeout)
+                return false;
+        }
+    }
+    unsigned __num_readers = (__state_ & __n_readers_) + 1;
+    __state_ &= ~__n_readers_;
+    __state_ |= __num_readers;
+    return true;
+}
+
+template <class _Mutex>
+class shared_lock
+{
+public:
+    typedef _Mutex mutex_type;
+
+private:
+    mutex_type* __m_;
+    bool __owns_;
+
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    shared_lock() noexcept
+        : __m_(nullptr),
+          __owns_(false)
+        {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit shared_lock(mutex_type& __m)
+        : __m_(&__m),
+          __owns_(true)
+        {__m_->lock_shared();}
+
+    _LIBCPP_INLINE_VISIBILITY
+    shared_lock(mutex_type& __m, defer_lock_t) noexcept
+        : __m_(&__m),
+          __owns_(false)
+        {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    shared_lock(mutex_type& __m, try_to_lock_t)
+        : __m_(&__m),
+          __owns_(__m.try_lock_shared())
+        {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    shared_lock(mutex_type& __m, adopt_lock_t)
+        : __m_(&__m),
+          __owns_(true)
+        {}
+
+    template <class _Clock, class _Duration>
+        _LIBCPP_INLINE_VISIBILITY
+        shared_lock(mutex_type& __m,
+                    const chrono::time_point<_Clock, _Duration>& __abs_time)
+            : __m_(&__m),
+              __owns_(__m.try_lock_shared_until(__abs_time))
+            {}
+
+    template <class _Rep, class _Period>
+        _LIBCPP_INLINE_VISIBILITY
+        shared_lock(mutex_type& __m,
+                    const chrono::duration<_Rep, _Period>& __rel_time)
+            : __m_(&__m),
+              __owns_(__m.try_lock_shared_for(__rel_time))
+            {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    ~shared_lock()
+    {
+        if (__owns_)
+            __m_->unlock_shared();
+    }
+
+    shared_lock(shared_lock const&) = delete;
+    shared_lock& operator=(shared_lock const&) = delete;
+
+    _LIBCPP_INLINE_VISIBILITY
+    shared_lock(shared_lock&& __u) noexcept
+        : __m_(__u.__m_),
+          __owns_(__u.__owns_)
+        {
+            __u.__m_ = nullptr;
+            __u.__owns_ = false;
+        }
+
+    _LIBCPP_INLINE_VISIBILITY
+    shared_lock& operator=(shared_lock&& __u) noexcept
+    {
+        if (__owns_)
+            __m_->unlock_shared();
+        __m_ = nullptr;
+        __owns_ = false;
+        __m_ = __u.__m_;
+        __owns_ = __u.__owns_;
+        __u.__m_ = nullptr;
+        __u.__owns_ = false;
+        return *this;
+    }
+
+    void lock();
+    bool try_lock();
+    template <class Rep, class Period>
+        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
+    template <class Clock, class Duration>
+        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
+    void unlock();
+
+    // Setters
+    _LIBCPP_INLINE_VISIBILITY
+    void swap(shared_lock& __u) noexcept
+    {
+        _VSTD::swap(__m_, __u.__m_);
+        _VSTD::swap(__owns_, __u.__owns_);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    mutex_type* release() noexcept
+    {
+        mutex_type* __m = __m_;
+        __m_ = nullptr;
+        __owns_ = false;
+        return __m;
+    }
+
+    // Getters
+    _LIBCPP_INLINE_VISIBILITY
+    bool owns_lock() const noexcept {return __owns_;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit operator bool () const noexcept {return __owns_;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    mutex_type* mutex() const noexcept {return __m_;}
+};
+
+template <class _Mutex>
+void
+shared_lock<_Mutex>::lock()
+{
+    if (__m_ == nullptr)
+        __throw_system_error(EPERM, "shared_lock::lock: references null mutex");
+    if (__owns_)
+        __throw_system_error(EDEADLK, "shared_lock::lock: already locked");
+    __m_->lock_shared();
+    __owns_ = true;
+}
+
+template <class _Mutex>
+bool
+shared_lock<_Mutex>::try_lock()
+{
+    if (__m_ == nullptr)
+        __throw_system_error(EPERM, "shared_lock::try_lock: references null mutex");
+    if (__owns_)
+        __throw_system_error(EDEADLK, "shared_lock::try_lock: already locked");
+    __owns_ = __m_->try_lock_shared();
+    return __owns_;
+}
+
+template <class _Mutex>
+template <class _Rep, class _Period>
+bool
+shared_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d)
+{
+    if (__m_ == nullptr)
+        __throw_system_error(EPERM, "shared_lock::try_lock_for: references null mutex");
+    if (__owns_)
+        __throw_system_error(EDEADLK, "shared_lock::try_lock_for: already locked");
+    __owns_ = __m_->try_lock_shared_for(__d);
+    return __owns_;
+}
+
+template <class _Mutex>
+template <class _Clock, class _Duration>
+bool
+shared_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
+{
+    if (__m_ == nullptr)
+        __throw_system_error(EPERM, "shared_lock::try_lock_until: references null mutex");
+    if (__owns_)
+        __throw_system_error(EDEADLK, "shared_lock::try_lock_until: already locked");
+    __owns_ = __m_->try_lock_shared_until(__t);
+    return __owns_;
+}
+
+template <class _Mutex>
+void
+shared_lock<_Mutex>::unlock()
+{
+    if (!__owns_)
+        __throw_system_error(EPERM, "shared_lock::unlock: not locked");
+    __m_->unlock_shared();
+    __owns_ = false;
+}
+
+template <class _Mutex>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) noexcept
+    {__x.swap(__y);}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif  // _LIBCPP_STD_VER > 11
+
+#endif  // _LIBCPP_SHARED_MUTEX
diff --git a/system/include/libcxx/sstream b/system/include/libcxx/sstream
index a8f8148ade570..f90d4464a4021 100644
--- a/system/include/libcxx/sstream
+++ b/system/include/libcxx/sstream
@@ -186,7 +186,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // basic_stringbuf
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TYPE_VIS basic_stringbuf
+class _LIBCPP_TYPE_VIS_ONLY basic_stringbuf
     : public basic_streambuf<_CharT, _Traits>
 {
 public:
@@ -613,7 +613,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::seekpos(pos_type __sp,
 // basic_istringstream
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TYPE_VIS basic_istringstream
+class _LIBCPP_TYPE_VIS_ONLY basic_istringstream
     : public basic_istream<_CharT, _Traits>
 {
 public:
@@ -732,7 +732,7 @@ basic_istringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
 // basic_ostringstream
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TYPE_VIS basic_ostringstream
+class _LIBCPP_TYPE_VIS_ONLY basic_ostringstream
     : public basic_ostream<_CharT, _Traits>
 {
 public:
@@ -851,7 +851,7 @@ basic_ostringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
 // basic_stringstream
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TYPE_VIS basic_stringstream
+class _LIBCPP_TYPE_VIS_ONLY basic_stringstream
     : public basic_iostream<_CharT, _Traits>
 {
 public:
diff --git a/system/include/libcxx/stack b/system/include/libcxx/stack
index b8a7f4c080900..30909c1ee3bd1 100644
--- a/system/include/libcxx/stack
+++ b/system/include/libcxx/stack
@@ -91,7 +91,7 @@ template <class T, class Container>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, class _Container> class _LIBCPP_TYPE_VIS stack;
+template <class _Tp, class _Container> class _LIBCPP_TYPE_VIS_ONLY stack;
 
 template <class _Tp, class _Container>
 _LIBCPP_INLINE_VISIBILITY
@@ -104,7 +104,7 @@ bool
 operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container = deque<_Tp> >
-class _LIBCPP_TYPE_VIS stack
+class _LIBCPP_TYPE_VIS_ONLY stack
 {
 public:
     typedef _Container                               container_type;
@@ -282,7 +282,7 @@ swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y)
 }
 
 template <class _Tp, class _Container, class _Alloc>
-struct _LIBCPP_TYPE_VIS uses_allocator<stack<_Tp, _Container>, _Alloc>
+struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<stack<_Tp, _Container>, _Alloc>
     : public uses_allocator<_Container, _Alloc>
 {
 };
diff --git a/system/include/libcxx/streambuf b/system/include/libcxx/streambuf
index 826159420ac1e..6adfc9237c7d9 100644
--- a/system/include/libcxx/streambuf
+++ b/system/include/libcxx/streambuf
@@ -119,7 +119,7 @@ protected:
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TYPE_VIS basic_streambuf
+class _LIBCPP_TYPE_VIS_ONLY basic_streambuf
 {
 public:
     // types:
@@ -553,11 +553,11 @@ basic_streambuf<_CharT, _Traits>::overflow(int_type)
     return traits_type::eof();
 }
 
-_LIBCPP_EXTERN_TEMPLATE(class basic_streambuf<char>)
-_LIBCPP_EXTERN_TEMPLATE(class basic_streambuf<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_streambuf<char>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_streambuf<wchar_t>)
 
-_LIBCPP_EXTERN_TEMPLATE(class basic_ios<char>)
-_LIBCPP_EXTERN_TEMPLATE(class basic_ios<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_ios<char>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_ios<wchar_t>)
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/system/include/libcxx/string b/system/include/libcxx/string
index 83dc53a109768..e8bd69fcabd7d 100644
--- a/system/include/libcxx/string
+++ b/system/include/libcxx/string
@@ -447,7 +447,7 @@ basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++1
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #include <cstdint>
 #endif
-#if defined(_LIBCPP_NO_EXCEPTIONS) || defined(_LIBCPP_DEBUG)
+#if defined(_LIBCPP_NO_EXCEPTIONS)
 #include <cassert>
 #endif
 
@@ -462,7 +462,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // fpos
 
 template <class _StateT>
-class _LIBCPP_TYPE_VIS fpos
+class _LIBCPP_TYPE_VIS_ONLY fpos
 {
 private:
     _StateT __st_;
@@ -499,7 +499,7 @@ bool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
 // char_traits
 
 template <class _CharT>
-struct _LIBCPP_TYPE_VIS char_traits
+struct _LIBCPP_TYPE_VIS_ONLY char_traits
 {
     typedef _CharT    char_type;
     typedef int       int_type;
@@ -605,6 +605,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _CharT*
 char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
 {
+    _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
     char_type* __r = __s1;
     for (; __n; --__n, ++__s1, ++__s2)
         assign(*__s1, *__s2);
@@ -625,7 +626,7 @@ char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)
 // char_traits<char>
 
 template <>
-struct _LIBCPP_TYPE_VIS char_traits<char>
+struct _LIBCPP_TYPE_VIS_ONLY char_traits<char>
 {
     typedef char      char_type;
     typedef int       int_type;
@@ -656,7 +657,10 @@ struct _LIBCPP_TYPE_VIS char_traits<char>
         {return (char_type*)memmove(__s1, __s2, __n);}
     _LIBCPP_INLINE_VISIBILITY
     static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n)
-        {return (char_type*)memcpy(__s1, __s2, __n);}
+        {
+            _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
+            return (char_type*)memcpy(__s1, __s2, __n);
+        }
     _LIBCPP_INLINE_VISIBILITY
     static char_type* assign(char_type* __s, size_t __n, char_type __a)
         {return (char_type*)memset(__s, to_int_type(__a), __n);}
@@ -681,7 +685,7 @@ struct _LIBCPP_TYPE_VIS char_traits<char>
 // char_traits<wchar_t>
 
 template <>
-struct _LIBCPP_TYPE_VIS char_traits<wchar_t>
+struct _LIBCPP_TYPE_VIS_ONLY char_traits<wchar_t>
 {
     typedef wchar_t   char_type;
     typedef wint_t    int_type;
@@ -713,7 +717,10 @@ struct _LIBCPP_TYPE_VIS char_traits<wchar_t>
         {return (char_type*)wmemmove(__s1, __s2, __n);}
     _LIBCPP_INLINE_VISIBILITY
     static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n)
-        {return (char_type*)wmemcpy(__s1, __s2, __n);}
+        {
+            _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
+            return (char_type*)wmemcpy(__s1, __s2, __n);
+        }
     _LIBCPP_INLINE_VISIBILITY
     static char_type* assign(char_type* __s, size_t __n, char_type __a)
         {return (char_type*)wmemset(__s, __a, __n);}
@@ -738,7 +745,7 @@ struct _LIBCPP_TYPE_VIS char_traits<wchar_t>
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 
 template <>
-struct _LIBCPP_TYPE_VIS char_traits<char16_t>
+struct _LIBCPP_TYPE_VIS_ONLY char_traits<char16_t>
 {
     typedef char16_t       char_type;
     typedef uint_least16_t int_type;
@@ -841,6 +848,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 char16_t*
 char_traits<char16_t>::copy(char_type* __s1, const char_type* __s2, size_t __n)
 {
+    _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
     char_type* __r = __s1;
     for (; __n; --__n, ++__s1, ++__s2)
         assign(*__s1, *__s2);
@@ -858,7 +866,7 @@ char_traits<char16_t>::assign(char_type* __s, size_t __n, char_type __a)
 }
 
 template <>
-struct _LIBCPP_TYPE_VIS char_traits<char32_t>
+struct _LIBCPP_TYPE_VIS_ONLY char_traits<char32_t>
 {
     typedef char32_t       char_type;
     typedef uint_least32_t int_type;
@@ -961,6 +969,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 char32_t*
 char_traits<char32_t>::copy(char_type* __s1, const char_type* __s2, size_t __n)
 {
+    _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
     char_type* __r = __s1;
     for (; __n; --__n, ++__s1, ++__s2)
         assign(*__s1, *__s2);
@@ -1003,7 +1012,7 @@ basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y);
 
 template <bool>
-class __basic_string_common
+class _LIBCPP_TYPE_VIS_ONLY __basic_string_common
 {
 protected:
     void __throw_length_error() const;
@@ -1036,7 +1045,7 @@ __basic_string_common<__b>::__throw_out_of_range() const
 #pragma warning( push )
 #pragma warning( disable: 4231 )
 #endif // _LIBCPP_MSVC
-_LIBCPP_EXTERN_TEMPLATE(class __basic_string_common<true>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS __basic_string_common<true>)
 #ifdef _LIBCPP_MSVC
 #pragma warning( pop )
 #endif // _LIBCPP_MSVC
@@ -1057,7 +1066,7 @@ struct __padding<_CharT, 1>
 #endif  // _LIBCPP_ALTERNATE_STRING_LAYOUT
 
 template<class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TYPE_VIS basic_string
+class _LIBCPP_TYPE_VIS_ONLY basic_string
     : private __basic_string_common<true>
 {
 public:
@@ -1072,13 +1081,13 @@ public:
     typedef const value_type&                            const_reference;
     typedef typename __alloc_traits::pointer             pointer;
     typedef typename __alloc_traits::const_pointer       const_pointer;
-#ifdef _LIBCPP_DEBUG
-    typedef __debug_iter<basic_string, pointer>          iterator;
-    typedef __debug_iter<basic_string, const_pointer>    const_iterator;
 
-    friend class __debug_iter<basic_string, pointer>;
-    friend class __debug_iter<basic_string, const_pointer>;
-#elif defined(_LIBCPP_RAW_ITERATORS)
+    static_assert(is_pod<value_type>::value, "Character type of basic_string must be a POD");
+    static_assert((is_same<_CharT, value_type>::value),
+                  "traits_type::char_type must be the same type as CharT");
+    static_assert((is_same<typename allocator_type::value_type, value_type>::value),
+                  "Allocator::value_type must be same type as value_type");
+#if defined(_LIBCPP_RAW_ITERATORS)
     typedef pointer                                      iterator;
     typedef const_pointer                                const_iterator;
 #else  // defined(_LIBCPP_RAW_ITERATORS)
@@ -1152,9 +1161,9 @@ private:
 
 #endif  // _LIBCPP_ALTERNATE_STRING_LAYOUT
 
-    union __lx{__long __lx; __short __lxx;};
+    union __ulx{__long __lx; __short __lxx;};
 
-    enum {__n_words = sizeof(__lx) / sizeof(size_type)};
+    enum {__n_words = sizeof(__ulx) / sizeof(size_type)};
 
     struct __raw
     {
@@ -1173,15 +1182,6 @@ private:
 
     __compressed_pair<__rep, allocator_type> __r_;
 
-#ifdef _LIBCPP_DEBUG
-
-    pair<iterator*, const_iterator*> __iterator_list_;
-
-    _LIBCPP_INLINE_VISIBILITY iterator*&       __get_iterator_list(iterator*)       {return __iterator_list_.first;}
-    _LIBCPP_INLINE_VISIBILITY const_iterator*& __get_iterator_list(const_iterator*) {return __iterator_list_.second;}
-
-#endif  // _LIBCPP_DEBUG
-
 public:
     static const size_type npos = -1;
 
@@ -1239,7 +1239,20 @@ public:
     basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
-#ifndef _LIBCPP_DEBUG
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    _LIBCPP_INLINE_VISIBILITY
+    iterator begin() _NOEXCEPT
+        {return iterator(this, __get_pointer());}
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator begin() const _NOEXCEPT
+        {return const_iterator(this, __get_pointer());}
+    _LIBCPP_INLINE_VISIBILITY
+    iterator end() _NOEXCEPT
+        {return iterator(this, __get_pointer() + size());}
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator end() const _NOEXCEPT
+        {return const_iterator(this, __get_pointer() + size());}
+#else
     _LIBCPP_INLINE_VISIBILITY
     iterator begin() _NOEXCEPT
         {return iterator(__get_pointer());}
@@ -1252,12 +1265,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     const_iterator end() const _NOEXCEPT
         {return const_iterator(__get_pointer() + size());}
-#else  // _LIBCPP_DEBUG
-    _LIBCPP_INLINE_VISIBILITY iterator       begin()       {return iterator(this, __get_pointer());}
-    _LIBCPP_INLINE_VISIBILITY const_iterator begin() const {return const_iterator(this, data());}
-    _LIBCPP_INLINE_VISIBILITY iterator       end()         {return iterator(this, __get_pointer() + size());}
-    _LIBCPP_INLINE_VISIBILITY const_iterator end() const   {return const_iterator(this, data() + size());}
-#endif  // _LIBCPP_DEBUG
+#endif  // _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_INLINE_VISIBILITY
     reverse_iterator rbegin() _NOEXCEPT
         {return reverse_iterator(end());}
@@ -1520,6 +1528,15 @@ public:
     bool __is_long() const _NOEXCEPT
         {return bool(__r_.first().__s.__size_ & __short_mask);}
 
+#if _LIBCPP_DEBUG_LEVEL >= 2
+
+    bool __dereferenceable(const const_iterator* __i) const;
+    bool __decrementable(const const_iterator* __i) const;
+    bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
+    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
+
+#endif  // _LIBCPP_DEBUG_LEVEL >= 2
+
 private:
     _LIBCPP_INLINE_VISIBILITY
     allocator_type& __alloc() _NOEXCEPT
@@ -1615,13 +1632,13 @@ private:
 
     template <size_type __a> static
         _LIBCPP_INLINE_VISIBILITY
-        size_type __align(size_type __s) _NOEXCEPT
+        size_type __align_it(size_type __s) _NOEXCEPT
             {return __s + (__a-1) & ~(__a-1);}
     enum {__alignment = 16};
     static _LIBCPP_INLINE_VISIBILITY
     size_type __recommend(size_type __s) _NOEXCEPT
         {return (__s < __min_cap ? __min_cap :
-                 __align<sizeof(value_type) < __alignment ?
+                 __align_it<sizeof(value_type) < __alignment ?
                             __alignment/sizeof(value_type) : 1 > (__s+1)) - 1;}
 
     void __init(const value_type* __s, size_type __sz, size_type __reserve);
@@ -1732,75 +1749,64 @@ private:
 };
 
 template <class _CharT, class _Traits, class _Allocator>
-#ifndef _LIBCPP_DEBUG
-_LIBCPP_INLINE_VISIBILITY inline
-#endif
+inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::__invalidate_all_iterators()
 {
-#ifdef _LIBCPP_DEBUG
-    iterator::__remove_all(this);
-    const_iterator::__remove_all(this);
-#endif  // _LIBCPP_DEBUG
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__invalidate_all(this);
+#endif  // _LIBCPP_DEBUG_LEVEL >= 2
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-#ifndef _LIBCPP_DEBUG
-_LIBCPP_INLINE_VISIBILITY inline
-#endif
+inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type
-#ifdef _LIBCPP_DEBUG
+#if _LIBCPP_DEBUG_LEVEL >= 2
                                                                         __pos
 #endif
                                                                       )
 {
-#ifdef _LIBCPP_DEBUG
-    const_iterator __beg = begin();
-    if (__iterator_list_.first)
-    {
-        for (iterator* __p = __iterator_list_.first; __p;)
-        {
-            if (*__p - __beg > static_cast<difference_type>(__pos))
-            {
-                iterator* __n = __p;
-                __p = __p->__next;
-                __n->__remove_owner();
-            }
-            else
-                __p = __p->__next;
-        }
-    }
-    if (__iterator_list_.second)
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __c_node* __c = __get_db()->__find_c_and_lock(this);
+    if (__c)
     {
-        for (const_iterator* __p = __iterator_list_.second; __p;)
+        const_pointer __new_last = __get_pointer() + __pos;
+        for (__i_node** __p = __c->end_; __p != __c->beg_; )
         {
-            if (*__p - __beg > static_cast<difference_type>(__pos))
+            --__p;
+            const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_);
+            if (__i->base() > __new_last)
             {
-                const_iterator* __n = __p;
-                __p = __p->__next;
-                __n->__remove_owner();
+                (*__p)->__c_ = nullptr;
+                if (--__c->end_ != __p)
+                    memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*));
             }
-            else
-                __p = __p->__next;
         }
+        __get_db()->unlock();
     }
-#endif  // _LIBCPP_DEBUG
+#endif  // _LIBCPP_DEBUG_LEVEL >= 2
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
 {
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
     __zero();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a)
     : __r_(__a)
 {
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
     __zero();
 }
 
@@ -1853,45 +1859,49 @@ basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_ty
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const value_type* __s)
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
     __init(__s, traits_type::length(__s));
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const value_type* __s, const allocator_type& __a)
     : __r_(__a)
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
     __init(__s, traits_type::length(__s));
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const value_type* __s, size_type __n)
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr");
     __init(__s, __n);
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const value_type* __s, size_type __n, const allocator_type& __a)
     : __r_(__a)
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
     __init(__s, __n);
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -1902,6 +1912,9 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __st
         __r_.first().__r = __str.__r_.first().__r;
     else
         __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -1912,24 +1925,29 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __st
         __r_.first().__r = __str.__r_.first().__r;
     else
         __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
     : __r_(_VSTD::move(__str.__r_))
 {
     __str.__zero();
-#ifdef _LIBCPP_DEBUG
-    __str.__invalidate_all_iterators();
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+    if (__is_long())
+        __get_db()->swap(this, &__str);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
     : __r_(__a)
 {
@@ -1938,8 +1956,10 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, co
     else
         __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
     __str.__zero();
-#ifdef _LIBCPP_DEBUG
-    __str.__invalidate_all_iterators();
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+    if (__is_long())
+        __get_db()->swap(this, &__str);
 #endif
 }
 
@@ -1970,18 +1990,24 @@ basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, value_type __c)
 {
     __init(__n, __c);
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, value_type __c, const allocator_type& __a)
     : __r_(__a)
 {
     __init(__n, __c);
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -1993,6 +2019,9 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __st
     if (__pos > __str_sz)
         this->__throw_out_of_range();
     __init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos));
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2056,37 +2085,49 @@ basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _For
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last)
 {
     __init(__first, __last);
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last,
                                                         const allocator_type& __a)
     : __r_(__a)
 {
     __init(__first, __last);
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
 }
 
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(initializer_list<value_type> __il)
 {
     __init(__il.begin(), __il.end());
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(initializer_list<value_type> __il, const allocator_type& __a)
     : __r_(__a)
 {
     __init(__il.begin(), __il.end());
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
 }
 
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
@@ -2094,7 +2135,9 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(initializer_list<value_t
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::~basic_string()
 {
-    __invalidate_all_iterators();
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__erase_c(this);
+#endif
     if (__is_long())
         __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
 }
@@ -2138,7 +2181,7 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_t
                                                      size_type __n_copy,  size_type __n_del,     size_type __n_add)
 {
     size_type __ms = max_size();
-    if (__delta_cap > __ms - __old_cap - 1)
+    if (__delta_cap > __ms - __old_cap)
         this->__throw_length_error();
     pointer __old_p = __get_pointer();
     size_type __cap = __old_cap < __ms / 2 - __alignment ?
@@ -2166,9 +2209,7 @@ template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n)
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign recieved nullptr");
     size_type __cap = capacity();
     if (__cap >= __n)
     {
@@ -2241,7 +2282,7 @@ basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type)
 {
@@ -2252,7 +2293,7 @@ basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, fa
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
     _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
@@ -2265,7 +2306,7 @@ basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, tr
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str)
     _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
@@ -2321,7 +2362,7 @@ basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _For
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str)
 {
@@ -2342,9 +2383,7 @@ template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s)
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "string::assign recieved nullptr");
     return assign(__s, traits_type::length(__s));
 }
 
@@ -2354,9 +2393,7 @@ template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n)
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::append recieved nullptr");
     size_type __cap = capacity();
     size_type __sz = size();
     if (__cap - __sz >= __n)
@@ -2472,7 +2509,7 @@ basic_string<_CharT, _Traits, _Allocator>::append(_ForwardIterator __first, _For
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str)
 {
@@ -2493,9 +2530,7 @@ template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s)
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "string::append recieved nullptr");
     return append(__s, traits_type::length(__s));
 }
 
@@ -2505,9 +2540,7 @@ template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n)
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::insert recieved nullptr");
     size_type __sz = size();
     if (__pos > __sz)
         this->__throw_out_of_range();
@@ -2576,13 +2609,22 @@ typename enable_if
 >::type
 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last)
 {
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
+        "string::insert(iterator, range) called with an iterator not"
+        " referring to this string");
+#endif
     size_type __old_sz = size();
     difference_type __ip = __pos - begin();
     for (; __first != __last; ++__first)
         push_back(*__first);
     pointer __p = __get_pointer();
     _VSTD::rotate(__p + __ip, __p + __old_sz, __p + size());
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    return iterator(this, __p + __ip);
+#else
     return iterator(__p + __ip);
+#endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2594,6 +2636,11 @@ typename enable_if
 >::type
 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last)
 {
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
+        "string::insert(iterator, range) called with an iterator not"
+        " referring to this string");
+#endif
     size_type __ip = static_cast<size_type>(__pos - begin());
     size_type __sz = size();
     size_type __cap = capacity();
@@ -2623,7 +2670,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _Forward
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str)
 {
@@ -2645,9 +2692,7 @@ template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s)
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "string::insert recieved nullptr");
     return insert(__pos, __s, traits_type::length(__s));
 }
 
@@ -2678,10 +2723,15 @@ basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_ty
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::iterator
 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, size_type __n, value_type __c)
 {
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
+        "string::insert(iterator, n, value) called with an iterator not"
+        " referring to this string");
+#endif
     difference_type __p = __pos - begin();
     insert(static_cast<size_type>(__p), __n, __c);
     return begin() + __p;
@@ -2693,9 +2743,7 @@ template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2)
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace recieved nullptr");
     size_type __sz = size();
     if (__pos > __sz)
         this->__throw_out_of_range();
@@ -2805,7 +2853,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_it
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str)
 {
@@ -2827,14 +2875,12 @@ template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s)
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "string::replace recieved nullptr");
     return replace(__pos, __n1, __s, traits_type::length(__s));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const basic_string& __str)
 {
@@ -2843,7 +2889,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_it
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n)
 {
@@ -2851,7 +2897,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_it
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s)
 {
@@ -2859,7 +2905,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_it
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c)
 {
@@ -2891,10 +2937,17 @@ basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, size_type __n)
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::iterator
 basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos)
 {
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
+        "string::erase(iterator) called with an iterator not"
+        " referring to this string");
+#endif
+    _LIBCPP_ASSERT(__pos != end(),
+        "string::erase(iterator) called with a non-dereferenceable iterator");
     iterator __b = begin();
     size_type __r = static_cast<size_type>(__pos - __b);
     erase(__r, 1);
@@ -2902,10 +2955,16 @@ basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos)
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::iterator
 basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last)
 {
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this,
+        "string::erase(iterator,  iterator) called with an iterator not"
+        " referring to this string");
+#endif
+    _LIBCPP_ASSERT(__first <= __last, "string::erase(first, last) called with invalid range");
     iterator __b = begin();
     size_type __r = static_cast<size_type>(__first - __b);
     erase(__r, static_cast<size_type>(__last - __first));
@@ -2913,13 +2972,11 @@ basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_i
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::pop_back()
 {
-#ifdef _LIBCPP_DEBUG
-    assert(!empty());
-#endif
+    _LIBCPP_ASSERT(!empty(), "string::pop_back(): string is already empty");
     size_type __sz;
     if (__is_long())
     {
@@ -2937,7 +2994,7 @@ basic_string<_CharT, _Traits, _Allocator>::pop_back()
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT
 {
@@ -2955,7 +3012,7 @@ basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::__erase_to_end(size_type __pos)
 {
@@ -2984,15 +3041,15 @@ basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c)
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::max_size() const _NOEXCEPT
 {
     size_type __m = __alloc_traits::max_size(__alloc());
 #if _LIBCPP_BIG_ENDIAN
-    return (__m <= ~__long_mask ? __m : __m/2) - 1;
+    return (__m <= ~__long_mask ? __m : __m/2) - __alignment;
 #else
-    return __m - 1;
+    return __m - __alignment;
 #endif
 }
 
@@ -3060,24 +3117,20 @@ basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __res_arg)
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::const_reference
 basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) const
 {
-#ifdef __LIBCPP_DEBUG
-    assert(__pos <= size());
-#endif
+    _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
     return *(data() + __pos);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::reference
 basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos)
 {
-#ifdef __LIBCPP_DEBUG
-    assert(__pos < size());
-#endif
+    _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
     return *(__get_pointer() + __pos);
 }
 
@@ -3100,46 +3153,38 @@ basic_string<_CharT, _Traits, _Allocator>::at(size_type __n)
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::reference
 basic_string<_CharT, _Traits, _Allocator>::front()
 {
-#ifdef _LIBCPP_DEBUG
-    assert(!empty());
-#endif
+    _LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
     return *__get_pointer();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::const_reference
 basic_string<_CharT, _Traits, _Allocator>::front() const
 {
-#ifdef _LIBCPP_DEBUG
-    assert(!empty());
-#endif
+    _LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
     return *data();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::reference
 basic_string<_CharT, _Traits, _Allocator>::back()
 {
-#ifdef _LIBCPP_DEBUG
-    assert(!empty());
-#endif
+    _LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
     return *(__get_pointer() + size() - 1);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::const_reference
 basic_string<_CharT, _Traits, _Allocator>::back() const
 {
-#ifdef _LIBCPP_DEBUG
-    assert(!empty());
-#endif
+    _LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
     return *(data() + size() - 1);
 }
 
@@ -3156,7 +3201,7 @@ basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n,
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n) const
 {
@@ -3164,18 +3209,21 @@ basic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                    __is_nothrow_swappable<allocator_type>::value)
 {
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    if (!__is_long())
+        __get_db()->__invalidate_all(this);
+    if (!__str.__is_long())
+        __get_db()->__invalidate_all(&__str);
+    __get_db()->swap(this, &__str);
+#endif
     _VSTD::swap(__r_.first(), __str.__r_.first());
     __swap_alloc(__alloc(), __str.__alloc());
-#ifdef _LIBCPP_DEBUG
-    __invalidate_all_iterators();
-    __str.__invalidate_all_iterators();
-#endif  // _LIBCPP_DEBUG
 }
 
 // find
@@ -3195,9 +3243,7 @@ basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
                                                 size_type __pos,
                                                 size_type __n) const _NOEXCEPT
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find(): recieved nullptr");
     size_type __sz = size();
     if (__pos > __sz || __sz - __pos < __n)
         return npos;
@@ -3212,7 +3258,7 @@ basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str,
                                                 size_type __pos) const _NOEXCEPT
@@ -3221,14 +3267,12 @@ basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
                                                 size_type __pos) const _NOEXCEPT
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "string::find(): recieved nullptr");
     return find(__s, __pos, traits_type::length(__s));
 }
 
@@ -3255,9 +3299,7 @@ basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
                                                  size_type __pos,
                                                  size_type __n) const _NOEXCEPT
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::rfind(): recieved nullptr");
     size_type __sz = size();
     __pos = _VSTD::min(__pos, __sz);
     if (__n < __sz - __pos)
@@ -3273,7 +3315,7 @@ basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str,
                                                  size_type __pos) const _NOEXCEPT
@@ -3282,14 +3324,12 @@ basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
                                                  size_type __pos) const _NOEXCEPT
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "string::rfind(): recieved nullptr");
     return rfind(__s, __pos, traits_type::length(__s));
 }
 
@@ -3323,9 +3363,7 @@ basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
                                                          size_type __pos,
                                                          size_type __n) const _NOEXCEPT
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_of(): recieved nullptr");
     size_type __sz = size();
     if (__pos >= __sz || __n == 0)
         return npos;
@@ -3338,7 +3376,7 @@ basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str,
                                                          size_type __pos) const _NOEXCEPT
@@ -3347,19 +3385,17 @@ basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __s
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
                                                          size_type __pos) const _NOEXCEPT
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "string::find_first_of(): recieved nullptr");
     return find_first_of(__s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c,
                                                          size_type __pos) const _NOEXCEPT
@@ -3375,9 +3411,7 @@ basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
                                                         size_type __pos,
                                                         size_type __n) const _NOEXCEPT
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_of(): recieved nullptr");
     if (__n != 0)
     {
         size_type __sz = size();
@@ -3397,7 +3431,7 @@ basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str,
                                                         size_type __pos) const _NOEXCEPT
@@ -3406,19 +3440,17 @@ basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __st
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
                                                         size_type __pos) const _NOEXCEPT
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "string::find_last_of(): recieved nullptr");
     return find_last_of(__s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c,
                                                         size_type __pos) const _NOEXCEPT
@@ -3434,9 +3466,7 @@ basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* _
                                                              size_type __pos,
                                                              size_type __n) const _NOEXCEPT
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_not_of(): recieved nullptr");
     size_type __sz = size();
     if (__pos < __sz)
     {
@@ -3450,7 +3480,7 @@ basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* _
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str,
                                                              size_type __pos) const _NOEXCEPT
@@ -3459,19 +3489,17 @@ basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string&
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
                                                              size_type __pos) const _NOEXCEPT
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "string::find_first_not_of(): recieved nullptr");
     return find_first_not_of(__s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c,
                                                              size_type __pos) const _NOEXCEPT
@@ -3496,9 +3524,7 @@ basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __
                                                             size_type __pos,
                                                             size_type __n) const _NOEXCEPT
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_not_of(): recieved nullptr");
     size_type __sz = size();
     if (__pos < __sz)
         ++__pos;
@@ -3512,7 +3538,7 @@ basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str,
                                                             size_type __pos) const _NOEXCEPT
@@ -3521,19 +3547,17 @@ basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string&
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
                                                             size_type __pos) const _NOEXCEPT
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "string::find_last_not_of(): recieved nullptr");
     return find_last_not_of(__s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c,
                                                             size_type __pos) const _NOEXCEPT
@@ -3553,7 +3577,7 @@ basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c,
 // compare
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT
 {
@@ -3571,7 +3595,7 @@ basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) co
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n1,
@@ -3599,9 +3623,7 @@ template <class _CharT, class _Traits, class _Allocator>
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "string::compare(): recieved nullptr");
     return compare(0, npos, __s, traits_type::length(__s));
 }
 
@@ -3611,9 +3633,7 @@ basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n1,
                                                    const value_type* __s) const
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__s != nullptr, "string::compare(): recieved nullptr");
     return compare(__pos1, __n1, __s, traits_type::length(__s));
 }
 
@@ -3624,9 +3644,7 @@ basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    const value_type* __s,
                                                    size_type __n2) const
 {
-#ifdef _LIBCPP_DEBUG
-    assert(__s != 0);
-#endif
+    _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::compare(): recieved nullptr");
     size_type __sz = size();
     if (__pos1 > __sz || __n2 == npos)
         this->__throw_out_of_range();
@@ -3645,7 +3663,7 @@ basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
 // __invariants
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 basic_string<_CharT, _Traits, _Allocator>::__invariants() const
 {
@@ -3663,7 +3681,7 @@ basic_string<_CharT, _Traits, _Allocator>::__invariants() const
 // operator==
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -3675,7 +3693,7 @@ operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
 }
 
 template<class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
            const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT
@@ -3694,7 +3712,7 @@ operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -3703,7 +3721,7 @@ operator==(const _CharT* __lhs,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
@@ -3714,7 +3732,7 @@ operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
 // operator!=
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -3723,7 +3741,7 @@ operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -3732,7 +3750,7 @@ operator!=(const _CharT* __lhs,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
@@ -3743,7 +3761,7 @@ operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
 // operator<
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -3752,7 +3770,7 @@ operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
@@ -3761,7 +3779,7 @@ operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -3772,7 +3790,7 @@ operator< (const _CharT* __lhs,
 // operator>
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -3781,7 +3799,7 @@ operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
@@ -3790,7 +3808,7 @@ operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator> (const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -3801,7 +3819,7 @@ operator> (const _CharT* __lhs,
 // operator<=
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -3810,7 +3828,7 @@ operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
@@ -3819,7 +3837,7 @@ operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -3830,7 +3848,7 @@ operator<=(const _CharT* __lhs,
 // operator>=
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -3839,7 +3857,7 @@ operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
@@ -3848,7 +3866,7 @@ operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -3920,7 +3938,7 @@ operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs)
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>
 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs)
 {
@@ -3928,7 +3946,7 @@ operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
 {
@@ -3936,7 +3954,7 @@ operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>
 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
 {
@@ -3944,7 +3962,7 @@ operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs)
 {
@@ -3952,7 +3970,7 @@ operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs)
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>
 operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs)
 {
@@ -3961,7 +3979,7 @@ operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs)
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>
 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs)
 {
@@ -3969,7 +3987,7 @@ operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>
 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs)
 {
@@ -3982,7 +4000,7 @@ operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs)
 // swap
 
 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(basic_string<_CharT, _Traits, _Allocator>& __lhs,
      basic_string<_CharT, _Traits, _Allocator>& __rhs)
@@ -3998,45 +4016,45 @@ typedef basic_string<char32_t> u32string;
 
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
 
-int                stoi  (const string& __str, size_t* __idx = 0, int __base = 10);
-long               stol  (const string& __str, size_t* __idx = 0, int __base = 10);
-unsigned long      stoul (const string& __str, size_t* __idx = 0, int __base = 10);
-long long          stoll (const string& __str, size_t* __idx = 0, int __base = 10);
-unsigned long long stoull(const string& __str, size_t* __idx = 0, int __base = 10);
-
-float       stof (const string& __str, size_t* __idx = 0);
-double      stod (const string& __str, size_t* __idx = 0);
-long double stold(const string& __str, size_t* __idx = 0);
-
-string to_string(int __val);
-string to_string(unsigned __val);
-string to_string(long __val);
-string to_string(unsigned long __val);
-string to_string(long long __val);
-string to_string(unsigned long long __val);
-string to_string(float __val);
-string to_string(double __val);
-string to_string(long double __val);
-
-int                stoi  (const wstring& __str, size_t* __idx = 0, int __base = 10);
-long               stol  (const wstring& __str, size_t* __idx = 0, int __base = 10);
-unsigned long      stoul (const wstring& __str, size_t* __idx = 0, int __base = 10);
-long long          stoll (const wstring& __str, size_t* __idx = 0, int __base = 10);
-unsigned long long stoull(const wstring& __str, size_t* __idx = 0, int __base = 10);
-
-float       stof (const wstring& __str, size_t* __idx = 0);
-double      stod (const wstring& __str, size_t* __idx = 0);
-long double stold(const wstring& __str, size_t* __idx = 0);
-
-wstring to_wstring(int __val);
-wstring to_wstring(unsigned __val);
-wstring to_wstring(long __val);
-wstring to_wstring(unsigned long __val);
-wstring to_wstring(long long __val);
-wstring to_wstring(unsigned long long __val);
-wstring to_wstring(float __val);
-wstring to_wstring(double __val);
-wstring to_wstring(long double __val);
+_LIBCPP_FUNC_VIS int                stoi  (const string& __str, size_t* __idx = 0, int __base = 10);
+_LIBCPP_FUNC_VIS long               stol  (const string& __str, size_t* __idx = 0, int __base = 10);
+_LIBCPP_FUNC_VIS unsigned long      stoul (const string& __str, size_t* __idx = 0, int __base = 10);
+_LIBCPP_FUNC_VIS long long          stoll (const string& __str, size_t* __idx = 0, int __base = 10);
+_LIBCPP_FUNC_VIS unsigned long long stoull(const string& __str, size_t* __idx = 0, int __base = 10);
+
+_LIBCPP_FUNC_VIS float       stof (const string& __str, size_t* __idx = 0);
+_LIBCPP_FUNC_VIS double      stod (const string& __str, size_t* __idx = 0);
+_LIBCPP_FUNC_VIS long double stold(const string& __str, size_t* __idx = 0);
+
+_LIBCPP_FUNC_VIS string to_string(int __val);
+_LIBCPP_FUNC_VIS string to_string(unsigned __val);
+_LIBCPP_FUNC_VIS string to_string(long __val);
+_LIBCPP_FUNC_VIS string to_string(unsigned long __val);
+_LIBCPP_FUNC_VIS string to_string(long long __val);
+_LIBCPP_FUNC_VIS string to_string(unsigned long long __val);
+_LIBCPP_FUNC_VIS string to_string(float __val);
+_LIBCPP_FUNC_VIS string to_string(double __val);
+_LIBCPP_FUNC_VIS string to_string(long double __val);
+
+_LIBCPP_FUNC_VIS int                stoi  (const wstring& __str, size_t* __idx = 0, int __base = 10);
+_LIBCPP_FUNC_VIS long               stol  (const wstring& __str, size_t* __idx = 0, int __base = 10);
+_LIBCPP_FUNC_VIS unsigned long      stoul (const wstring& __str, size_t* __idx = 0, int __base = 10);
+_LIBCPP_FUNC_VIS long long          stoll (const wstring& __str, size_t* __idx = 0, int __base = 10);
+_LIBCPP_FUNC_VIS unsigned long long stoull(const wstring& __str, size_t* __idx = 0, int __base = 10);
+
+_LIBCPP_FUNC_VIS float       stof (const wstring& __str, size_t* __idx = 0);
+_LIBCPP_FUNC_VIS double      stod (const wstring& __str, size_t* __idx = 0);
+_LIBCPP_FUNC_VIS long double stold(const wstring& __str, size_t* __idx = 0);
+
+_LIBCPP_FUNC_VIS wstring to_wstring(int __val);
+_LIBCPP_FUNC_VIS wstring to_wstring(unsigned __val);
+_LIBCPP_FUNC_VIS wstring to_wstring(long __val);
+_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long __val);
+_LIBCPP_FUNC_VIS wstring to_wstring(long long __val);
+_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long long __val);
+_LIBCPP_FUNC_VIS wstring to_wstring(float __val);
+_LIBCPP_FUNC_VIS wstring to_wstring(double __val);
+_LIBCPP_FUNC_VIS wstring to_wstring(long double __val);
 
 template<class _CharT, class _Traits, class _Allocator>
     const typename basic_string<_CharT, _Traits, _Allocator>::size_type
@@ -4050,7 +4068,7 @@ size_t _LIBCPP_INLINE_VISIBILITY __do_string_hash(_Ptr __p, _Ptr __e)
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-struct _LIBCPP_TYPE_VIS hash<basic_string<_CharT, _Traits, _Allocator> >
+struct _LIBCPP_TYPE_VIS_ONLY hash<basic_string<_CharT, _Traits, _Allocator> >
     : public unary_function<basic_string<_CharT, _Traits, _Allocator>, size_t>
 {
     size_t
@@ -4102,12 +4120,45 @@ getline(basic_istream<_CharT, _Traits>&& __is,
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
+#if _LIBCPP_DEBUG_LEVEL >= 2
+
+template<class _CharT, class _Traits, class _Allocator>
+bool
+basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const
+{
+    return this->data() <= _VSTD::__to_raw_pointer(__i->base()) &&
+           _VSTD::__to_raw_pointer(__i->base()) < this->data() + this->size();
+}
+
+template<class _CharT, class _Traits, class _Allocator>
+bool
+basic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const
+{
+    return this->data() < _VSTD::__to_raw_pointer(__i->base()) &&
+           _VSTD::__to_raw_pointer(__i->base()) <= this->data() + this->size();
+}
+
+template<class _CharT, class _Traits, class _Allocator>
+bool
+basic_string<_CharT, _Traits, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const
+{
+    const value_type* __p = _VSTD::__to_raw_pointer(__i->base()) + __n;
+    return this->data() <= __p && __p <= this->data() + this->size();
+}
+
+template<class _CharT, class _Traits, class _Allocator>
+bool
+basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
+{
+    const value_type* __p = _VSTD::__to_raw_pointer(__i->base()) + __n;
+    return this->data() <= __p && __p < this->data() + this->size();
+}
+
+#endif  // _LIBCPP_DEBUG_LEVEL >= 2
+
 #if _LIBCPP_STD_VER > 11 
 // Literal suffixes for basic_string [basic.string.literals]
-// inline // Deviation from N3690.
-//    We believe the inline to be a defect and have submitted an LWG issue.
-//    An LWG issue number has not yet been assigned.
-namespace literals
+inline namespace literals
 {
   inline namespace string_literals
   {
@@ -4138,12 +4189,9 @@ namespace literals
 }
 #endif
 
-_LIBCPP_EXTERN_TEMPLATE(class basic_string<char>)
-_LIBCPP_EXTERN_TEMPLATE(class basic_string<wchar_t>)
-
-extern template
-    string
-    operator+<char, char_traits<char>, allocator<char> >(char const*, string const&);
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_string<char>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_string<wchar_t>)
+_LIBCPP_EXTERN_TEMPLATE(string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&))
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/system/include/libcxx/support/ibm/limits.h b/system/include/libcxx/support/ibm/limits.h
new file mode 100644
index 0000000000000..efdb359659653
--- /dev/null
+++ b/system/include/libcxx/support/ibm/limits.h
@@ -0,0 +1,99 @@
+// -*- C++ -*-
+//===--------------------- support/ibm/limits.h ---------------------------===//
+//
+//                     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_SUPPORT_IBM_LIMITS_H
+#define _LIBCPP_SUPPORT_IBM_LIMITS_H
+
+#if !defined(_AIX) // Linux
+#include <math.h> // for HUGE_VAL, HUGE_VALF, HUGE_VALL, and NAN
+
+static const unsigned int _QNAN_F = 0x7fc00000;
+#define NANF (*((float *)(&_QNAN_F)))
+static const unsigned int _QNAN_LDBL128[4] = {0x7ff80000, 0x0, 0x0, 0x0};
+#define NANL (*((long double *)(&_QNAN_LDBL128)))
+static const unsigned int _SNAN_F= 0x7f855555;
+#define NANSF (*((float *)(&_SNAN_F)))
+static const unsigned int _SNAN_D[2] = {0x7ff55555, 0x55555555};
+#define NANS (*((double *)(&_SNAN_D)))
+static const unsigned int _SNAN_LDBL128[4] = {0x7ff55555, 0x55555555, 0x0, 0x0};
+#define NANSL (*((long double *)(&_SNAN_LDBL128)))
+
+#define __builtin_huge_val()     HUGE_VAL
+#define __builtin_huge_valf()    HUGE_VALF
+#define __builtin_huge_vall()    HUGE_VALL
+#define __builtin_nan(__dummy)   NAN
+#define __builtin_nanf(__dummy)  NANF
+#define __builtin_nanl(__dummy)  NANL
+#define __builtin_nans(__dummy)  NANS
+#define __builtin_nansf(__dummy) NANSF
+#define __builtin_nansl(__dummy) NANSL
+
+#else
+
+#include <math.h>
+#include <float.h> // limit constants
+
+#define __builtin_huge_val()     HUGE_VAL  //0x7ff0000000000000
+#define __builtin_huge_valf()    HUGE_VALF //0x7f800000
+#define __builtin_huge_vall()    HUGE_VALL //0x7ff0000000000000
+#define __builtin_nan(__dummy)   nan(__dummy) //0x7ff8000000000000
+#define __builtin_nanf(__dummy)  nanf(__dummy) // 0x7ff80000
+#define __builtin_nanl(__dummy)  nanl(__dummy) //0x7ff8000000000000
+#define __builtin_nans(__dummy)  DBL_SNAN //0x7ff5555555555555
+#define __builtin_nansf(__dummy) FLT_SNAN //0x7f855555
+#define __builtin_nansl(__dummy) DBL_SNAN //0x7ff5555555555555
+
+#define __FLT_MANT_DIG__   FLT_MANT_DIG
+#define __FLT_DIG__        FLT_DIG
+#define __FLT_RADIX__      FLT_RADIX
+#define __FLT_MIN_EXP__    FLT_MIN_EXP
+#define __FLT_MIN_10_EXP__ FLT_MIN_10_EXP
+#define __FLT_MAX_EXP__    FLT_MAX_EXP
+#define __FLT_MAX_10_EXP__ FLT_MAX_10_EXP
+#define __FLT_MIN__        FLT_MIN
+#define __FLT_MAX__        FLT_MAX
+#define __FLT_EPSILON__    FLT_EPSILON
+// predefined by XLC on LoP
+#define __FLT_DENORM_MIN__ 1.40129846e-45F
+
+#define __DBL_MANT_DIG__   DBL_MANT_DIG
+#define __DBL_DIG__        DBL_DIG
+#define __DBL_MIN_EXP__    DBL_MIN_EXP
+#define __DBL_MIN_10_EXP__ DBL_MIN_10_EXP
+#define __DBL_MAX_EXP__    DBL_MAX_EXP
+#define __DBL_MAX_10_EXP__ DBL_MAX_10_EXP
+#define __DBL_MIN__        DBL_MIN
+#define __DBL_MAX__        DBL_MAX
+#define __DBL_EPSILON__    DBL_EPSILON
+// predefined by XLC on LoP
+#define __DBL_DENORM_MIN__ 4.9406564584124654e-324
+
+#define __LDBL_MANT_DIG__   LDBL_MANT_DIG
+#define __LDBL_DIG__        LDBL_DIG
+#define __LDBL_MIN_EXP__    LDBL_MIN_EXP
+#define __LDBL_MIN_10_EXP__ LDBL_MIN_10_EXP
+#define __LDBL_MAX_EXP__    LDBL_MAX_EXP
+#define __LDBL_MAX_10_EXP__ LDBL_MAX_10_EXP
+#define __LDBL_MIN__        LDBL_MIN
+#define __LDBL_MAX__        LDBL_MAX
+#define __LDBL_EPSILON__    LDBL_EPSILON
+// predefined by XLC on LoP
+#if __LONGDOUBLE128
+#define __LDBL_DENORM_MIN__ 4.94065645841246544176568792868221e-324L
+#else
+#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324L
+#endif
+
+// predefined by XLC on LoP
+#define __CHAR_BIT__    8
+
+#endif // _AIX
+
+#endif // _LIBCPP_SUPPORT_IBM_LIMITS_H
diff --git a/system/include/libcxx/support/ibm/support.h b/system/include/libcxx/support/ibm/support.h
new file mode 100644
index 0000000000000..3effbaed16081
--- /dev/null
+++ b/system/include/libcxx/support/ibm/support.h
@@ -0,0 +1,54 @@
+// -*- C++ -*-
+//===----------------------- support/ibm/support.h ----------------------===//
+//
+//                     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_SUPPORT_IBM_SUPPORT_H
+#define _LIBCPP_SUPPORT_IBM_SUPPORT_H
+
+extern "builtin" int __popcnt4(unsigned int);
+extern "builtin" int __popcnt8(unsigned long long);
+extern "builtin" unsigned int __cnttz4(unsigned int);
+extern "builtin" unsigned int __cnttz8(unsigned long long);
+extern "builtin" unsigned int __cntlz4(unsigned long long);
+extern "builtin" unsigned int __cntlz8(unsigned long long);
+
+// Builtin functions for counting population
+#define __builtin_popcount(x) __popcnt4(x)
+#define __builtin_popcountll(x) __popcnt8(x)
+#if defined(__64BIT__)
+#define __builtin_popcountl(x) __builtin_popcountll(x)
+#else
+#define __builtin_popcountl(x) __builtin_popcount(x)
+#endif
+
+// Builtin functions for counting trailing zeros
+#define __builtin_ctz(x) __cnttz4(x)
+#define __builtin_ctzll(x) __cnttz8(x)
+#if defined(__64BIT__)
+#define __builtin_ctzl(x) __builtin_ctzll(x)
+#else
+#define __builtin_ctzl(x) __builtin_ctz(x)
+#endif
+
+// Builtin functions for counting leading zeros
+#define __builtin_clz(x) __cntlz4(x)
+#define __builtin_clzll(x) __cntlz8(x)
+#if defined(__64BIT__)
+#define __builtin_clzl(x) __builtin_clzll(x)
+#else
+#define __builtin_clzl(x) __builtin_clz(x)
+#endif
+
+#if defined(__64BIT__)
+#define __SIZE_WIDTH__ 64
+#else
+#define __SIZE_WIDTH__ 32
+#endif
+
+#endif // _LIBCPP_SUPPORT_IBM_SUPPORT_H
diff --git a/system/include/libcxx/support/ibm/xlocale.h b/system/include/libcxx/support/ibm/xlocale.h
new file mode 100644
index 0000000000000..8d99a5c7d34d5
--- /dev/null
+++ b/system/include/libcxx/support/ibm/xlocale.h
@@ -0,0 +1,326 @@
+// -*- C++ -*-
+//===--------------------- support/ibm/xlocale.h -------------------===//
+//
+//                     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_SUPPORT_IBM_XLOCALE_H
+#define _LIBCPP_SUPPORT_IBM_XLOCALE_H
+
+#if defined(_AIX)
+#include "cstdlib"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(_AIX71)
+// AIX 7.1 and higher has these definitions.  Definitions and stubs
+// are provied here as a temporary workaround on AIX 6.1.
+
+#define LC_COLLATE_MASK         1
+#define LC_CTYPE_MASK           2
+#define LC_MESSAGES_MASK        4
+#define LC_MONETARY_MASK        8
+#define LC_NUMERIC_MASK         16
+#define LC_TIME_MASK            32
+#define LC_ALL_MASK             (LC_COLLATE_MASK | LC_CTYPE_MASK | \
+                                 LC_MESSAGES_MASK | LC_MONETARY_MASK |\
+                                 LC_NUMERIC_MASK | LC_TIME_MASK)
+
+typedef void* locale_t;
+
+// The following are stubs.  They are not supported on AIX 6.1.
+static inline
+locale_t newlocale(int category_mask, const char *locale, locale_t base)
+{
+  _LC_locale_t *newloc, *loc;
+  if ((loc = (_LC_locale_t *)__xopen_locale(locale)) == NULL)
+  {
+    errno = EINVAL;
+    return (locale_t)0;
+  }
+  if ((newloc = (_LC_locale_t *)calloc(1, sizeof(_LC_locale_t))) == NULL)
+  {
+    errno = ENOMEM;
+    return (locale_t)0;
+  }
+  if (!base)
+    base = (_LC_locale_t *)__xopen_locale("C");
+  memcpy(newloc, base, sizeof (_LC_locale_t));
+  if (category_mask & LC_COLLATE_MASK) 
+    newloc->lc_collate = loc->lc_collate;
+  if (category_mask & LC_CTYPE_MASK)
+    newloc->lc_ctype = loc->lc_ctype;
+  //if (category_mask & LC_MESSAGES_MASK)
+  //  newloc->lc_messages = loc->lc_messages;
+  if (category_mask & LC_MONETARY_MASK)
+    newloc->lc_monetary = loc->lc_monetary;
+  if (category_mask & LC_TIME_MASK)
+    newloc->lc_time = loc->lc_time;
+  if (category_mask & LC_NUMERIC_MASK)
+    newloc->lc_numeric = loc->lc_numeric;
+  return (locale_t)newloc; 
+}
+static inline
+void freelocale(locale_t locobj)
+{
+  free(locobj);
+}
+static inline
+locale_t uselocale(locale_t newloc)
+{
+  return (locale_t)0;
+}
+
+static inline
+int isalnum_l(int c, locale_t locale)
+{
+  return __xisalnum(locale, c);
+}
+static inline
+int isalpha_l(int c, locale_t locale)
+{
+  return __xisalpha(locale, c);
+}
+static inline
+int isblank_l(int c, locale_t locale)
+{
+  return __xisblank(locale, c);
+}
+static inline
+int iscntrl_l(int c, locale_t locale)
+{
+  return __xiscntrl(locale, c);
+}
+static inline
+int isdigit_l(int c, locale_t locale)
+{
+  return __xisdigit(locale, c);
+}
+static inline
+int isgraph_l(int c, locale_t locale)
+{
+  return __xisgraph(locale, c);
+}
+static inline
+int islower_l(int c, locale_t locale)
+{
+  return __xislower(locale, c);
+}
+static inline
+int isprint_l(int c, locale_t locale)
+{
+  return __xisprint(locale, c);
+}
+
+static inline
+int ispunct_l(int c, locale_t locale)
+{
+  return __xispunct(locale, c);
+}
+static inline
+int isspace_l(int c, locale_t locale)
+{
+  return __xisspace(locale, c);
+}
+static inline
+int isupper_l(int c, locale_t locale)
+{
+  return __xisupper(locale, c);
+}
+
+static inline
+int isxdigit_l(int c, locale_t locale)
+{
+  return __xisxdigit(locale, c);
+}
+
+static inline
+int iswalnum_l(wchar_t wc, locale_t locale)
+{
+  return __xiswalnum(locale, wc); 
+}
+
+static inline
+int iswalpha_l(wchar_t wc, locale_t locale)
+{
+  return __xiswalpha(locale, wc);
+}
+
+static inline
+int iswblank_l(wchar_t wc, locale_t locale)
+{
+  return __xiswblank(locale, wc);
+}
+
+static inline
+int iswcntrl_l(wchar_t wc, locale_t locale)
+{
+  return __xiswcntrl(locale, wc);
+}
+
+static inline
+int iswdigit_l(wchar_t wc, locale_t locale)
+{
+  return __xiswdigit(locale, wc);
+}
+
+static inline
+int iswgraph_l(wchar_t wc, locale_t locale)
+{
+  return __xiswgraph(locale, wc);
+}
+
+static inline
+int iswlower_l(wchar_t wc, locale_t locale)
+{
+  return __xiswlower(locale, wc);
+}
+
+static inline
+int iswprint_l(wchar_t wc, locale_t locale)
+{
+  return __xiswprint(locale, wc);
+}
+
+static inline
+int iswpunct_l(wchar_t wc, locale_t locale)
+{
+  return __xiswpunct(locale, wc);
+}
+
+static inline
+int iswspace_l(wchar_t wc, locale_t locale)
+{
+  return __xiswspace(locale, wc);
+}
+
+static inline
+int iswupper_l(wchar_t wc, locale_t locale)
+{
+  return __xiswupper(locale, wc);
+}
+
+static inline
+int iswxdigit_l(wchar_t wc, locale_t locale)
+{
+  return __xiswxdigit(locale, wc);
+}
+
+static inline
+int iswctype_l(wint_t wc, wctype_t desc, locale_t locale)
+{
+  return __xiswctype(locale, wc, desc); 
+}
+
+static inline
+int toupper_l(int c, locale_t locale)
+{
+  return __xtoupper(locale, c);
+}
+static inline
+int tolower_l(int c, locale_t locale)
+{
+  return __xtolower(locale, c);
+}
+static inline
+wint_t towupper_l(wint_t wc, locale_t locale)
+{
+  return __xtowupper(locale, wc);
+}
+static inline
+wint_t towlower_l(wint_t wc, locale_t locale)
+{
+  return __xtowlower(locale, wc);
+}
+
+static inline
+int strcoll_l(const char *__s1, const char *__s2, locale_t locale)
+{
+  return __xstrcoll(locale, __s1, __s2);
+}
+static inline
+int wcscoll_l(const wchar_t *__s1, const wchar_t *__s2, locale_t locale)
+{
+  return __xwcscoll(locale, __s1, __s2);
+}
+static inline
+size_t strxfrm_l(char *__s1, const char *__s2, size_t __n, locale_t locale)
+{
+  return __xstrxfrm(locale, __s1, __s2, __n);
+}
+
+static inline
+size_t wcsxfrm_l(wchar_t *__ws1, const wchar_t *__ws2, size_t __n,
+    locale_t locale)
+{
+  return __xwcsxfrm(locale, __ws1, __ws2, __n);
+}
+#endif // !defined(_AIX71)
+
+// strftime_l() is defined by POSIX. However, AIX 7.1 does not have it
+// implemented yet.
+static inline
+size_t strftime_l(char *__s, size_t __size, const char *__fmt,
+                  const struct tm *__tm, locale_t locale) {
+  return __xstrftime(locale, __s, __size, __fmt, __tm);
+}
+
+// The following are not POSIX routines.  These are quick-and-dirty hacks
+// to make things pretend to work
+static inline
+long long strtoll_l(const char *__nptr, char **__endptr,
+    int __base, locale_t locale) {
+  return strtoll(__nptr, __endptr, __base);
+}
+static inline
+long strtol_l(const char *__nptr, char **__endptr,
+    int __base, locale_t locale) {
+  return strtol(__nptr, __endptr, __base);
+}
+static inline
+long double strtold_l(const char *__nptr, char **__endptr,
+    locale_t locale) {
+  return strtold(__nptr, __endptr);
+}
+static inline
+unsigned long long strtoull_l(const char *__nptr, char **__endptr,
+    int __base, locale_t locale) {
+  return strtoull(__nptr, __endptr, __base);
+}
+static inline
+unsigned long strtoul_l(const char *__nptr, char **__endptr,
+    int __base, locale_t locale) {
+  return strtoul(__nptr, __endptr, __base);
+}
+
+static inline
+int vasprintf(char **strp, const char *fmt, va_list ap)
+{
+  const size_t buff_size = 256;
+  int str_size;
+  if ((*strp = (char *)malloc(buff_size)) == NULL)
+  {
+    return -1;
+  }
+  if ((str_size = vsnprintf(*strp, buff_size, fmt,  ap)) >= buff_size)
+  {
+    if ((*strp = (char *)realloc(*strp, str_size + 1)) == NULL)
+    {
+      return -1;
+    }
+    str_size = vsnprintf(*strp, str_size + 1, fmt,  ap);
+  }
+  return str_size;
+}  
+
+#ifdef __cplusplus
+}
+#endif
+#endif // defined(_AIX)
+#endif // _LIBCPP_SUPPORT_IBM_XLOCALE_H
diff --git a/system/include/libcxx/support/win32/limits_win32.h b/system/include/libcxx/support/win32/limits_win32.h
index 52229c4ddec3f..406cd3025bf84 100644
--- a/system/include/libcxx/support/win32/limits_win32.h
+++ b/system/include/libcxx/support/win32/limits_win32.h
@@ -12,16 +12,15 @@
 #define _LIBCPP_SUPPORT_WIN32_LIMITS_WIN32_H
 
 #if !defined(_LIBCPP_MSVCRT)
-#error "This header complements Microsoft's C Runtime library, and should not be included otherwise."
+#error "This header complements the Microsoft C Runtime library, and should not be included otherwise."
 #else
 
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#include <windows.h> // ymath.h works correctly
-
+#include <limits.h> // CHAR_BIT
 #include <float.h> // limit constants
 
+#if ! defined(__clang__)
+#define __CHAR_BIT__       CHAR_BIT
+
 #define __FLT_MANT_DIG__   FLT_MANT_DIG
 #define __FLT_DIG__        FLT_DIG
 #define __FLT_RADIX__      FLT_RADIX
@@ -73,6 +72,7 @@
 #define __builtin_nans(__dummy)  _Snan._Double
 #define __builtin_nansf(__dummy) _FSnan._Float
 #define __builtin_nansl(__dummy) _LSnan._Long_double
+#endif // ! defined(__clang__)
 
 #endif // _LIBCPP_MSVCRT
 
diff --git a/system/include/libcxx/support/win32/locale_win32.h b/system/include/libcxx/support/win32/locale_win32.h
index 019586c0f4e13..e768af50c14cd 100644
--- a/system/include/libcxx/support/win32/locale_win32.h
+++ b/system/include/libcxx/support/win32/locale_win32.h
@@ -15,6 +15,7 @@
 extern "C" unsigned short  __declspec(dllimport) _ctype[];
 
 #include "support/win32/support.h"
+#include <stdio.h>
 #include <memory>
 #include <xlocinfo.h> // _locale_t
 #define locale_t _locale_t
@@ -35,23 +36,23 @@ extern "C" unsigned short  __declspec(dllimport) _ctype[];
 locale_t newlocale( int mask, const char * locale, locale_t base );
 locale_t uselocale( locale_t newloc );
 lconv *localeconv_l( locale_t loc );
-size_t mbrlen_l( const char *__restrict__ s, size_t n,
-                 mbstate_t *__restrict__ ps, locale_t loc);
-size_t mbsrtowcs_l( wchar_t *__restrict__ dst, const char **__restrict__ src,
-                    size_t len, mbstate_t *__restrict__ ps, locale_t loc );
-size_t wcrtomb_l( char *__restrict__ s, wchar_t wc, mbstate_t *__restrict__ ps,
+size_t mbrlen_l( const char *__restrict s, size_t n,
+                 mbstate_t *__restrict ps, locale_t loc);
+size_t mbsrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
+                    size_t len, mbstate_t *__restrict ps, locale_t loc );
+size_t wcrtomb_l( char *__restrict s, wchar_t wc, mbstate_t *__restrict ps,
                   locale_t loc);
-size_t mbrtowc_l( wchar_t *__restrict__ pwc, const char *__restrict__ s,
-                  size_t n, mbstate_t *__restrict__ ps, locale_t loc);
-size_t mbsnrtowcs_l( wchar_t *__restrict__ dst, const char **__restrict__ src,
-                     size_t nms, size_t len, mbstate_t *__restrict__ ps, locale_t loc);
-size_t wcsnrtombs_l( char *__restrict__ dst, const wchar_t **__restrict__ src,
-                     size_t nwc, size_t len, mbstate_t *__restrict__ ps, locale_t loc);
+size_t mbrtowc_l( wchar_t *__restrict pwc, const char *__restrict s,
+                  size_t n, mbstate_t *__restrict ps, locale_t loc);
+size_t mbsnrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
+                     size_t nms, size_t len, mbstate_t *__restrict ps, locale_t loc);
+size_t wcsnrtombs_l( char *__restrict dst, const wchar_t **__restrict src,
+                     size_t nwc, size_t len, mbstate_t *__restrict ps, locale_t loc);
 wint_t btowc_l( int c, locale_t loc );
 int wctob_l( wint_t c, locale_t loc );
 typedef _VSTD::remove_pointer<locale_t>::type __locale_struct;
 typedef _VSTD::unique_ptr<__locale_struct, decltype(&uselocale)> __locale_raii;
-_LIBCPP_ALWAYS_INLINE inline
+inline _LIBCPP_ALWAYS_INLINE
 decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l )
 {
   __locale_raii __current( uselocale(__l), uselocale );
@@ -59,7 +60,6 @@ decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l )
 }
 
 // the *_l functions are prefixed on Windows, only available for msvcr80+, VS2005+
-#include <stdio.h>
 #define mbtowc_l _mbtowc_l
 #define strtoll_l _strtoi64_l
 #define strtoull_l _strtoui64_l
@@ -120,10 +120,10 @@ inline int iswblank_l( wint_t c, locale_t /*loc*/ )
     return ( c == L' ' || c == L'\t' );
 }
 
-#ifdef _MSC_VER
+#if defined(_LIBCPP_MSVCRT)
 inline int isblank( int c, locale_t /*loc*/ )
 { return ( c == ' ' || c == '\t' ); }
 inline int iswblank( wint_t c, locale_t /*loc*/ )
 { return ( c == L' ' || c == L'\t' ); }
-#endif // _MSC_VER
+#endif // _LIBCPP_MSVCRT
 #endif // _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H
diff --git a/system/include/libcxx/support/win32/math_win32.h b/system/include/libcxx/support/win32/math_win32.h
index 22400c0d00f3c..c62c54e3cd850 100644
--- a/system/include/libcxx/support/win32/math_win32.h
+++ b/system/include/libcxx/support/win32/math_win32.h
@@ -16,7 +16,9 @@
 #else
 
 #include <math.h>
+#include <float.h> // _FPCLASS_PN etc.
 
+// Necessary?
 typedef float float_t;
 typedef double double_t;
 
diff --git a/system/include/libcxx/support/win32/support.h b/system/include/libcxx/support/win32/support.h
index 17abb915f7ebb..b953ab77ce354 100644
--- a/system/include/libcxx/support/win32/support.h
+++ b/system/include/libcxx/support/win32/support.h
@@ -15,11 +15,16 @@
    Functions and constants used in libc++ that are missing from the Windows C library.
   */
 
-#include <cwchar>  // mbstate_t
+#include <wchar.h>  // mbstate_t
 #include <cstdarg> // va_ macros
 #define swprintf _snwprintf
 #define vswprintf _vsnwprintf
 
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <Windows.h>
+
 extern "C" {
 
 int vasprintf( char **sptr, const char *__restrict fmt, va_list ap );
diff --git a/system/include/libcxx/system_error b/system/include/libcxx/system_error
index 1c1c7ebddf37d..66bf6d6c42495 100644
--- a/system/include/libcxx/system_error
+++ b/system/include/libcxx/system_error
@@ -22,6 +22,7 @@ class error_category
 public:
     virtual ~error_category() noexcept;
 
+    constexpr error_category();
     error_category(const error_category&) = delete;
     error_category& operator=(const error_category&) = delete;
 
@@ -232,13 +233,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // is_error_code_enum
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_error_code_enum
+struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum
     : public false_type {};
 
 // is_error_condition_enum
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_error_condition_enum
+struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum
     : public false_type {};
 
 // Some error codes are not present on all platforms, so we provide equivalents
@@ -345,12 +346,12 @@ _LIBCPP_DECLARE_STRONG_ENUM(errc)
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc)
 
 template <>
-struct _LIBCPP_TYPE_VIS is_error_condition_enum<errc>
+struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum<errc>
     : true_type { };
 
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 template <>
-struct _LIBCPP_TYPE_VIS is_error_condition_enum<errc::__lx>
+struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum<errc::__lx>
     : true_type { };
 #endif
 
@@ -366,7 +367,12 @@ class _LIBCPP_TYPE_VIS error_category
 public:
     virtual ~error_category() _NOEXCEPT;
 
+#ifdef _LIBCPP_BUILDING_SYSTEM_ERROR
     error_category() _NOEXCEPT;
+#else
+    _LIBCPP_ALWAYS_INLINE
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 error_category() _NOEXCEPT _LIBCPP_DEFAULT;
+#endif
 private:
     error_category(const error_category&);// = delete;
     error_category& operator=(const error_category&);// = delete;
@@ -397,8 +403,8 @@ public:
     virtual string message(int ev) const;
 };
 
-const error_category& generic_category() _NOEXCEPT;
-const error_category& system_category() _NOEXCEPT;
+_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
+_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
 
 class _LIBCPP_TYPE_VIS error_condition
 {
@@ -597,7 +603,7 @@ operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
 {return !(__x == __y);}
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<error_code>
+struct _LIBCPP_TYPE_VIS_ONLY hash<error_code>
     : public unary_function<error_code, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -629,7 +635,7 @@ private:
     static string __init(const error_code&, string);
 };
 
-void __throw_system_error(int ev, const char* what_arg);
+_LIBCPP_FUNC_VIS void __throw_system_error(int ev, const char* what_arg);
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/system/include/libcxx/thread b/system/include/libcxx/thread
index f41ea2902055d..1f1e4a2b9459c 100644
--- a/system/include/libcxx/thread
+++ b/system/include/libcxx/thread
@@ -185,10 +185,9 @@ _LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
 
 }  // this_thread
 
-class _LIBCPP_TYPE_VIS __thread_id;
-template<> struct _LIBCPP_TYPE_VIS hash<__thread_id>;
+template<> struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
 
-class _LIBCPP_TYPE_VIS __thread_id
+class _LIBCPP_TYPE_VIS_ONLY __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
@@ -231,11 +230,11 @@ private:
 
     friend __thread_id this_thread::get_id() _NOEXCEPT;
     friend class _LIBCPP_TYPE_VIS thread;
-    friend struct _LIBCPP_TYPE_VIS hash<__thread_id>;
+    friend struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
 };
 
 template<>
-struct _LIBCPP_TYPE_VIS hash<__thread_id>
+struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>
     : public unary_function<__thread_id, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -307,7 +306,7 @@ class __assoc_sub_state;
 
 class _LIBCPP_HIDDEN __thread_struct_imp;
 
-class __thread_struct
+class _LIBCPP_TYPE_VIS __thread_struct
 {
     __thread_struct_imp* __p_;
 
@@ -321,7 +320,7 @@ public:
     void __make_ready_at_thread_exit(__assoc_sub_state*);
 };
 
-__thread_specific_ptr<__thread_struct>& __thread_local_data();
+_LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data();
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
@@ -405,7 +404,7 @@ void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);}
 namespace this_thread
 {
 
-void sleep_for(const chrono::nanoseconds& ns);
+_LIBCPP_FUNC_VIS void sleep_for(const chrono::nanoseconds& ns);
 
 template <class _Rep, class _Period>
 void
diff --git a/system/include/libcxx/tuple b/system/include/libcxx/tuple
index 94876c91c0289..a1a7bcf0b5e73 100644
--- a/system/include/libcxx/tuple
+++ b/system/include/libcxx/tuple
@@ -73,7 +73,7 @@ public:
 const unspecified ignore;
 
 template <class... T> tuple<V...>  make_tuple(T&&...); // constexpr in C++14
-template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept;
+template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept; // constexpr in C++14
 template <class... T> tuple<T&...> tie(T&...) noexcept;
 template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls); // constexpr in C++14
   
@@ -133,74 +133,12 @@ template <class... Types>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-// allocator_arg_t
-
-struct _LIBCPP_TYPE_VIS allocator_arg_t { };
-
-#if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MEMORY)
-extern const allocator_arg_t allocator_arg;
-#else
-constexpr allocator_arg_t allocator_arg = allocator_arg_t();
-#endif
-
-// uses_allocator
-
-template <class _Tp>
-struct __has_allocator_type
-{
-private:
-    struct __two {char __lx; char __lxx;};
-    template <class _Up> static __two __test(...);
-    template <class _Up> static char __test(typename _Up::allocator_type* = 0);
-public:
-    static const bool value = sizeof(__test<_Tp>(0)) == 1;
-};
-
-template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value>
-struct __uses_allocator
-    : public integral_constant<bool,
-        is_convertible<_Alloc, typename _Tp::allocator_type>::value>
-{
-};
-
-template <class _Tp, class _Alloc>
-struct __uses_allocator<_Tp, _Alloc, false>
-    : public false_type
-{
-};
-
-template <class _Tp, class _Alloc>
-struct _LIBCPP_TYPE_VIS uses_allocator
-    : public __uses_allocator<_Tp, _Alloc>
-{
-};
-
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
-// uses-allocator construction
-
-template <class _Tp, class _Alloc, class ..._Args>
-struct __uses_alloc_ctor_imp
-{
-    static const bool __ua = uses_allocator<_Tp, _Alloc>::value;
-    static const bool __ic =
-        is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
-    static const int value = __ua ? 2 - __ic : 0;
-};
-
-template <class _Tp, class _Alloc, class ..._Args>
-struct __uses_alloc_ctor
-    : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
-    {};
-
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 // tuple_size
 
 template <class ..._Tp>
-class _LIBCPP_TYPE_VIS tuple_size<tuple<_Tp...> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_size<tuple<_Tp...> >
     : public integral_constant<size_t, sizeof...(_Tp)>
 {
 };
@@ -208,7 +146,7 @@ class _LIBCPP_TYPE_VIS tuple_size<tuple<_Tp...> >
 // tuple_element
 
 template <size_t _Ip, class ..._Tp>
-class _LIBCPP_TYPE_VIS tuple_element<_Ip, tuple<_Tp...> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, tuple<_Tp...> >
 {
 public:
     typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
@@ -332,7 +270,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR_AFTER_CXX11
     __tuple_leaf(__tuple_leaf&& __t) _NOEXCEPT_(is_nothrow_move_constructible<_Hp>::value)
-        : value(_VSTD::move(__t.get()))
+        : value(_VSTD::forward<_Hp>(__t.get()))
         {}
 
     template <class _Tp>
@@ -519,13 +457,24 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
             return *this;
         }
 
-        _LIBCPP_INLINE_VISIBILITY
-        __tuple_impl&
-        operator=(const __tuple_impl& __t) _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
-        {
-            __swallow(__tuple_leaf<_Indx, _Tp>::operator=(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t).get())...);
-            return *this;
-        }
+    __tuple_impl(const __tuple_impl&) = default;
+    __tuple_impl(__tuple_impl&&) = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    __tuple_impl&
+    operator=(const __tuple_impl& __t) _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
+    {
+        __swallow(__tuple_leaf<_Indx, _Tp>::operator=(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t).get())...);
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    __tuple_impl&
+    operator=(__tuple_impl&& __t) _NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
+    {
+        __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<_Tp>(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t).get()))...);
+        return *this;
+    }
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(__tuple_impl& __t)
@@ -536,7 +485,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
 };
 
 template <class ..._Tp>
-class _LIBCPP_TYPE_VIS tuple
+class _LIBCPP_TYPE_VIS_ONLY tuple
 {
     typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base;
 
@@ -724,7 +673,7 @@ public:
 };
 
 template <>
-class _LIBCPP_TYPE_VIS tuple<>
+class _LIBCPP_TYPE_VIS_ONLY tuple<>
 {
 public:
     _LIBCPP_INLINE_VISIBILITY
@@ -810,7 +759,7 @@ struct __find_exactly_one_t_helper <_T1, _Idx, _Head, _Args...> {
     static constexpr size_t value =
         std::conditional<
             std::is_same<_T1, _Head>::value,
-            __find_exactly_one_t_checker<_T1, _Idx,   _Args...>,
+            __find_exactly_one_t_checker<_T1, _Idx,   _Args...>,
             __find_exactly_one_t_helper <_T1, _Idx+1, _Args...>
         >::type::value;
     };
@@ -864,7 +813,7 @@ struct __ignore_t
 
 namespace { const __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); }
 
-template <class _Tp> class _LIBCPP_TYPE_VIS reference_wrapper;
+template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY reference_wrapper;
 
 template <class _Tp>
 struct ___make_tuple_return
@@ -895,14 +844,6 @@ make_tuple(_Tp&&... __t)
 template <class... _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 tuple<_Tp&&...>
-__forward_as_tuple(_Tp&&... __t) _NOEXCEPT
-{
-    return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
-}
-
-template <class... _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-tuple<_Tp&&...>
 forward_as_tuple(_Tp&&... __t) _NOEXCEPT
 {
     return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
@@ -1103,7 +1044,7 @@ struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J
     typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
     operator()(tuple<_Types...> __t, _Tuple0&& __t0)
     {
-        return __forward_as_tuple(_VSTD::forward<_Types>(get<_I0>(__t))...,
+        return forward_as_tuple(_VSTD::forward<_Types>(get<_I0>(__t))...,
                                       get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
     }
 
@@ -1118,7 +1059,7 @@ struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J
            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>()
-                           (__forward_as_tuple(
+                           (forward_as_tuple(
                               _VSTD::forward<_Types>(get<_I0>(__t))...,
                               get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
                             ),
@@ -1140,7 +1081,7 @@ tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
 }
 
 template <class ..._Tp, class _Alloc>
-struct _LIBCPP_TYPE_VIS uses_allocator<tuple<_Tp...>, _Alloc>
+struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<tuple<_Tp...>, _Alloc>
     : true_type {};
 
 template <class _T1, class _T2>
diff --git a/system/include/libcxx/type_traits b/system/include/libcxx/type_traits
index 99e34d133232a..b6430fbbc9a6b 100644
--- a/system/include/libcxx/type_traits
+++ b/system/include/libcxx/type_traits
@@ -28,6 +28,7 @@ namespace std
 
     // Primary classification traits:
     template <class T> struct is_void;
+    template <class T> struct is_null_pointer;  // C++14
     template <class T> struct is_integral;
     template <class T> struct is_floating_point;
     template <class T> struct is_array;
@@ -208,16 +209,16 @@ namespace std
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <bool _Bp, class _If, class _Then>
-    struct _LIBCPP_TYPE_VIS conditional {typedef _If type;};
+    struct _LIBCPP_TYPE_VIS_ONLY conditional {typedef _If type;};
 template <class _If, class _Then>
-    struct _LIBCPP_TYPE_VIS conditional<false, _If, _Then> {typedef _Then type;};
+    struct _LIBCPP_TYPE_VIS_ONLY conditional<false, _If, _Then> {typedef _Then type;};
 
 #if _LIBCPP_STD_VER > 11
 template <bool _Bp, class _If, class _Then> using conditional_t = typename conditional<_Bp, _If, _Then>::type;
 #endif
 
-template <bool, class _Tp = void> struct _LIBCPP_TYPE_VIS enable_if {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS enable_if<true, _Tp> {typedef _Tp type;};
+template <bool, class _Tp = void> struct _LIBCPP_TYPE_VIS_ONLY enable_if {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY enable_if<true, _Tp> {typedef _Tp type;};
 
 #if _LIBCPP_STD_VER > 11
 template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type;
@@ -229,7 +230,7 @@ struct __two {char __lx[2];};
 // helper class:
 
 template <class _Tp, _Tp __v>
-struct _LIBCPP_TYPE_VIS integral_constant
+struct _LIBCPP_TYPE_VIS_ONLY integral_constant
 {
     static _LIBCPP_CONSTEXPR const _Tp      value = __v;
     typedef _Tp               value_type;
@@ -250,33 +251,33 @@ typedef integral_constant<bool, false> false_type;
 
 // is_const
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_const            : public false_type {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_const<_Tp const> : public true_type {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_const            : public false_type {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_const<_Tp const> : public true_type {};
 
 // is_volatile
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_volatile               : public false_type {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_volatile<_Tp volatile> : public true_type {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_volatile               : public false_type {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_volatile<_Tp volatile> : public true_type {};
 
 // remove_const
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_const            {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_const<const _Tp> {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_const            {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_const<const _Tp> {typedef _Tp type;};
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_const_t = typename remove_const<_Tp>::type;
 #endif
 
 // remove_volatile
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_volatile               {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_volatile               {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_volatile<volatile _Tp> {typedef _Tp type;};
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_volatile_t = typename remove_volatile<_Tp>::type;
 #endif
 
 // remove_cv
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_cv
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_cv
 {typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type;
@@ -287,7 +288,7 @@ template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type;
 template <class _Tp> struct __is_void       : public false_type {};
 template <>          struct __is_void<void> : public true_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_void
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_void
     : public __is_void<typename remove_cv<_Tp>::type> {};
 
 // __is_nullptr_t
@@ -295,9 +296,14 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_void
 template <class _Tp> struct ____is_nullptr_t       : public false_type {};
 template <>          struct ____is_nullptr_t<nullptr_t> : public true_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS __is_nullptr_t
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY __is_nullptr_t
     : public ____is_nullptr_t<typename remove_cv<_Tp>::type> {};
 
+#if _LIBCPP_STD_VER > 11
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_null_pointer
+    : public ____is_nullptr_t<typename remove_cv<_Tp>::type> {};
+#endif
+
 // is_integral
 
 template <class _Tp> struct __is_integral                     : public false_type {};
@@ -319,7 +325,7 @@ template <>          struct __is_integral<unsigned long>      : public true_type
 template <>          struct __is_integral<long long>          : public true_type {};
 template <>          struct __is_integral<unsigned long long> : public true_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_integral
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_integral
     : public __is_integral<typename remove_cv<_Tp>::type> {};
 
 // is_floating_point
@@ -329,16 +335,16 @@ template <>          struct __is_floating_point<float>       : public true_type
 template <>          struct __is_floating_point<double>      : public true_type {};
 template <>          struct __is_floating_point<long double> : public true_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_floating_point
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_floating_point
     : public __is_floating_point<typename remove_cv<_Tp>::type> {};
 
 // is_array
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_array
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_array
     : public false_type {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_array<_Tp[]>
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_array<_Tp[]>
     : public true_type {};
-template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS is_array<_Tp[_Np]>
+template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY is_array<_Tp[_Np]>
     : public true_type {};
 
 // is_pointer
@@ -346,23 +352,23 @@ template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS is_array<_Tp[_Np]>
 template <class _Tp> struct __is_pointer       : public false_type {};
 template <class _Tp> struct __is_pointer<_Tp*> : public true_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_pointer
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_pointer
     : public __is_pointer<typename remove_cv<_Tp>::type> {};
 
 // is_reference
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_lvalue_reference       : public false_type {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_lvalue_reference<_Tp&> : public true_type {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_lvalue_reference       : public false_type {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_lvalue_reference<_Tp&> : public true_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_rvalue_reference        : public false_type {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_rvalue_reference        : public false_type {};
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_rvalue_reference<_Tp&&> : public true_type {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_rvalue_reference<_Tp&&> : public true_type {};
 #endif
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_reference        : public false_type {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_reference<_Tp&>  : public true_type {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_reference        : public false_type {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_reference<_Tp&>  : public true_type {};
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_reference<_Tp&&> : public true_type {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_reference<_Tp&&> : public true_type {};
 #endif
 
 #if defined(__clang__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
@@ -373,13 +379,13 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_reference<_Tp&&> : public true_t
 
 #if __has_feature(is_union) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_union
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_union
     : public integral_constant<bool, __is_union(_Tp)> {};
 
 #else
 
 template <class _Tp> struct __libcpp_union : public false_type {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_union
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_union
     : public __libcpp_union<typename remove_cv<_Tp>::type> {};
 
 #endif
@@ -388,7 +394,7 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_union
 
 #if __has_feature(is_class) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_class
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_class
     : public integral_constant<bool, __is_class(_Tp)> {};
 
 #else
@@ -399,15 +405,15 @@ template <class _Tp> char  __test(int _Tp::*);
 template <class _Tp> __two __test(...);
 }
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_class
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_class
     : public integral_constant<bool, sizeof(__is_class_imp::__test<_Tp>(0)) == 1 && !is_union<_Tp>::value> {};
 
 #endif
 
 // is_same
 
-template <class _Tp, class _Up> struct _LIBCPP_TYPE_VIS is_same           : public false_type {};
-template <class _Tp>            struct _LIBCPP_TYPE_VIS is_same<_Tp, _Tp> : public true_type {};
+template <class _Tp, class _Up> struct _LIBCPP_TYPE_VIS_ONLY is_same           : public false_type {};
+template <class _Tp>            struct _LIBCPP_TYPE_VIS_ONLY is_same<_Tp, _Tp> : public true_type {};
 
 // is_function
 
@@ -422,13 +428,13 @@ template <class _Tp, bool = is_class<_Tp>::value ||
                             is_union<_Tp>::value ||
                             is_void<_Tp>::value  ||
                             is_reference<_Tp>::value ||
-                            is_same<_Tp, nullptr_t>::value >
+                            __is_nullptr_t<_Tp>::value >
 struct __is_function
     : public integral_constant<bool, sizeof(__is_function_imp::__test<_Tp>(__is_function_imp::__source<_Tp>())) == 1>
     {};
 template <class _Tp> struct __is_function<_Tp, true> : public false_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_function
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_function
     : public __is_function<_Tp> {};
 
 // is_member_function_pointer
@@ -436,7 +442,7 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_function
 template <class _Tp> struct            __is_member_function_pointer             : public false_type {};
 template <class _Tp, class _Up> struct __is_member_function_pointer<_Tp _Up::*> : public is_function<_Tp> {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_member_function_pointer
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_member_function_pointer
     : public __is_member_function_pointer<typename remove_cv<_Tp>::type> {};
 
 // is_member_pointer
@@ -444,12 +450,12 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_member_function_pointer
 template <class _Tp>            struct __is_member_pointer             : public false_type {};
 template <class _Tp, class _Up> struct __is_member_pointer<_Tp _Up::*> : public true_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_member_pointer
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_member_pointer
     : public __is_member_pointer<typename remove_cv<_Tp>::type> {};
 
 // is_member_object_pointer
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_member_object_pointer
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_member_object_pointer
     : public integral_constant<bool, is_member_pointer<_Tp>::value &&
                                     !is_member_function_pointer<_Tp>::value> {};
 
@@ -457,12 +463,12 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_member_object_pointer
 
 #if __has_feature(is_enum) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_enum
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_enum
     : public integral_constant<bool, __is_enum(_Tp)> {};
 
 #else
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_enum
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_enum
     : public integral_constant<bool, !is_void<_Tp>::value             &&
                                      !is_integral<_Tp>::value         &&
                                      !is_floating_point<_Tp>::value   &&
@@ -478,31 +484,31 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_enum
 
 // is_arithmetic
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_arithmetic
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_arithmetic
     : public integral_constant<bool, is_integral<_Tp>::value      ||
                                      is_floating_point<_Tp>::value> {};
 
 // is_fundamental
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_fundamental
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_fundamental
     : public integral_constant<bool, is_void<_Tp>::value        ||
                                      __is_nullptr_t<_Tp>::value ||
                                      is_arithmetic<_Tp>::value> {};
 
 // is_scalar
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_scalar
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_scalar
     : public integral_constant<bool, is_arithmetic<_Tp>::value     ||
                                      is_member_pointer<_Tp>::value ||
                                      is_pointer<_Tp>::value        ||
                                      __is_nullptr_t<_Tp>::value    ||
                                      is_enum<_Tp>::value           > {};
 
-template <> struct _LIBCPP_TYPE_VIS is_scalar<nullptr_t> : public true_type {};
+template <> struct _LIBCPP_TYPE_VIS_ONLY is_scalar<nullptr_t> : public true_type {};
 
 // is_object
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_object
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_object
     : public integral_constant<bool, is_scalar<_Tp>::value ||
                                      is_array<_Tp>::value  ||
                                      is_union<_Tp>::value  ||
@@ -510,7 +516,7 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_object
 
 // is_compound
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_compound
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_compound
     : public integral_constant<bool, !is_fundamental<_Tp>::value> {};
 
 // add_const
@@ -523,7 +529,7 @@ struct __add_const             {typedef _Tp type;};
 template <class _Tp>
 struct __add_const<_Tp, false> {typedef const _Tp type;};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS add_const
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_const
     {typedef typename __add_const<_Tp>::type type;};
 
 #if _LIBCPP_STD_VER > 11
@@ -540,7 +546,7 @@ struct __add_volatile             {typedef _Tp type;};
 template <class _Tp>
 struct __add_volatile<_Tp, false> {typedef volatile _Tp type;};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS add_volatile
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_volatile
     {typedef typename __add_volatile<_Tp>::type type;};
 
 #if _LIBCPP_STD_VER > 11
@@ -549,7 +555,7 @@ template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type;
 
 // add_cv
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS add_cv
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_cv
     {typedef typename add_const<typename add_volatile<_Tp>::type>::type type;};
 
 #if _LIBCPP_STD_VER > 11
@@ -558,10 +564,10 @@ template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;
 
 // remove_reference
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_reference        {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_reference<_Tp&>  {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_reference        {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_reference<_Tp&>  {typedef _Tp type;};
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_reference<_Tp&&> {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_reference<_Tp&&> {typedef _Tp type;};
 #endif
 
 #if _LIBCPP_STD_VER > 11
@@ -570,12 +576,12 @@ template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::
 
 // add_lvalue_reference
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS add_lvalue_reference                      {typedef _Tp& type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS add_lvalue_reference<_Tp&>                {typedef _Tp& type;};  // for older compiler
-template <>          struct _LIBCPP_TYPE_VIS add_lvalue_reference<void>                {typedef void type;};
-template <>          struct _LIBCPP_TYPE_VIS add_lvalue_reference<const void>          {typedef const void type;};
-template <>          struct _LIBCPP_TYPE_VIS add_lvalue_reference<volatile void>       {typedef volatile void type;};
-template <>          struct _LIBCPP_TYPE_VIS add_lvalue_reference<const volatile void> {typedef const volatile void type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference                      {typedef _Tp& type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<_Tp&>                {typedef _Tp& type;};  // for older compiler
+template <>          struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<void>                {typedef void type;};
+template <>          struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<const void>          {typedef const void type;};
+template <>          struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<volatile void>       {typedef volatile void type;};
+template <>          struct _LIBCPP_TYPE_VIS_ONLY add_lvalue_reference<const volatile void> {typedef const volatile void type;};
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
@@ -583,11 +589,11 @@ template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_referenc
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS  add_rvalue_reference                     {typedef _Tp&& type;};
-template <>          struct _LIBCPP_TYPE_VIS add_rvalue_reference<void>                {typedef void type;};
-template <>          struct _LIBCPP_TYPE_VIS add_rvalue_reference<const void>          {typedef const void type;};
-template <>          struct _LIBCPP_TYPE_VIS add_rvalue_reference<volatile void>       {typedef volatile void type;};
-template <>          struct _LIBCPP_TYPE_VIS add_rvalue_reference<const volatile void> {typedef const volatile void type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY  add_rvalue_reference                     {typedef _Tp&& type;};
+template <>          struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<void>                {typedef void type;};
+template <>          struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<const void>          {typedef const void type;};
+template <>          struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<volatile void>       {typedef volatile void type;};
+template <>          struct _LIBCPP_TYPE_VIS_ONLY add_rvalue_reference<const volatile void> {typedef const volatile void type;};
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
@@ -616,11 +622,11 @@ struct __any
 
 // remove_pointer
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_pointer                      {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_pointer<_Tp*>                {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_pointer<_Tp* const>          {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_pointer<_Tp* volatile>       {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_pointer<_Tp* const volatile> {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer                      {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer<_Tp*>                {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer<_Tp* const>          {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer<_Tp* volatile>       {typedef _Tp type;};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_pointer<_Tp* const volatile> {typedef _Tp type;};
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type;
@@ -628,7 +634,7 @@ template <class _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type
 
 // add_pointer
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS add_pointer
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY add_pointer
     {typedef typename remove_reference<_Tp>::type* type;};
 
 #if _LIBCPP_STD_VER > 11
@@ -648,7 +654,7 @@ struct __is_signed : public ___is_signed<_Tp> {};
 
 template <class _Tp> struct __is_signed<_Tp, false> : public false_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_signed : public __is_signed<_Tp> {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_signed : public __is_signed<_Tp> {};
 
 // is_unsigned
 
@@ -663,37 +669,37 @@ struct __is_unsigned : public ___is_unsigned<_Tp> {};
 
 template <class _Tp> struct __is_unsigned<_Tp, false> : public false_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_unsigned : public __is_unsigned<_Tp> {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_unsigned : public __is_unsigned<_Tp> {};
 
 // rank
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS rank
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY rank
     : public integral_constant<size_t, 0> {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS rank<_Tp[]>
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY rank<_Tp[]>
     : public integral_constant<size_t, rank<_Tp>::value + 1> {};
-template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS rank<_Tp[_Np]>
+template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY rank<_Tp[_Np]>
     : public integral_constant<size_t, rank<_Tp>::value + 1> {};
 
 // extent
 
-template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TYPE_VIS extent
+template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TYPE_VIS_ONLY extent
     : public integral_constant<size_t, 0> {};
-template <class _Tp> struct _LIBCPP_TYPE_VIS extent<_Tp[], 0>
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY extent<_Tp[], 0>
     : public integral_constant<size_t, 0> {};
-template <class _Tp, unsigned _Ip> struct _LIBCPP_TYPE_VIS extent<_Tp[], _Ip>
+template <class _Tp, unsigned _Ip> struct _LIBCPP_TYPE_VIS_ONLY extent<_Tp[], _Ip>
     : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
-template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS extent<_Tp[_Np], 0>
+template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY extent<_Tp[_Np], 0>
     : public integral_constant<size_t, _Np> {};
-template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TYPE_VIS extent<_Tp[_Np], _Ip>
+template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TYPE_VIS_ONLY extent<_Tp[_Np], _Ip>
     : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
 
 // remove_extent
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_extent
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_extent
     {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_extent<_Tp[]>
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_extent<_Tp[]>
     {typedef _Tp type;};
-template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS remove_extent<_Tp[_Np]>
+template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY remove_extent<_Tp[_Np]>
     {typedef _Tp type;};
 
 #if _LIBCPP_STD_VER > 11
@@ -702,17 +708,42 @@ template <class _Tp> using remove_extent_t = typename remove_extent<_Tp>::type;
 
 // remove_all_extents
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_all_extents
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_all_extents
     {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TYPE_VIS remove_all_extents<_Tp[]>
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY remove_all_extents<_Tp[]>
     {typedef typename remove_all_extents<_Tp>::type type;};
-template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS remove_all_extents<_Tp[_Np]>
+template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS_ONLY remove_all_extents<_Tp[_Np]>
     {typedef typename remove_all_extents<_Tp>::type type;};
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
 #endif
 
+// decay
+
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY decay
+{
+private:
+    typedef typename remove_reference<_Tp>::type _Up;
+public:
+    typedef typename conditional
+                     <
+                         is_array<_Up>::value,
+                         typename remove_extent<_Up>::type*,
+                         typename conditional
+                         <
+                              is_function<_Up>::value,
+                              typename add_pointer<_Up>::type,
+                              typename remove_cv<_Up>::type
+                         >::type
+                     >::type type;
+};
+
+#if _LIBCPP_STD_VER > 11
+template <class _Tp> using decay_t = typename decay<_Tp>::type;
+#endif
+
 // is_abstract
 
 namespace __is_abstract_imp
@@ -726,14 +757,14 @@ struct __libcpp_abstract : public integral_constant<bool, sizeof(__is_abstract_i
 
 template <class _Tp> struct __libcpp_abstract<_Tp, false> : public false_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_abstract : public __libcpp_abstract<_Tp> {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_abstract : public __libcpp_abstract<_Tp> {};
 
 // is_base_of
 
 #ifdef _LIBCPP_HAS_IS_BASE_OF
 
 template <class _Bp, class _Dp>
-struct _LIBCPP_TYPE_VIS is_base_of
+struct _LIBCPP_TYPE_VIS_ONLY is_base_of
     : public integral_constant<bool, __is_base_of(_Bp, _Dp)> {};
 
 #else  // __has_feature(is_base_of)
@@ -757,7 +788,7 @@ template <class _Bp, class _Dp> __two __test(...);
 }
 
 template <class _Bp, class _Dp>
-struct _LIBCPP_TYPE_VIS is_base_of
+struct _LIBCPP_TYPE_VIS_ONLY is_base_of
     : public integral_constant<bool, is_class<_Bp>::value &&
                                      sizeof(__is_base_of_imp::__test<_Bp, _Dp>(0)) == 2> {};
 
@@ -767,7 +798,7 @@ struct _LIBCPP_TYPE_VIS is_base_of
 
 #if __has_feature(is_convertible_to)
 
-template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS is_convertible
+template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY is_convertible
     : public integral_constant<bool, __is_convertible_to(_T1, _T2) &&
                                      !is_abstract<_T2>::value> {};
 
@@ -873,7 +904,7 @@ template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 3> : public
 template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 3> : public false_type {};
 template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 3> : public true_type {};
 
-template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS is_convertible
+template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY is_convertible
     : public __is_convertible<_T1, _T2>
 {
     static const size_t __complete_check1 = __is_convertible_check<_T1>::__v;
@@ -887,7 +918,7 @@ template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS is_convertible
 #if __has_feature(is_empty)
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_empty
+struct _LIBCPP_TYPE_VIS_ONLY is_empty
     : public integral_constant<bool, __is_empty(_Tp)> {};
 
 #else  // __has_feature(is_empty)
@@ -909,7 +940,7 @@ struct __libcpp_empty : public integral_constant<bool, sizeof(__is_empty1<_Tp>)
 
 template <class _Tp> struct __libcpp_empty<_Tp, false> : public false_type {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_empty : public __libcpp_empty<_Tp> {};
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_empty : public __libcpp_empty<_Tp> {};
 
 #endif  // __has_feature(is_empty)
 
@@ -918,7 +949,7 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_empty : public __libcpp_empty<_T
 #if __has_feature(is_polymorphic)
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_polymorphic
+struct _LIBCPP_TYPE_VIS_ONLY is_polymorphic
     : public integral_constant<bool, __is_polymorphic(_Tp)> {};
 
 #else
@@ -928,7 +959,7 @@ template<typename _Tp> char &__is_polymorphic_impl(
                        int>::type);
 template<typename _Tp> __two &__is_polymorphic_impl(...);
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_polymorphic
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_polymorphic
     : public integral_constant<bool, sizeof(__is_polymorphic_impl<_Tp>(0)) == 1> {};
 
 #endif // __has_feature(is_polymorphic)
@@ -937,19 +968,19 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_polymorphic
 
 #if __has_feature(has_virtual_destructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS has_virtual_destructor
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY has_virtual_destructor
     : public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
 
 #else  // _LIBCPP_HAS_TYPE_TRAITS
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS has_virtual_destructor
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY has_virtual_destructor
     : public false_type {};
 
 #endif  // _LIBCPP_HAS_TYPE_TRAITS
 
 // alignment_of
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS alignment_of
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY alignment_of
     : public integral_constant<size_t, __alignof__(_Tp)> {};
 
 // aligned_storage
@@ -1037,7 +1068,7 @@ struct __find_max_align<__type_list<_Hp, _Tp>, _Len>
     : public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {};
 
 template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
-struct _LIBCPP_TYPE_VIS aligned_storage
+struct _LIBCPP_TYPE_VIS_ONLY aligned_storage
 {
     typedef typename __find_pod<__all_types, _Align>::type _Aligner;
     static_assert(!is_void<_Aligner>::value, "");
@@ -1055,7 +1086,7 @@ template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::valu
 
 #define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n) \
 template <size_t _Len>\
-struct _LIBCPP_TYPE_VIS aligned_storage<_Len, n>\
+struct _LIBCPP_TYPE_VIS_ONLY aligned_storage<_Len, n>\
 {\
     struct _ALIGNAS(n) type\
     {\
@@ -1274,7 +1305,7 @@ template <> struct __make_signed<  signed long long, true> {typedef long long ty
 template <> struct __make_signed<unsigned long long, true> {typedef long long type;};
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS make_signed
+struct _LIBCPP_TYPE_VIS_ONLY make_signed
 {
     typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type;
 };
@@ -1303,7 +1334,7 @@ template <> struct __make_unsigned<  signed long long, true> {typedef unsigned l
 template <> struct __make_unsigned<unsigned long long, true> {typedef unsigned long long type;};
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS make_unsigned
+struct _LIBCPP_TYPE_VIS_ONLY make_unsigned
 {
     typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
 };
@@ -1315,21 +1346,21 @@ template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type;
 #ifdef _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Tp, class _Up = void, class V = void>
-struct _LIBCPP_TYPE_VIS common_type
+struct _LIBCPP_TYPE_VIS_ONLY common_type
 {
 public:
     typedef typename common_type<typename common_type<_Tp, _Up>::type, V>::type type;
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS common_type<_Tp, void, void>
+struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, void, void>
 {
 public:
     typedef _Tp type;
 };
 
 template <class _Tp, class _Up>
-struct _LIBCPP_TYPE_VIS common_type<_Tp, _Up, void>
+struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, _Up, void>
 {
 private:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1348,24 +1379,24 @@ public:
 template <class ..._Tp> struct common_type;
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS common_type<_Tp>
+struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp>
 {
-    typedef _Tp type;
+    typedef typename decay<_Tp>::type type;
 };
 
 template <class _Tp, class _Up>
-struct _LIBCPP_TYPE_VIS common_type<_Tp, _Up>
+struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, _Up>
 {
 private:
     static _Tp&& __t();
     static _Up&& __u();
     static bool __f();
 public:
-    typedef typename remove_reference<decltype(__f() ? __t() : __u())>::type type;
+    typedef typename decay<decltype(__f() ? __t() : __u())>::type type;
 };
 
 template <class _Tp, class _Up, class ..._Vp>
-struct _LIBCPP_TYPE_VIS common_type<_Tp, _Up, _Vp...>
+struct _LIBCPP_TYPE_VIS_ONLY common_type<_Tp, _Up, _Vp...>
 {
     typedef typename common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type;
 };
@@ -1378,8 +1409,10 @@ template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type
 
 // is_assignable
 
+template<typename, typename T> struct __select_2nd { typedef T type; };
+
 template <class _Tp, class _Arg>
-decltype((_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>(), true_type()))
+typename __select_2nd<decltype((_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>())), true_type>::type
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 __is_assignable_test(_Tp&&, _Arg&&);
 #else
@@ -1413,13 +1446,13 @@ struct is_assignable
 
 // is_copy_assignable
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_copy_assignable
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_copy_assignable
     : public is_assignable<typename add_lvalue_reference<_Tp>::type,
                      const typename add_lvalue_reference<_Tp>::type> {};
 
 // is_move_assignable
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_move_assignable
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_move_assignable
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     : public is_assignable<typename add_lvalue_reference<_Tp>::type,
                      const typename add_rvalue_reference<_Tp>::type> {};
@@ -1446,7 +1479,8 @@ __is_destructible_test(_Tp&);
 false_type
 __is_destructible_test(__any);
 
-template <class _Tp, bool = is_void<_Tp>::value || is_abstract<_Tp>::value>
+template <class _Tp, bool = is_void<_Tp>::value || is_abstract<_Tp>::value
+                                                || is_function<_Tp>::value>
 struct __destructible_imp
     : public common_type
         <
@@ -1461,6 +1495,10 @@ template <class _Tp>
 struct is_destructible
     : public __destructible_imp<_Tp> {};
 
+template <class _Tp>
+struct is_destructible<_Tp[]>
+    : public false_type {};
+
 // move
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1533,29 +1571,6 @@ public:
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _Tp>
-struct _LIBCPP_TYPE_VIS decay
-{
-private:
-    typedef typename remove_reference<_Tp>::type _Up;
-public:
-    typedef typename conditional
-                     <
-                         is_array<_Up>::value,
-                         typename remove_extent<_Up>::type*,
-                         typename conditional
-                         <
-                              is_function<_Up>::value,
-                              typename add_pointer<_Up>::type,
-                              typename remove_cv<_Up>::type
-                         >::type
-                     >::type type;
-};
-
-#if _LIBCPP_STD_VER > 11
-template <class _Tp> using decay_t = typename decay<_Tp>::type;
-#endif
-
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp>
@@ -1917,7 +1932,7 @@ class __result_of<_Fn(_Tp, _A0, _A1, _A2), false, true>  // _Fn must be member p
 // result_of
 
 template <class _Fn>
-class _LIBCPP_TYPE_VIS result_of<_Fn()>
+class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn()>
     : public __result_of<_Fn(),
                          is_class<typename remove_reference<_Fn>::type>::value ||
                          is_function<typename remove_reference<_Fn>::type>::value,
@@ -1927,7 +1942,7 @@ class _LIBCPP_TYPE_VIS result_of<_Fn()>
 };
 
 template <class _Fn, class _A0>
-class _LIBCPP_TYPE_VIS result_of<_Fn(_A0)>
+class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn(_A0)>
     : public __result_of<_Fn(_A0),
                          is_class<typename remove_reference<_Fn>::type>::value ||
                          is_function<typename remove_reference<_Fn>::type>::value,
@@ -1937,7 +1952,7 @@ class _LIBCPP_TYPE_VIS result_of<_Fn(_A0)>
 };
 
 template <class _Fn, class _A0, class _A1>
-class _LIBCPP_TYPE_VIS result_of<_Fn(_A0, _A1)>
+class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn(_A0, _A1)>
     : public __result_of<_Fn(_A0, _A1),
                          is_class<typename remove_reference<_Fn>::type>::value ||
                          is_function<typename remove_reference<_Fn>::type>::value,
@@ -1947,7 +1962,7 @@ class _LIBCPP_TYPE_VIS result_of<_Fn(_A0, _A1)>
 };
 
 template <class _Fn, class _A0, class _A1, class _A2>
-class _LIBCPP_TYPE_VIS result_of<_Fn(_A0, _A1, _A2)>
+class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn(_A0, _A1, _A2)>
     : public __result_of<_Fn(_A0, _A1, _A2),
                          is_class<typename remove_reference<_Fn>::type>::value ||
                          is_function<typename remove_reference<_Fn>::type>::value,
@@ -1964,8 +1979,6 @@ class _LIBCPP_TYPE_VIS result_of<_Fn(_A0, _A1, _A2)>
 
 //      main is_constructible test
 
-template<typename, typename T> struct __select_2nd { typedef T type; };
-
 template <class _Tp, class ..._Args>
 typename __select_2nd<decltype(_VSTD::move(_Tp(_VSTD::declval<_Args>()...))), true_type>::type
 __is_constructible_test(_Tp&&, _Args&& ...);
@@ -2052,7 +2065,7 @@ struct __contains_void<_A0, _Args...>
 //      is_constructible entry point
 
 template <class _Tp, class... _Args>
-struct _LIBCPP_TYPE_VIS is_constructible
+struct _LIBCPP_TYPE_VIS_ONLY is_constructible
     : public __is_constructible_void_check<__contains_void<_Tp, _Args...>::value
                                         || is_abstract<_Tp>::value,
                                            _Tp, _Args...>
@@ -2200,7 +2213,7 @@ struct __nat {};
 
 template <class _Tp, class _A0 = __is_construct::__nat,
                      class _A1 = __is_construct::__nat>
-struct _LIBCPP_TYPE_VIS is_constructible
+struct _LIBCPP_TYPE_VIS_ONLY is_constructible
     : public __is_constructible2_void_check<is_void<_Tp>::value
                                         || is_abstract<_Tp>::value
                                         || is_function<_Tp>::value
@@ -2210,7 +2223,7 @@ struct _LIBCPP_TYPE_VIS is_constructible
     {};
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_constructible<_Tp, __is_construct::__nat, __is_construct::__nat>
+struct _LIBCPP_TYPE_VIS_ONLY is_constructible<_Tp, __is_construct::__nat, __is_construct::__nat>
     : public __is_constructible0_void_check<is_void<_Tp>::value
                                         || is_abstract<_Tp>::value
                                         || is_function<_Tp>::value,
@@ -2218,7 +2231,7 @@ struct _LIBCPP_TYPE_VIS is_constructible<_Tp, __is_construct::__nat, __is_constr
     {};
 
 template <class _Tp, class _A0>
-struct _LIBCPP_TYPE_VIS is_constructible<_Tp, _A0, __is_construct::__nat>
+struct _LIBCPP_TYPE_VIS_ONLY is_constructible<_Tp, _A0, __is_construct::__nat>
     : public __is_constructible1_void_check<is_void<_Tp>::value
                                         || is_abstract<_Tp>::value
                                         || is_function<_Tp>::value
@@ -2266,21 +2279,21 @@ struct __is_constructible2_imp<false, _Ap[], _A0, _A1>
 // is_default_constructible
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_default_constructible
+struct _LIBCPP_TYPE_VIS_ONLY is_default_constructible
     : public is_constructible<_Tp>
     {};
 
 // is_copy_constructible
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_copy_constructible
+struct _LIBCPP_TYPE_VIS_ONLY is_copy_constructible
     : public is_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
     {};
 
 // is_move_constructible
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_move_constructible
+struct _LIBCPP_TYPE_VIS_ONLY is_move_constructible
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     : public is_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
 #else
@@ -2295,7 +2308,7 @@ struct _LIBCPP_TYPE_VIS is_move_constructible
 #if __has_feature(is_trivially_constructible)
 
 template <class _Tp, class... _Args>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible
     : integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)>
 {
 };
@@ -2303,13 +2316,13 @@ struct _LIBCPP_TYPE_VIS is_trivially_constructible
 #else  // !__has_feature(is_trivially_constructible)
 
 template <class _Tp, class... _Args>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible
     : false_type
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp>
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp>
 #if __has_feature(has_trivial_constructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
     : integral_constant<bool, __has_trivial_constructor(_Tp)>
 #else
@@ -2320,22 +2333,22 @@ struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp>
 
 template <class _Tp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&&>
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp&&>
 #else
-struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp>
 #endif
     : integral_constant<bool, is_scalar<_Tp>::value>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, const _Tp&>
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, const _Tp&>
     : integral_constant<bool, is_scalar<_Tp>::value>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&>
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp&>
     : integral_constant<bool, is_scalar<_Tp>::value>
 {
 };
@@ -2346,7 +2359,7 @@ struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&>
 
 template <class _Tp, class _A0 = __is_construct::__nat,
                      class _A1 = __is_construct::__nat>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible
     : false_type
 {
 };
@@ -2354,28 +2367,28 @@ struct _LIBCPP_TYPE_VIS is_trivially_constructible
 #if __has_feature(is_trivially_constructible)
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, __is_construct::__nat,
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, __is_construct::__nat,
                                                        __is_construct::__nat>
     : integral_constant<bool, __is_trivially_constructible(_Tp)>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp,
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp,
                                                        __is_construct::__nat>
     : integral_constant<bool, __is_trivially_constructible(_Tp, _Tp)>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, const _Tp&,
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, const _Tp&,
                                                        __is_construct::__nat>
     : integral_constant<bool, __is_trivially_constructible(_Tp, const _Tp&)>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&,
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp&,
                                                        __is_construct::__nat>
     : integral_constant<bool, __is_trivially_constructible(_Tp, _Tp&)>
 {
@@ -2384,28 +2397,28 @@ struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&,
 #else  // !__has_feature(is_trivially_constructible)
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, __is_construct::__nat,
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, __is_construct::__nat,
                                                        __is_construct::__nat>
     : integral_constant<bool, is_scalar<_Tp>::value>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp,
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp,
                                                        __is_construct::__nat>
     : integral_constant<bool, is_scalar<_Tp>::value>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, const _Tp&,
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, const _Tp&,
                                                        __is_construct::__nat>
     : integral_constant<bool, is_scalar<_Tp>::value>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&,
+struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, _Tp&,
                                                        __is_construct::__nat>
     : integral_constant<bool, is_scalar<_Tp>::value>
 {
@@ -2417,19 +2430,19 @@ struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&,
 
 // is_trivially_default_constructible
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_default_constructible
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_default_constructible
     : public is_trivially_constructible<_Tp>
     {};
 
 // is_trivially_copy_constructible
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_copy_constructible
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_copy_constructible
     : public is_trivially_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
     {};
 
 // is_trivially_move_constructible
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_move_constructible
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_move_constructible
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     : public is_trivially_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
 #else
@@ -2477,14 +2490,14 @@ struct is_trivially_assignable<_Tp&, _Tp&&>
 
 // is_trivially_copy_assignable
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_copy_assignable
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_copy_assignable
     : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
                                const typename add_lvalue_reference<_Tp>::type>
     {};
 
 // is_trivially_move_assignable
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_move_assignable
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_move_assignable
     : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
                                      typename add_rvalue_reference<_Tp>::type>
@@ -2497,7 +2510,7 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_move_assignable
 
 #if __has_feature(has_trivial_destructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_destructible
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_destructible
     : public integral_constant<bool, __has_trivial_destructor(_Tp)> {};
 
 #else  // _LIBCPP_HAS_TYPE_TRAITS
@@ -2506,7 +2519,7 @@ template <class _Tp> struct __libcpp_trivial_destructor
     : public integral_constant<bool, is_scalar<_Tp>::value ||
                                      is_reference<_Tp>::value> {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_destructible
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_destructible
     : public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {};
 
 #endif  // _LIBCPP_HAS_TYPE_TRAITS
@@ -2532,13 +2545,13 @@ struct __is_nothrow_constructible<false, _Tp, _Args...>
 };
 
 template <class _Tp, class... _Args>
-struct _LIBCPP_TYPE_VIS is_nothrow_constructible
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible
     : __is_nothrow_constructible<is_constructible<_Tp, _Args...>::value, _Tp, _Args...>
 {
 };
 
 template <class _Tp, size_t _Ns>
-struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp[_Ns]>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp[_Ns]>
     : __is_nothrow_constructible<is_constructible<_Tp>::value, _Tp>
 {
 };
@@ -2546,13 +2559,13 @@ struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp[_Ns]>
 #else  // __has_feature(cxx_noexcept)
 
 template <class _Tp, class... _Args>
-struct _LIBCPP_TYPE_VIS is_nothrow_constructible
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible
     : false_type
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp>
 #if __has_feature(has_nothrow_constructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
     : integral_constant<bool, __has_nothrow_constructor(_Tp)>
 #else
@@ -2563,9 +2576,9 @@ struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp>
 
 template <class _Tp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp&&>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp&&>
 #else
-struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp>
 #endif
 #if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
     : integral_constant<bool, __has_nothrow_copy(_Tp)>
@@ -2576,7 +2589,7 @@ struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp>
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, const _Tp&>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, const _Tp&>
 #if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
     : integral_constant<bool, __has_nothrow_copy(_Tp)>
 #else
@@ -2586,7 +2599,7 @@ struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, const _Tp&>
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp&>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp&>
 #if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
     : integral_constant<bool, __has_nothrow_copy(_Tp)>
 #else
@@ -2601,13 +2614,13 @@ struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp&>
 
 template <class _Tp, class _A0 = __is_construct::__nat,
                      class _A1 = __is_construct::__nat>
-struct _LIBCPP_TYPE_VIS is_nothrow_constructible
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible
     : false_type
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, __is_construct::__nat,
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, __is_construct::__nat,
                                                        __is_construct::__nat>
 #if __has_feature(has_nothrow_constructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
     : integral_constant<bool, __has_nothrow_constructor(_Tp)>
@@ -2618,7 +2631,7 @@ struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, __is_construct::__nat,
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp,
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp,
                                                        __is_construct::__nat>
 #if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
     : integral_constant<bool, __has_nothrow_copy(_Tp)>
@@ -2629,7 +2642,7 @@ struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp,
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, const _Tp&,
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, const _Tp&,
                                                        __is_construct::__nat>
 #if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
     : integral_constant<bool, __has_nothrow_copy(_Tp)>
@@ -2640,7 +2653,7 @@ struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, const _Tp&,
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp&,
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_constructible<_Tp, _Tp&,
                                                        __is_construct::__nat>
 #if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
     : integral_constant<bool, __has_nothrow_copy(_Tp)>
@@ -2654,19 +2667,19 @@ struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp&,
 
 // is_nothrow_default_constructible
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_nothrow_default_constructible
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_default_constructible
     : public is_nothrow_constructible<_Tp>
     {};
 
 // is_nothrow_copy_constructible
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_nothrow_copy_constructible
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_copy_constructible
     : public is_nothrow_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
     {};
 
 // is_nothrow_move_constructible
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_nothrow_move_constructible
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_move_constructible
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     : public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
 #else
@@ -2693,7 +2706,7 @@ struct __is_nothrow_assignable<true, _Tp, _Arg>
 };
 
 template <class _Tp, class _Arg>
-struct _LIBCPP_TYPE_VIS is_nothrow_assignable
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable
     : public __is_nothrow_assignable<is_assignable<_Tp, _Arg>::value, _Tp, _Arg>
 {
 };
@@ -2701,11 +2714,11 @@ struct _LIBCPP_TYPE_VIS is_nothrow_assignable
 #else  // __has_feature(cxx_noexcept)
 
 template <class _Tp, class _Arg>
-struct _LIBCPP_TYPE_VIS is_nothrow_assignable
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable
     : public false_type {};
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_nothrow_assignable<_Tp&, _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable<_Tp&, _Tp>
 #if __has_feature(has_nothrow_assign) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
     : integral_constant<bool, __has_nothrow_assign(_Tp)> {};
 #else
@@ -2713,7 +2726,7 @@ struct _LIBCPP_TYPE_VIS is_nothrow_assignable<_Tp&, _Tp>
 #endif
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_nothrow_assignable<_Tp&, _Tp&>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable<_Tp&, _Tp&>
 #if __has_feature(has_nothrow_assign) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
     : integral_constant<bool, __has_nothrow_assign(_Tp)> {};
 #else
@@ -2721,7 +2734,7 @@ struct _LIBCPP_TYPE_VIS is_nothrow_assignable<_Tp&, _Tp&>
 #endif
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_nothrow_assignable<_Tp&, const _Tp&>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_assignable<_Tp&, const _Tp&>
 #if __has_feature(has_nothrow_assign) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
     : integral_constant<bool, __has_nothrow_assign(_Tp)> {};
 #else
@@ -2744,14 +2757,14 @@ struct is_nothrow_assignable<_Tp&, _Tp&&>
 
 // is_nothrow_copy_assignable
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_nothrow_copy_assignable
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_copy_assignable
     : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
                                const typename add_lvalue_reference<_Tp>::type>
     {};
 
 // is_nothrow_move_assignable
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_nothrow_move_assignable
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_move_assignable
     : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
                                      typename add_rvalue_reference<_Tp>::type>
@@ -2779,19 +2792,19 @@ struct __is_nothrow_destructible<true, _Tp>
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_nothrow_destructible
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible
     : public __is_nothrow_destructible<is_destructible<_Tp>::value, _Tp>
 {
 };
 
 template <class _Tp, size_t _Ns>
-struct _LIBCPP_TYPE_VIS is_nothrow_destructible<_Tp[_Ns]>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible<_Tp[_Ns]>
     : public is_nothrow_destructible<_Tp>
 {
 };
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_nothrow_destructible<_Tp&>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible<_Tp&>
     : public true_type
 {
 };
@@ -2799,7 +2812,7 @@ struct _LIBCPP_TYPE_VIS is_nothrow_destructible<_Tp&>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp>
-struct _LIBCPP_TYPE_VIS is_nothrow_destructible<_Tp&&>
+struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible<_Tp&&>
     : public true_type
 {
 };
@@ -2812,7 +2825,7 @@ template <class _Tp> struct __libcpp_nothrow_destructor
     : public integral_constant<bool, is_scalar<_Tp>::value ||
                                      is_reference<_Tp>::value> {};
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_nothrow_destructible
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible
     : public __libcpp_nothrow_destructor<typename remove_all_extents<_Tp>::type> {};
 
 #endif
@@ -2821,12 +2834,12 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_nothrow_destructible
 
 #if __has_feature(is_pod) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_pod
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_pod
     : public integral_constant<bool, __is_pod(_Tp)> {};
 
 #else  // _LIBCPP_HAS_TYPE_TRAITS
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_pod
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_pod
     : public integral_constant<bool, is_trivially_default_constructible<_Tp>::value   &&
                                      is_trivially_copy_constructible<_Tp>::value      &&
                                      is_trivially_copy_assignable<_Tp>::value    &&
@@ -2836,7 +2849,7 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_pod
 
 // is_literal_type;
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_literal_type
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_literal_type
 #if __has_feature(is_literal)
     : public integral_constant<bool, __is_literal(_Tp)>
 #else
@@ -2847,7 +2860,7 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_literal_type
     
 // is_standard_layout;
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_standard_layout
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_standard_layout
 #if __has_feature(is_standard_layout)
     : public integral_constant<bool, __is_standard_layout(_Tp)>
 #else
@@ -2857,7 +2870,7 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_standard_layout
     
 // is_trivially_copyable;
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_copyable
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_copyable
 #if __has_feature(is_trivially_copyable)
     : public integral_constant<bool, __is_trivially_copyable(_Tp)>
 #else
@@ -2867,7 +2880,7 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_copyable
     
 // is_trivial;
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivial
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivial
 #if __has_feature(is_trivial)
     : public integral_constant<bool, __is_trivial(_Tp)>
 #else
@@ -2924,12 +2937,22 @@ struct __check_complete<_Rp (*)(_Param...)>
 {
 };
 
+template <class ..._Param>
+struct __check_complete<void (*)(_Param...)>
+{
+};
+
 template <class _Rp, class ..._Param>
 struct __check_complete<_Rp (_Param...)>
     : private __check_complete<_Rp>
 {
 };
 
+template <class ..._Param>
+struct __check_complete<void (_Param...)>
+{
+};
+
 template <class _Rp, class _Class, class ..._Param>
 struct __check_complete<_Rp (_Class::*)(_Param...)>
     : private __check_complete<_Class>
@@ -3124,7 +3147,7 @@ struct __invoke_of
 };
 
 template <class _Fp, class ..._Args>
-class _LIBCPP_TYPE_VIS result_of<_Fp(_Args...)>
+class _LIBCPP_TYPE_VIS_ONLY result_of<_Fp(_Args...)>
     : public __invoke_of<_Fp, _Args...>
 {
 };
@@ -3243,6 +3266,27 @@ struct underlying_type
 
 #endif // _LIBCXX_UNDERLYING_TYPE
 
+#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+
+template <class _Tp>
+struct __has_operator_addressof_imp
+{
+    template <class>
+        static auto __test(__any) -> false_type;
+    template <class _Up>
+        static auto __test(_Up* __u)
+            -> typename __select_2nd<decltype(__u->operator&()), true_type>::type;
+
+    static const bool value = decltype(__test<_Tp>(nullptr))::value;
+};
+
+template <class _Tp>
+struct __has_operator_addressof
+    : public integral_constant<bool, __has_operator_addressof_imp<_Tp>::value>
+{};
+
+#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_TYPE_TRAITS
diff --git a/system/include/libcxx/typeindex b/system/include/libcxx/typeindex
index 67462b7424939..d4d6ca96ba4d3 100644
--- a/system/include/libcxx/typeindex
+++ b/system/include/libcxx/typeindex
@@ -55,7 +55,7 @@ struct hash<type_index>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_TYPE_VIS type_index
+class _LIBCPP_TYPE_VIS_ONLY type_index
 {
     const type_info* __t_;
 public:
@@ -87,10 +87,10 @@ public:
     const char* name() const _NOEXCEPT {return __t_->name();}
 };
 
-template <class _Tp> struct _LIBCPP_TYPE_VIS hash;
+template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY hash;
 
 template <>
-struct _LIBCPP_TYPE_VIS hash<type_index>
+struct _LIBCPP_TYPE_VIS_ONLY hash<type_index>
     : public unary_function<type_index, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
diff --git a/system/include/libcxx/unordered_map b/system/include/libcxx/unordered_map
index eebf2f5ea612c..78fee4811fadf 100644
--- a/system/include/libcxx/unordered_map
+++ b/system/include/libcxx/unordered_map
@@ -69,6 +69,22 @@ public:
     unordered_map(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_map(size_type n, const allocator_type& a)
+      : unordered_map(n, hasher(), key_equal(), a) {}  // C++14
+    unordered_map(size_type n, const hasher& hf, const allocator_type& a)
+      : unordered_map(n, hf, key_equal(), a) {}  // C++14
+    template <class InputIterator>
+      unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
+      : unordered_map(f, l, n, hasher(), key_equal(), a) {}  // C++14
+    template <class InputIterator>
+      unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf, 
+        const allocator_type& a)
+      : unordered_map(f, l, n, hf, key_equal(), a) {}  // C++14
+    unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
+      : unordered_map(il, n, hasher(), key_equal(), a) {}  // C++14
+    unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf, 
+      const allocator_type& a)
+      : unordered_map(il, n, hf, key_equal(), a) {}  // C++14
     ~unordered_map();
     unordered_map& operator=(const unordered_map&);
     unordered_map& operator=(unordered_map&&)
@@ -217,6 +233,22 @@ public:
     unordered_multimap(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_multimap(size_type n, const allocator_type& a)
+      : unordered_multimap(n, hasher(), key_equal(), a) {}  // C++14
+    unordered_multimap(size_type n, const hasher& hf, const allocator_type& a)
+      : unordered_multimap(n, hf, key_equal(), a) {}  // C++14
+    template <class InputIterator>
+      unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
+      : unordered_multimap(f, l, n, hasher(), key_equal(), a) {}  // C++14
+    template <class InputIterator>
+      unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf, 
+        const allocator_type& a)
+      : unordered_multimap(f, l, n, hf, key_equal(), a) {}  // C++14
+    unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a)
+      : unordered_multimap(il, n, hasher(), key_equal(), a) {}  // C++14
+    unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf, 
+      const allocator_type& a)
+      : unordered_multimap(il, n, hf, key_equal(), a) {}  // C++14
     ~unordered_multimap();
     unordered_multimap& operator=(const unordered_multimap&);
     unordered_multimap& operator=(unordered_multimap&&)
@@ -493,8 +525,73 @@ public:
     }
 };
 
+#if __cplusplus >= 201103L
+
+template <class _Key, class _Tp>
+union __hash_value_type
+{
+    typedef _Key                                     key_type;
+    typedef _Tp                                      mapped_type;
+    typedef pair<const key_type, mapped_type>        value_type;
+    typedef pair<key_type, mapped_type>              __nc_value_type;
+
+    value_type __cc;
+    __nc_value_type __nc;
+
+    template <class ..._Args>
+    _LIBCPP_INLINE_VISIBILITY
+    __hash_value_type(_Args&& ...__args)
+        : __cc(std::forward<_Args>(__args)...) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __hash_value_type(const __hash_value_type& __v)
+        : __cc(__v.__cc) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __hash_value_type(__hash_value_type&& __v)
+        : __nc(std::move(__v.__nc)) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __hash_value_type& operator=(const __hash_value_type& __v)
+        {__nc = __v.__cc; return *this;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __hash_value_type& operator=(__hash_value_type&& __v)
+        {__nc = std::move(__v.__nc); return *this;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    ~__hash_value_type() {__cc.~value_type();}
+};
+
+#else
+
+template <class _Key, class _Tp>
+struct __hash_value_type
+{
+    typedef _Key                                     key_type;
+    typedef _Tp                                      mapped_type;
+    typedef pair<const key_type, mapped_type>        value_type;
+
+    value_type __cc;
+
+    _LIBCPP_INLINE_VISIBILITY
+    __hash_value_type() {}
+
+    template <class _A0>
+    _LIBCPP_INLINE_VISIBILITY
+    __hash_value_type(const _A0& __a0)
+        : __cc(__a0) {}
+
+    template <class _A0, class _A1>
+    _LIBCPP_INLINE_VISIBILITY
+    __hash_value_type(const _A0& __a0, const _A1& __a1)
+        : __cc(__a0, __a1) {}
+};
+
+#endif
+
 template <class _HashIterator>
-class _LIBCPP_TYPE_VIS __hash_map_iterator
+class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator
 {
     _HashIterator __i_;
 
@@ -542,15 +639,15 @@ public:
         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_TYPE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_multimap;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_const_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_map_const_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator;
 };
 
 template <class _HashIterator>
-class _LIBCPP_TYPE_VIS __hash_map_const_iterator
+class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator
 {
     _HashIterator __i_;
 
@@ -603,15 +700,15 @@ public:
         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_TYPE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_multimap;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_const_iterator;
-    template <class> friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY __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_TYPE_VIS unordered_map
+class _LIBCPP_TYPE_VIS_ONLY unordered_map
 {
 public:
     // types
@@ -628,49 +725,7 @@ public:
                   "Invalid allocator::value_type");
 
 private:
-#if __cplusplus >= 201103L
-    union __value_type
-    {
-        typedef typename unordered_map::value_type value_type;
-        typedef typename unordered_map::__nc_value_type __nc_value_type;
-        value_type __cc;
-        __nc_value_type __nc;
-
-        template <class ..._Args>
-        __value_type(_Args&& ...__args)
-            : __cc(std::forward<_Args>(__args)...) {}
-
-        __value_type(const __value_type& __v)
-            : __cc(std::move(__v.__cc)) {}
-
-        __value_type(__value_type&& __v)
-            : __nc(std::move(__v.__nc)) {}
-
-        __value_type& operator=(const __value_type& __v)
-            {__nc = __v.__cc; return *this;}
-
-        __value_type& operator=(__value_type&& __v)
-            {__nc = std::move(__v.__nc); return *this;}
-
-        ~__value_type() {__cc.~value_type();}
-    };
-#else
-    struct __value_type
-    {
-        typedef typename unordered_map::value_type value_type;
-        value_type __cc;
-
-        __value_type() {}
-
-        template <class _A0>
-        __value_type(const _A0& __a0)
-            : __cc(__a0) {}
-
-        template <class _A0, class _A1>
-        __value_type(const _A0& __a0, const _A1& __a1)
-            : __cc(__a0, __a1) {}
-    };
-#endif
+    typedef __hash_value_type<key_type, mapped_type>                 __value_type;
     typedef __unordered_map_hasher<key_type, __value_type, hasher>   __hasher;
     typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal;
     typedef typename allocator_traits<allocator_type>::template
@@ -745,6 +800,30 @@ public:
                   const hasher& __hf, const key_equal& __eql,
                   const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#if _LIBCPP_STD_VER > 11
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_map(size_type __n, const allocator_type& __a)
+      : unordered_map(__n, hasher(), key_equal(), __a) {}
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_map(size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_map(__n, __hf, key_equal(), __a) {}
+    template <class _InputIterator>
+    _LIBCPP_INLINE_VISIBILITY
+      unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
+      : unordered_map(__first, __last, __n, hasher(), key_equal(), __a) {}
+    template <class _InputIterator>
+    _LIBCPP_INLINE_VISIBILITY
+      unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, 
+        const allocator_type& __a)
+      : unordered_map(__first, __last, __n, __hf, key_equal(), __a) {}
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_map(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
+      : unordered_map(__il, __n, hasher(), key_equal(), __a) {}
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_map(initializer_list<value_type> __il, size_type __n, const hasher& __hf, 
+      const allocator_type& __a)
+      : unordered_map(__il, __n, __hf, key_equal(), __a) {}
+#endif
     // ~unordered_map() = default;
     _LIBCPP_INLINE_VISIBILITY
     unordered_map& operator=(const unordered_map& __u)
@@ -1211,7 +1290,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(key_ty
     __h.get_deleter().__first_constructed = true;
     __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second));
     __h.get_deleter().__second_constructed = true;
-    return _VSTD::move(__h);
+    return __h;
 }
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
@@ -1258,7 +1337,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(const
     __h.get_deleter().__first_constructed = true;
     __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second));
     __h.get_deleter().__second_constructed = true;
-    return _VSTD::move(__h);
+    return _VSTD::move(__h);  // explicitly moved for C++03
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
@@ -1366,7 +1445,7 @@ operator!=(const unordered_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_TYPE_VIS unordered_multimap
+class _LIBCPP_TYPE_VIS_ONLY unordered_multimap
 {
 public:
     // types
@@ -1383,49 +1462,7 @@ public:
                   "Invalid allocator::value_type");
 
 private:
-#if __cplusplus >= 201103L
-    union __value_type
-    {
-        typedef typename unordered_multimap::value_type value_type;
-        typedef typename unordered_multimap::__nc_value_type __nc_value_type;
-        value_type __cc;
-        __nc_value_type __nc;
-
-        template <class ..._Args>
-        __value_type(_Args&& ...__args)
-            : __cc(std::forward<_Args>(__args)...) {}
-
-        __value_type(const __value_type& __v)
-            : __cc(std::move(__v.__cc)) {}
-
-        __value_type(__value_type&& __v)
-            : __nc(std::move(__v.__nc)) {}
-
-        __value_type& operator=(const __value_type& __v)
-            {__nc = __v.__cc; return *this;}
-
-        __value_type& operator=(__value_type&& __v)
-            {__nc = std::move(__v.__nc); return *this;}
-
-        ~__value_type() {__cc.~value_type();}
-    };
-#else
-    struct __value_type
-    {
-        typedef typename unordered_multimap::value_type value_type;
-        value_type __cc;
-
-        __value_type() {}
-
-        template <class _A0>
-        __value_type(const _A0& __a0)
-            : __cc(__a0) {}
-
-        template <class _A0, class _A1>
-        __value_type(const _A0& __a0, const _A1& __a1)
-            : __cc(__a0, __a1) {}
-    };
-#endif
+    typedef __hash_value_type<key_type, mapped_type>                 __value_type;
     typedef __unordered_map_hasher<key_type, __value_type, hasher>   __hasher;
     typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal;
     typedef typename allocator_traits<allocator_type>::template
@@ -1499,6 +1536,30 @@ public:
                        const hasher& __hf, const key_equal& __eql,
                        const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#if _LIBCPP_STD_VER > 11
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_multimap(size_type __n, const allocator_type& __a)
+      : unordered_multimap(__n, hasher(), key_equal(), __a) {}
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_multimap(size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_multimap(__n, __hf, key_equal(), __a) {}
+    template <class _InputIterator>
+    _LIBCPP_INLINE_VISIBILITY
+      unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
+      : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a) {}
+    template <class _InputIterator>
+    _LIBCPP_INLINE_VISIBILITY
+      unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, 
+        const allocator_type& __a)
+      : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a) {}
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_multimap(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
+      : unordered_multimap(__il, __n, hasher(), key_equal(), __a) {}
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_multimap(initializer_list<value_type> __il, size_type __n, const hasher& __hf, 
+      const allocator_type& __a)
+      : unordered_multimap(__il, __n, __hf, key_equal(), __a) {}
+#endif
     // ~unordered_multimap() = default;
     _LIBCPP_INLINE_VISIBILITY
     unordered_multimap& operator=(const unordered_multimap& __u)
diff --git a/system/include/libcxx/unordered_set b/system/include/libcxx/unordered_set
index 8be36df6d23d9..fd378fa071457 100644
--- a/system/include/libcxx/unordered_set
+++ b/system/include/libcxx/unordered_set
@@ -68,6 +68,16 @@ public:
     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(size_type n, const allocator_type& a); // C++14
+    unordered_set(size_type n, const hasher& hf, const allocator_type& a); // C++14
+    template <class InputIterator>
+      unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type& a); // C++14
+    template <class InputIterator>
+      unordered_set(InputIterator f, InputIterator l, size_type n, 
+                    const hasher& hf,  const allocator_type& a); // C++14
+    unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14
+    unordered_set(initializer_list<value_type> il, size_type n,
+                  const hasher& hf,  const allocator_type& a); // C++14
     ~unordered_set();
     unordered_set& operator=(const unordered_set&);
     unordered_set& operator=(unordered_set&&)
@@ -207,6 +217,16 @@ public:
     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(size_type n, const allocator_type& a); // C++14
+    unordered_multiset(size_type n, const hasher& hf, const allocator_type& a); // C++14
+    template <class InputIterator>
+      unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a); // C++14
+    template <class InputIterator>
+      unordered_multiset(InputIterator f, InputIterator l, size_type n,
+                         const hasher& hf, const allocator_type& a); // C++14
+    unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14
+    unordered_multiset(initializer_list<value_type> il, size_type n, 
+                       const hasher& hf,  const allocator_type& a); // C++14
     ~unordered_multiset();
     unordered_multiset& operator=(const unordered_multiset&);
     unordered_multiset& operator=(unordered_multiset&&)
@@ -313,7 +333,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
           class _Alloc = allocator<_Value> >
-class _LIBCPP_TYPE_VIS unordered_set
+class _LIBCPP_TYPE_VIS_ONLY unordered_set
 {
 public:
     // types
@@ -353,6 +373,14 @@ public:
         }
     explicit unordered_set(size_type __n, const hasher& __hf = hasher(),
                            const key_equal& __eql = key_equal());
+#if _LIBCPP_STD_VER > 11
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_set(size_type __n, const allocator_type& __a)
+        : unordered_set(__n, hasher(), key_equal(), __a) {}
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_set(size_type __n, const hasher& __hf, const allocator_type& __a)
+        : unordered_set(__n, __hf, key_equal(), __a) {}
+#endif
     unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql,
                   const allocator_type& __a);
     template <class _InputIterator>
@@ -365,6 +393,17 @@ public:
         unordered_set(_InputIterator __first, _InputIterator __last,
                       size_type __n, const hasher& __hf, const key_equal& __eql,
                       const allocator_type& __a);
+#if _LIBCPP_STD_VER > 11
+    template <class _InputIterator>
+    inline _LIBCPP_INLINE_VISIBILITY
+        unordered_set(_InputIterator __first, _InputIterator __last, 
+                    size_type __n, const allocator_type& __a)
+            : unordered_set(__first, __last, __n, hasher(), key_equal(), __a) {}
+    template <class _InputIterator>
+        unordered_set(_InputIterator __first, _InputIterator __last, 
+                      size_type __n, const hasher& __hf, const allocator_type& __a)
+            : unordered_set(__first, __last, __n, __hf, key_equal(), __a) {}
+#endif
     explicit unordered_set(const allocator_type& __a);
     unordered_set(const unordered_set& __u);
     unordered_set(const unordered_set& __u, const allocator_type& __a);
@@ -381,6 +420,16 @@ public:
     unordered_set(initializer_list<value_type> __il, size_type __n,
                   const hasher& __hf, const key_equal& __eql,
                   const allocator_type& __a);
+#if _LIBCPP_STD_VER > 11
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_set(initializer_list<value_type> __il, size_type __n,
+                                                      const allocator_type& __a)
+        : unordered_set(__il, __n, hasher(), key_equal(), __a) {}
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_set(initializer_list<value_type> __il, size_type __n, 
+                                  const hasher& __hf, const allocator_type& __a)
+        : unordered_set(__il, __n, __hf, key_equal(), __a) {}
+#endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     // ~unordered_set() = default;
     _LIBCPP_INLINE_VISIBILITY
@@ -819,7 +868,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_TYPE_VIS unordered_multiset
+class _LIBCPP_TYPE_VIS_ONLY unordered_multiset
 {
 public:
     // types
@@ -861,6 +910,14 @@ public:
                                 const key_equal& __eql = key_equal());
     unordered_multiset(size_type __n, const hasher& __hf,
                        const key_equal& __eql, const allocator_type& __a);
+#if _LIBCPP_STD_VER > 11
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset(size_type __n, const allocator_type& __a)
+        : unordered_multiset(__n, hasher(), key_equal(), __a) {}
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset(size_type __n, const hasher& __hf, const allocator_type& __a)
+        : unordered_multiset(__n, __hf, key_equal(), __a) {}
+#endif
     template <class _InputIterator>
         unordered_multiset(_InputIterator __first, _InputIterator __last);
     template <class _InputIterator>
@@ -871,6 +928,18 @@ public:
         unordered_multiset(_InputIterator __first, _InputIterator __last,
                       size_type __n , const hasher& __hf,
                       const key_equal& __eql, const allocator_type& __a);
+#if _LIBCPP_STD_VER > 11
+    template <class _InputIterator>
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset(_InputIterator __first, _InputIterator __last, 
+                       size_type __n, const allocator_type& __a)
+        : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a) {}
+    template <class _InputIterator>
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset(_InputIterator __first, _InputIterator __last,
+                       size_type __n, const hasher& __hf, const allocator_type& __a)
+        : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a) {}
+#endif
     explicit unordered_multiset(const allocator_type& __a);
     unordered_multiset(const unordered_multiset& __u);
     unordered_multiset(const unordered_multiset& __u, const allocator_type& __a);
@@ -887,6 +956,14 @@ public:
     unordered_multiset(initializer_list<value_type> __il, size_type __n,
                        const hasher& __hf, const key_equal& __eql,
                        const allocator_type& __a);
+#if _LIBCPP_STD_VER > 11
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
+      : unordered_multiset(__il, __n, hasher(), key_equal(), __a) {}
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_multiset(__il, __n, __hf, key_equal(), __a) {}
+#endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     // ~unordered_multiset() = default;
     _LIBCPP_INLINE_VISIBILITY
diff --git a/system/include/libcxx/utility b/system/include/libcxx/utility
index d36cf9dd76614..5fc2cf205bc2a 100644
--- a/system/include/libcxx/utility
+++ b/system/include/libcxx/utility
@@ -237,7 +237,7 @@ move_if_noexcept(_Tp& __x) _NOEXCEPT
     return _VSTD::move(__x);
 }
 
-struct _LIBCPP_TYPE_VIS piecewise_construct_t { };
+struct _LIBCPP_TYPE_VIS_ONLY piecewise_construct_t { };
 #if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_UTILITY)
 extern const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();
 #else
@@ -245,7 +245,7 @@ constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
 #endif
 
 template <class _T1, class _T2>
-struct _LIBCPP_TYPE_VIS pair
+struct _LIBCPP_TYPE_VIS_ONLY pair
 {
     typedef _T1 first_type;
     typedef _T2 second_type;
@@ -462,7 +462,7 @@ swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-template <class _Tp> class _LIBCPP_TYPE_VIS reference_wrapper;
+template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY reference_wrapper;
 
 template <class _Tp>
 struct ___make_pair_return
@@ -504,36 +504,36 @@ make_pair(_T1 __x, _T2 __y)
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _T1, class _T2>
-  class _LIBCPP_TYPE_VIS tuple_size<pair<_T1, _T2> >
+  class _LIBCPP_TYPE_VIS_ONLY tuple_size<pair<_T1, _T2> >
     : public integral_constant<size_t, 2> {};
 
 template <class _T1, class _T2>
-  class _LIBCPP_TYPE_VIS tuple_size<const pair<_T1, _T2> >
+  class _LIBCPP_TYPE_VIS_ONLY tuple_size<const pair<_T1, _T2> >
     : public integral_constant<size_t, 2> {};
 
 template <class _T1, class _T2>
-class _LIBCPP_TYPE_VIS tuple_element<0, pair<_T1, _T2> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_element<0, pair<_T1, _T2> >
 {
 public:
     typedef _T1 type;
 };
 
 template <class _T1, class _T2>
-class _LIBCPP_TYPE_VIS tuple_element<1, pair<_T1, _T2> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_element<1, pair<_T1, _T2> >
 {
 public:
     typedef _T2 type;
 };
 
 template <class _T1, class _T2>
-class _LIBCPP_TYPE_VIS tuple_element<0, const pair<_T1, _T2> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_element<0, const pair<_T1, _T2> >
 {
 public:
     typedef const _T1 type;
 };
 
 template <class _T1, class _T2>
-class _LIBCPP_TYPE_VIS tuple_element<1, const pair<_T1, _T2> >
+class _LIBCPP_TYPE_VIS_ONLY tuple_element<1, const pair<_T1, _T2> >
 {
 public:
     typedef const _T2 type;
@@ -594,7 +594,7 @@ struct __get_pair<1>
 };
 
 template <size_t _Ip, class _T1, class _T2>
-_LIBCPP_INLINE_VISIBILITY inline _LIBCPP_CONSTEXPR_AFTER_CXX11
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 get(pair<_T1, _T2>& __p) _NOEXCEPT
 {
@@ -602,7 +602,7 @@ get(pair<_T1, _T2>& __p) _NOEXCEPT
 }
 
 template <size_t _Ip, class _T1, class _T2>
-_LIBCPP_INLINE_VISIBILITY inline _LIBCPP_CONSTEXPR_AFTER_CXX11
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 get(const pair<_T1, _T2>& __p) _NOEXCEPT
 {
@@ -612,7 +612,7 @@ get(const pair<_T1, _T2>& __p) _NOEXCEPT
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <size_t _Ip, class _T1, class _T2>
-_LIBCPP_INLINE_VISIBILITY inline _LIBCPP_CONSTEXPR_AFTER_CXX11
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
 get(pair<_T1, _T2>&& __p) _NOEXCEPT
 {
@@ -623,42 +623,42 @@ get(pair<_T1, _T2>&& __p) _NOEXCEPT
 
 #if _LIBCPP_STD_VER > 11
 template <class _T1, class _T2>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT
 {
     return __get_pair<0>::get(__p);
 }
 
 template <class _T1, class _T2>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 const & get(pair<_T1, _T2> const& __p) _NOEXCEPT
 {
     return __get_pair<0>::get(__p);
 }
 
 template <class _T1, class _T2>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT
 {
     return __get_pair<0>::get(_VSTD::move(__p));
 }
 
 template <class _T1, class _T2>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 & get(pair<_T2, _T1>& __p) _NOEXCEPT
 {
     return __get_pair<1>::get(__p);
 }
 
 template <class _T1, class _T2>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 const & get(pair<_T2, _T1> const& __p) _NOEXCEPT
 {
     return __get_pair<1>::get(__p);
 }
 
 template <class _T1, class _T2>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT
 {
     return __get_pair<1>::get(_VSTD::move(__p));
@@ -669,7 +669,7 @@ constexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT
 #if _LIBCPP_STD_VER > 11
 
 template<class _Tp, _Tp... _Ip>
-struct _LIBCPP_TYPE_VIS integer_sequence
+struct _LIBCPP_TYPE_VIS_ONLY integer_sequence
 {
     typedef _Tp value_type;
     static_assert( is_integral<_Tp>::value,
@@ -754,7 +754,7 @@ template<class... _Tp>
 
 #if _LIBCPP_STD_VER > 11
 template<class _T1, class _T2 = _T1>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 _T1 exchange(_T1& __obj, _T2 && __new_value)
 {
     _T1 __old_value = _VSTD::move(__obj);
diff --git a/system/include/libcxx/valarray b/system/include/libcxx/valarray
index 71c8a74edb28f..5113516e9b767 100644
--- a/system/include/libcxx/valarray
+++ b/system/include/libcxx/valarray
@@ -354,9 +354,9 @@ template <class T> unspecified2 end(const valarray<T>& v);
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Tp> class _LIBCPP_TYPE_VIS valarray;
+template<class _Tp> class _LIBCPP_TYPE_VIS_ONLY valarray;
 
-class _LIBCPP_TYPE_VIS slice
+class _LIBCPP_TYPE_VIS_ONLY slice
 {
     size_t __start_;
     size_t __size_;
@@ -381,11 +381,11 @@ public:
     _LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;}
 };
 
-template <class _Tp> class _LIBCPP_TYPE_VIS slice_array;
+template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY slice_array;
 class _LIBCPP_TYPE_VIS gslice;
-template <class _Tp> class _LIBCPP_TYPE_VIS gslice_array;
-template <class _Tp> class _LIBCPP_TYPE_VIS mask_array;
-template <class _Tp> class _LIBCPP_TYPE_VIS indirect_array;
+template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY gslice_array;
+template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY mask_array;
+template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY indirect_array;
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
@@ -671,7 +671,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __size_;}
 
-    template <class> friend class _LIBCPP_TYPE_VIS valarray;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY valarray;
 };
 
 template <class _ValExpr>
@@ -786,7 +786,7 @@ template<class _Tp>
 struct __is_val_expr<valarray<_Tp> > : true_type {};
 
 template<class _Tp>
-class _LIBCPP_TYPE_VIS valarray
+class _LIBCPP_TYPE_VIS_ONLY valarray
 {
 public:
     typedef _Tp value_type;
@@ -976,12 +976,12 @@ public:
     void     resize(size_t __n, value_type __x = value_type());
 
 private:
-    template <class> friend class _LIBCPP_TYPE_VIS valarray;
-    template <class> friend class _LIBCPP_TYPE_VIS slice_array;
-    template <class> friend class _LIBCPP_TYPE_VIS gslice_array;
-    template <class> friend class _LIBCPP_TYPE_VIS mask_array;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY valarray;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY slice_array;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY gslice_array;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY mask_array;
     template <class> friend class __mask_expr;
-    template <class> friend class _LIBCPP_TYPE_VIS indirect_array;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY indirect_array;
     template <class> friend class __indirect_expr;
     template <class> friend class __val_expr;
 
@@ -1006,6 +1006,10 @@ private:
     end(const valarray<_Up>& __v);
 };
 
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::valarray(size_t))
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::~valarray())
+_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void valarray<size_t>::resize(size_t, size_t))
+
 template <class _Op, class _Tp>
 struct _UnaryOp<_Op, valarray<_Tp> >
 {
@@ -1091,7 +1095,7 @@ struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> >
 // slice_array
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS slice_array
+class _LIBCPP_TYPE_VIS_ONLY slice_array
 {
 public:
     typedef _Tp value_type;
@@ -1461,7 +1465,7 @@ private:
 // gslice_array
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS gslice_array
+class _LIBCPP_TYPE_VIS_ONLY gslice_array
 {
 public:
     typedef _Tp value_type;
@@ -1790,7 +1794,7 @@ gslice_array<_Tp>::operator=(const value_type& __x) const
 // mask_array
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS mask_array
+class _LIBCPP_TYPE_VIS_ONLY mask_array
 {
 public:
     typedef _Tp value_type;
@@ -2134,7 +2138,7 @@ public:
 // indirect_array
 
 template <class _Tp>
-class _LIBCPP_TYPE_VIS indirect_array
+class _LIBCPP_TYPE_VIS_ONLY indirect_array
 {
 public:
     typedef _Tp value_type;
@@ -2485,7 +2489,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __1d_.size();}
 
-    template <class> friend class _LIBCPP_TYPE_VIS valarray;
+    template <class> friend class _LIBCPP_TYPE_VIS_ONLY valarray;
 };
 
 template<class _ValExpr>
@@ -2624,7 +2628,7 @@ public:
 };
 
 template<class _ValExpr>
-__val_expr<_ValExpr>::operator valarray<result_type>() const
+__val_expr<_ValExpr>::operator valarray<__val_expr::result_type>() const
 {
     valarray<result_type> __r;
     size_t __n = __expr_.size();
@@ -4770,10 +4774,6 @@ end(const valarray<_Tp>& __v)
     return __v.__end_;
 }
 
-_LIBCPP_EXTERN_TEMPLATE(valarray<size_t>::valarray(size_t))
-_LIBCPP_EXTERN_TEMPLATE(valarray<size_t>::~valarray())
-_LIBCPP_EXTERN_TEMPLATE(void valarray<size_t>::resize(size_t, size_t))
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_VALARRAY
diff --git a/system/include/libcxx/vector b/system/include/libcxx/vector
index 0758f75bf3b71..6ac78d5d50b5b 100644
--- a/system/include/libcxx/vector
+++ b/system/include/libcxx/vector
@@ -38,6 +38,7 @@ public:
         noexcept(is_nothrow_default_constructible<allocator_type>::value);
     explicit vector(const allocator_type&);
     explicit vector(size_type n);
+    explicit vector(size_type n, const allocator_type&); // C++14
     vector(size_type n, const value_type& value, const allocator_type& = allocator_type());
     template <class InputIterator>
         vector(InputIterator first, InputIterator last, const allocator_type& = allocator_type());
@@ -161,7 +162,8 @@ public:
     vector()
         noexcept(is_nothrow_default_constructible<allocator_type>::value);
     explicit vector(const allocator_type&);
-    explicit vector(size_type n, const value_type& value = value_type(), const allocator_type& = allocator_type());
+    explicit vector(size_type n, const allocator_type& a = allocator_type()); // C++14
+    vector(size_type n, const value_type& value, const allocator_type& = allocator_type());
     template <class InputIterator>
         vector(InputIterator first, InputIterator last, const allocator_type& = allocator_type());
     vector(const vector& x);
@@ -216,8 +218,10 @@ public:
     const_reference back() const;
 
     void push_back(const value_type& x);
+    template <class... Args> void emplace_back(Args&&... args);  // C++14
     void pop_back();
 
+    template <class... Args> iterator emplace(const_iterator position, Args&&... args);  // C++14
     iterator insert(const_iterator position, const value_type& x);
     iterator insert(const_iterator position, size_type n, const value_type& x);
     template <class InputIterator>
@@ -272,7 +276,7 @@ void swap(vector<T,Allocator>& x, vector<T,Allocator>& y)
 
 #include <__undef_min_max>
 
-#ifdef _LIBCPP_DEBUG2
+#ifdef _LIBCPP_DEBUG
 #   include <__debug>
 #else
 #   define _LIBCPP_ASSERT(x, m) ((void)0)
@@ -319,7 +323,7 @@ __vector_base_common<__b>::__throw_out_of_range() const
 #pragma warning( push )
 #pragma warning( disable: 4231 )
 #endif // _LIBCPP_MSVC
-_LIBCPP_EXTERN_TEMPLATE(class __vector_base_common<true>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS __vector_base_common<true>)
 #ifdef _LIBCPP_MSVC
 #pragma warning( pop )
 #endif // _LIBCPP_MSVC
@@ -436,7 +440,7 @@ private:
 };
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 __vector_base<_Tp, _Allocator>::__destruct_at_end(pointer __new_last) _NOEXCEPT
 {
@@ -445,7 +449,7 @@ __vector_base<_Tp, _Allocator>::__destruct_at_end(pointer __new_last) _NOEXCEPT
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 __vector_base<_Tp, _Allocator>::__vector_base()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __begin_(nullptr),
@@ -455,7 +459,7 @@ __vector_base<_Tp, _Allocator>::__vector_base()
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 __vector_base<_Tp, _Allocator>::__vector_base(const allocator_type& __a)
     : __begin_(nullptr),
       __end_(nullptr),
@@ -474,7 +478,7 @@ __vector_base<_Tp, _Allocator>::~__vector_base()
 }
 
 template <class _Tp, class _Allocator = allocator<_Tp> >
-class _LIBCPP_TYPE_VIS vector
+class _LIBCPP_TYPE_VIS_ONLY vector
     : private __vector_base<_Tp, _Allocator>
 {
 private:
@@ -514,15 +518,19 @@ public:
 #endif
     }
     explicit vector(size_type __n);
+#if _LIBCPP_STD_VER > 11
+    explicit vector(size_type __n, const allocator_type& __a);
+#endif
     vector(size_type __n, const_reference __x);
     vector(size_type __n, const_reference __x, const allocator_type& __a);
     template <class _InputIterator>
-        vector(_InputIterator __first, _InputIterator __last,
+        vector(_InputIterator __first,
                typename enable_if<__is_input_iterator  <_InputIterator>::value &&
                                  !__is_forward_iterator<_InputIterator>::value &&
                                  is_constructible<
                                     value_type,
-                                    typename iterator_traits<_InputIterator>::reference>::value>::type* = 0);
+                                    typename iterator_traits<_InputIterator>::reference>::value,
+                                 _InputIterator>::type __last);
     template <class _InputIterator>
         vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
                typename enable_if<__is_input_iterator  <_InputIterator>::value &&
@@ -531,11 +539,12 @@ public:
                                     value_type,
                                     typename iterator_traits<_InputIterator>::reference>::value>::type* = 0);
     template <class _ForwardIterator>
-        vector(_ForwardIterator __first, _ForwardIterator __last,
+        vector(_ForwardIterator __first,
                typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
                                  is_constructible<
                                     value_type,
-                                    typename iterator_traits<_ForwardIterator>::reference>::value>::type* = 0);
+                                    typename iterator_traits<_ForwardIterator>::reference>::value,
+                                 _ForwardIterator>::type __last);
     template <class _ForwardIterator>
         vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
                typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
@@ -888,7 +897,7 @@ vector<_Tp, _Allocator>::max_size() const _NOEXCEPT
 
 //  Precondition:  __new_size > capacity()
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::size_type
 vector<_Tp, _Allocator>::__recommend(size_type __new_size) const
 {
@@ -926,7 +935,7 @@ vector<_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
+inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
 {
@@ -1020,6 +1029,22 @@ vector<_Tp, _Allocator>::vector(size_type __n)
     }
 }
 
+#if _LIBCPP_STD_VER > 11
+template <class _Tp, class _Allocator>
+vector<_Tp, _Allocator>::vector(size_type __n, const allocator_type& __a)
+    : __base(__a)
+{
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    __get_db()->__insert_c(this);
+#endif
+    if (__n > 0)
+    {
+        allocate(__n);
+        __construct_at_end(__n);
+    }
+}
+#endif
+
 template <class _Tp, class _Allocator>
 vector<_Tp, _Allocator>::vector(size_type __n, const_reference __x)
 {
@@ -1049,12 +1074,13 @@ vector<_Tp, _Allocator>::vector(size_type __n, const_reference __x, const alloca
 
 template <class _Tp, class _Allocator>
 template <class _InputIterator>
-vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
+vector<_Tp, _Allocator>::vector(_InputIterator __first,
        typename enable_if<__is_input_iterator  <_InputIterator>::value &&
                          !__is_forward_iterator<_InputIterator>::value &&
                          is_constructible<
                             value_type,
-                            typename iterator_traits<_InputIterator>::reference>::value>::type*)
+                            typename iterator_traits<_InputIterator>::reference>::value,
+                          _InputIterator>::type __last)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
@@ -1082,11 +1108,12 @@ vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, c
 
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
-vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last,
+vector<_Tp, _Allocator>::vector(_ForwardIterator __first,
                                 typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
                                 is_constructible<
                                    value_type,
-                                   typename iterator_traits<_ForwardIterator>::reference>::value>::type*)
+                                   typename iterator_traits<_ForwardIterator>::reference>::value,
+                                                   _ForwardIterator>::type __last)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
@@ -1152,7 +1179,7 @@ vector<_Tp, _Allocator>::vector(const vector& __x, const allocator_type& __a)
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>::vector(vector&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
     : __base(_VSTD::move(__x.__alloc()))
@@ -1168,7 +1195,7 @@ vector<_Tp, _Allocator>::vector(vector&& __x)
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>::vector(vector&& __x, const allocator_type& __a)
     : __base(__a)
 {
@@ -1195,7 +1222,7 @@ vector<_Tp, _Allocator>::vector(vector&& __x, const allocator_type& __a)
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
@@ -1209,7 +1236,7 @@ vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il)
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a)
     : __base(__a)
 {
@@ -1226,7 +1253,7 @@ vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il, const allocat
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>&
 vector<_Tp, _Allocator>::operator=(vector&& __x)
         _NOEXCEPT_(
@@ -1270,7 +1297,7 @@ vector<_Tp, _Allocator>::__move_assign(vector& __c, true_type)
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 vector<_Tp, _Allocator>&
 vector<_Tp, _Allocator>::operator=(const vector& __x)
 {
@@ -1359,7 +1386,7 @@ vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u)
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::__make_iter(pointer __p) _NOEXCEPT
 {
@@ -1371,7 +1398,7 @@ vector<_Tp, _Allocator>::__make_iter(pointer __p) _NOEXCEPT
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::const_iterator
 vector<_Tp, _Allocator>::__make_iter(const_pointer __p) const _NOEXCEPT
 {
@@ -1383,7 +1410,7 @@ vector<_Tp, _Allocator>::__make_iter(const_pointer __p) const _NOEXCEPT
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::begin() _NOEXCEPT
 {
@@ -1391,7 +1418,7 @@ vector<_Tp, _Allocator>::begin() _NOEXCEPT
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::const_iterator
 vector<_Tp, _Allocator>::begin() const _NOEXCEPT
 {
@@ -1399,7 +1426,7 @@ vector<_Tp, _Allocator>::begin() const _NOEXCEPT
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::end() _NOEXCEPT
 {
@@ -1407,7 +1434,7 @@ vector<_Tp, _Allocator>::end() _NOEXCEPT
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::const_iterator
 vector<_Tp, _Allocator>::end() const _NOEXCEPT
 {
@@ -1415,7 +1442,7 @@ vector<_Tp, _Allocator>::end() const _NOEXCEPT
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::reference
 vector<_Tp, _Allocator>::operator[](size_type __n)
 {
@@ -1424,7 +1451,7 @@ vector<_Tp, _Allocator>::operator[](size_type __n)
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::const_reference
 vector<_Tp, _Allocator>::operator[](size_type __n) const
 {
@@ -1502,7 +1529,7 @@ vector<_Tp, _Allocator>::__push_back_slow_path(_Up& __x)
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<_Tp, _Allocator>::push_back(const_reference __x)
 {
@@ -1519,7 +1546,7 @@ vector<_Tp, _Allocator>::push_back(const_reference __x)
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<_Tp, _Allocator>::push_back(value_type&& __x)
 {
@@ -1551,7 +1578,7 @@ vector<_Tp, _Allocator>::__emplace_back_slow_path(_Args&&... __args)
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<_Tp, _Allocator>::emplace_back(_Args&&... __args)
 {
@@ -1570,7 +1597,7 @@ vector<_Tp, _Allocator>::emplace_back(_Args&&... __args)
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<_Tp, _Allocator>::pop_back()
 {
@@ -1579,7 +1606,7 @@ vector<_Tp, _Allocator>::pop_back()
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::erase(const_iterator __position)
 {
@@ -1989,7 +2016,7 @@ vector<_Tp, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __
 #endif  // _LIBCPP_DEBUG_LEVEL >= 2
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<_Tp, _Allocator>::__invalidate_all_iterators()
 {
@@ -2011,7 +2038,7 @@ struct __has_storage_type<vector<bool, _Allocator> >
 };
 
 template <class _Allocator>
-class _LIBCPP_TYPE_VIS vector<bool, _Allocator>
+class _LIBCPP_TYPE_VIS_ONLY vector<bool, _Allocator>
     : private __vector_base_common<true>
 {
 public:
@@ -2024,21 +2051,8 @@ public:
     typedef size_type __storage_type;
     typedef __bit_iterator<vector, false>            pointer;
     typedef __bit_iterator<vector, true>             const_pointer;
-#ifdef _LIBCPP_DEBUG
-    typedef __debug_iter<vector, pointer>            iterator;
-    typedef __debug_iter<vector, const_pointer>      const_iterator;
-
-    friend class __debug_iter<vector, pointer>;
-    friend class __debug_iter<vector, const_pointer>;
-
-    pair<iterator*, const_iterator*> __iterator_list_;
-
-    _LIBCPP_INLINE_VISIBILITY iterator*&       __get_iterator_list(iterator*)       {return __iterator_list_.first;}
-    _LIBCPP_INLINE_VISIBILITY const_iterator*& __get_iterator_list(const_iterator*) {return __iterator_list_.second;}
-#else  // _LIBCPP_DEBUG
     typedef pointer                                  iterator;
     typedef const_pointer                            const_iterator;
-#endif  // _LIBCPP_DEBUG
     typedef _VSTD::reverse_iterator<iterator>         reverse_iterator;
     typedef _VSTD::reverse_iterator<const_iterator>   const_reverse_iterator;
 
@@ -2090,6 +2104,9 @@ public:
     _LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a);
     ~vector();
     explicit vector(size_type __n);
+#if _LIBCPP_STD_VER > 11
+    explicit vector(size_type __n, const allocator_type& __a);
+#endif
     vector(size_type __n, const value_type& __v);
     vector(size_type __n, const value_type& __v, const allocator_type& __a);
     template <class _InputIterator>
@@ -2221,8 +2238,20 @@ public:
     _LIBCPP_INLINE_VISIBILITY const_reference back()  const {return __make_ref(__size_ - 1);}
 
     void push_back(const value_type& __x);
+#if _LIBCPP_STD_VER > 11
+    template <class... _Args>
+    _LIBCPP_INLINE_VISIBILITY void emplace_back(_Args&&... __args)
+        { push_back ( value_type ( _VSTD::forward<_Args>(__args)... )); }
+#endif
+
     _LIBCPP_INLINE_VISIBILITY void pop_back() {--__size_;}
 
+#if _LIBCPP_STD_VER > 11
+    template <class... _Args>
+   _LIBCPP_INLINE_VISIBILITY iterator emplace(const_iterator position, _Args&&... __args)
+        { return insert ( position, value_type ( _VSTD::forward<_Args>(__args)... )); }
+#endif
+
     iterator insert(const_iterator __position, const value_type& __x);
     iterator insert(const_iterator __position, size_type __n, const value_type& __x);
     iterator insert(const_iterator __position, size_type __n, const_reference __x);
@@ -2267,7 +2296,7 @@ private:
     void allocate(size_type __n);
     void deallocate() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
-    static size_type __align(size_type __new_size) _NOEXCEPT
+    static size_type __align_it(size_type __new_size) _NOEXCEPT
         {return __new_size + (__bits_per_word-1) & ~(__bits_per_word-1);};
     _LIBCPP_INLINE_VISIBILITY  size_type __recommend(size_type __new_size) const;
     _LIBCPP_INLINE_VISIBILITY void __construct_at_end(size_type __n, bool __x);
@@ -2285,14 +2314,6 @@ private:
     _LIBCPP_INLINE_VISIBILITY
     const_reference __make_ref(size_type __pos) const _NOEXCEPT
         {return const_reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
-#ifdef _LIBCPP_DEBUG
-    _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_type __pos)
-        {return iterator(this, pointer(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word)));}
-    _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_type __pos) const
-        {return const_iterator(this, const_pointer(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word)));}
-    _LIBCPP_INLINE_VISIBILITY iterator __const_iterator_cast(const_iterator __p)
-        {return iterator(this, pointer(const_cast<__storage_pointer>(__p.base().__seg_), __p.base().__ctz_));}
-#else  // _LIBCPP_DEBUG
     _LIBCPP_INLINE_VISIBILITY
     iterator __make_iter(size_type __pos) _NOEXCEPT
         {return iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
@@ -2302,7 +2323,6 @@ private:
     _LIBCPP_INLINE_VISIBILITY
     iterator __const_iterator_cast(const_iterator __p) _NOEXCEPT
         {return begin() + (__p - cbegin());}
-#endif  // _LIBCPP_DEBUG
 
     _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const vector& __v)
@@ -2369,20 +2389,14 @@ private:
     friend class __bit_iterator<vector, false>;
     friend class __bit_iterator<vector, true>;
     friend struct __bit_array<vector>;
-    friend struct _LIBCPP_TYPE_VIS hash<vector>;
+    friend struct _LIBCPP_TYPE_VIS_ONLY hash<vector>;
 };
 
 template <class _Allocator>
-#ifndef _LIBCPP_DEBUG
-_LIBCPP_INLINE_VISIBILITY inline
-#endif
+inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<bool, _Allocator>::__invalidate_all_iterators()
 {
-#ifdef _LIBCPP_DEBUG
-    iterator::__remove_all(this);
-    const_iterator::__remove_all(this);
-#endif  // _LIBCPP_DEBUG
 }
 
 //  Allocate space for __n objects
@@ -2430,7 +2444,7 @@ vector<bool, _Allocator>::max_size() const _NOEXCEPT
 
 //  Precondition:  __new_size > capacity()
 template <class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename vector<bool, _Allocator>::size_type
 vector<bool, _Allocator>::__recommend(size_type __new_size) const
 {
@@ -2440,7 +2454,7 @@ vector<bool, _Allocator>::__recommend(size_type __new_size) const
     const size_type __cap = capacity();
     if (__cap >= __ms / 2)
         return __ms;
-    return _VSTD::max(2*__cap, __align(__new_size));
+    return _VSTD::max(2*__cap, __align_it(__new_size));
 }
 
 //  Default constructs __n objects starting at __end_
@@ -2448,7 +2462,7 @@ vector<bool, _Allocator>::__recommend(size_type __new_size) const
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == size() + __n
 template <class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<bool, _Allocator>::__construct_at_end(size_type __n, bool __x)
 {
@@ -2472,7 +2486,7 @@ vector<bool, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardI
 }
 
 template <class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 vector<bool, _Allocator>::vector()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __begin_(nullptr),
@@ -2482,7 +2496,7 @@ vector<bool, _Allocator>::vector()
 }
 
 template <class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 vector<bool, _Allocator>::vector(const allocator_type& __a)
     : __begin_(nullptr),
       __size_(0),
@@ -2503,6 +2517,21 @@ vector<bool, _Allocator>::vector(size_type __n)
     }
 }
 
+#if _LIBCPP_STD_VER > 11
+template <class _Allocator>
+vector<bool, _Allocator>::vector(size_type __n, const allocator_type& __a)
+    : __begin_(nullptr),
+      __size_(0),
+      __cap_alloc_(0, static_cast<__storage_allocator>(__a))
+{
+    if (__n > 0)
+    {
+        allocate(__n);
+        __construct_at_end(__n, false);
+    }
+}
+#endif
+
 template <class _Allocator>
 vector<bool, _Allocator>::vector(size_type __n, const value_type& __x)
     : __begin_(nullptr),
@@ -2652,9 +2681,7 @@ vector<bool, _Allocator>::~vector()
 {
     if (__begin_ != nullptr)
         __storage_traits::deallocate(__alloc(), __begin_, __cap());
-#ifdef _LIBCPP_DEBUG
     __invalidate_all_iterators();
-#endif
 }
 
 template <class _Allocator>
@@ -2707,7 +2734,7 @@ vector<bool, _Allocator>::operator=(const vector& __v)
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 vector<bool, _Allocator>::vector(vector&& __v)
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
     : __begin_(__v.__begin_),
@@ -2741,7 +2768,7 @@ vector<bool, _Allocator>::vector(vector&& __v, const allocator_type& __a)
 }
 
 template <class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 vector<bool, _Allocator>&
 vector<bool, _Allocator>::operator=(vector&& __v)
         _NOEXCEPT_(
@@ -3028,7 +3055,7 @@ vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __f
 }
 
 template <class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 typename vector<bool, _Allocator>::iterator
 vector<bool, _Allocator>::erase(const_iterator __position)
 {
@@ -3059,10 +3086,6 @@ vector<bool, _Allocator>::swap(vector& __x)
     _VSTD::swap(this->__size_, __x.__size_);
     _VSTD::swap(this->__cap(), __x.__cap());
     __swap_alloc(this->__alloc(), __x.__alloc());
-#ifdef _LIBCPP_DEBUG
-    iterator::swap(this, &__x);
-    const_iterator::swap(this, &__x);
-#endif  // _LIBCPP_DEBUG
 }
 
 template <class _Allocator>
@@ -3152,7 +3175,7 @@ vector<bool, _Allocator>::__hash_code() const _NOEXCEPT
 }
 
 template <class _Allocator>
-struct _LIBCPP_TYPE_VIS hash<vector<bool, _Allocator> >
+struct _LIBCPP_TYPE_VIS_ONLY hash<vector<bool, _Allocator> >
     : public unary_function<vector<bool, _Allocator>, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -3161,7 +3184,7 @@ struct _LIBCPP_TYPE_VIS hash<vector<bool, _Allocator> >
 };
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
@@ -3170,7 +3193,7 @@ operator==(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
@@ -3178,7 +3201,7 @@ operator!=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
@@ -3186,7 +3209,7 @@ operator< (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator> (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
@@ -3194,7 +3217,7 @@ operator> (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
@@ -3202,7 +3225,7 @@ operator>=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
@@ -3210,7 +3233,7 @@ operator<=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
+inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
diff --git a/system/lib/libcxx/CREDITS.TXT b/system/lib/libcxx/CREDITS.TXT
index 5e4d14ec20a45..368b526fcc1b5 100644
--- a/system/lib/libcxx/CREDITS.TXT
+++ b/system/lib/libcxx/CREDITS.TXT
@@ -31,7 +31,7 @@ D: FreeBSD and Solaris ports, libcxxrt support, some atomics work.
 N: Marshall Clow
 E: mclow.lists@gmail.com
 E: marshall@idio.com
-D: Minor patches and bug fixes.
+D: C++14 support, patches and bug fixes.
 
 N: Bill Fisher
 E: william.w.fisher@gmail.com
@@ -76,6 +76,10 @@ N: Bjorn Reese
 E: breese@users.sourceforge.net
 D: Initial regex prototype
 
+N: Nico Rieck
+E: nico.rieck@gmail.com
+D: Windows fixes
+
 N: Jonathan Sauer
 D: Minor patches, mostly related to constexpr
 
@@ -105,6 +109,10 @@ N: Zhang Xiongpang
 E: zhangxiongpang@gmail.com
 D: Minor patches and bug fixes.
 
+N: Xing Xue
+E: xingxue@ca.ibm.com
+D: AIX port
+
 N: Zhihao Yuan
 E: lichray@gmail.com
 D: Standard compatibility fixes.
diff --git a/system/lib/libcxx/algorithm.cpp b/system/lib/libcxx/algorithm.cpp
index 6d5cf7c0bc810..10c4c3312599d 100644
--- a/system/lib/libcxx/algorithm.cpp
+++ b/system/lib/libcxx/algorithm.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
 #include "algorithm"
 #include "random"
 #include "mutex"
diff --git a/system/lib/libcxx/debug.cpp b/system/lib/libcxx/debug.cpp
index c9b09b7a5407c..d0e867957dc01 100644
--- a/system/lib/libcxx/debug.cpp
+++ b/system/lib/libcxx/debug.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#define _LIBCPP_DEBUG2 1
+#define _LIBCPP_DEBUG 1
 #include "__config"
 #include "__debug"
 #include "functional"
@@ -118,20 +118,19 @@ void
 __libcpp_db::__insert_ic(void* __i, const void* __c)
 {
     WLock _(mut());
-    __i_node* i = __insert_iterator(__i);
-    const char* errmsg =
-        "Container constructed in a translation unit with debug mode disabled."
-        " But it is being used in a translation unit with debug mode enabled."
-        " Enable it in the other translation unit with #define _LIBCPP_DEBUG2 1";
-    _LIBCPP_ASSERT(__cbeg_ != __cend_, errmsg);
+    if (__cbeg_ == __cend_)
+        return;
     size_t hc = hash<const void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
     __c_node* c = __cbeg_[hc];
-    _LIBCPP_ASSERT(c != nullptr, errmsg);
+    if (c == nullptr)
+        return;
     while (c->__c_ != __c)
     {
         c = c->__next_;
-        _LIBCPP_ASSERT(c != nullptr, errmsg);
+        if (c == nullptr)
+            return;
     }
+    __i_node* i = __insert_iterator(__i);
     c->__add(i);
     i->__c_ = c;
 }
@@ -217,18 +216,23 @@ void
 __libcpp_db::__invalidate_all(void* __c)
 {
     WLock _(mut());
-    size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
-    __c_node* p = __cbeg_[hc];
-    _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __invalidate_all A");
-    while (p->__c_ != __c)
-    {
-        p = p->__next_;
-        _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __invalidate_all B");
-    }
-    while (p->end_ != p->beg_)
+    if (__cend_ != __cbeg_)
     {
-        --p->end_;
-        (*p->end_)->__c_ = nullptr;
+        size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
+        __c_node* p = __cbeg_[hc];
+        if (p == nullptr)
+            return;
+        while (p->__c_ != __c)
+        {
+            p = p->__next_;
+            if (p == nullptr)
+                return;
+        }
+        while (p->end_ != p->beg_)
+        {
+            --p->end_;
+            (*p->end_)->__c_ = nullptr;
+        }
     }
 }
 
@@ -236,13 +240,26 @@ __c_node*
 __libcpp_db::__find_c_and_lock(void* __c) const
 {
     mut().lock();
+    if (__cend_ == __cbeg_)
+    {
+        mut().unlock();
+        return nullptr;
+    }
     size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
     __c_node* p = __cbeg_[hc];
-    _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c_and_lock A");
+    if (p == nullptr)
+    {
+        mut().unlock();
+        return nullptr;
+    }
     while (p->__c_ != __c)
     {
         p = p->__next_;
-        _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c_and_lock B");
+        if (p == nullptr)
+        {
+            mut().unlock();
+            return nullptr;
+        }
     }
     return p;
 }
@@ -271,28 +288,35 @@ void
 __libcpp_db::__erase_c(void* __c)
 {
     WLock _(mut());
-    size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
-    __c_node* p = __cbeg_[hc];
-    __c_node* q = nullptr;
-    _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __erase_c A");
-    while (p->__c_ != __c)
+    if (__cend_ != __cbeg_)
     {
-        q = p;
-        p = p->__next_;
-        _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __erase_c B");
-    }
-    if (q == nullptr)
-        __cbeg_[hc] = p->__next_;
-    else
-        q->__next_ = p->__next_;
-    while (p->end_ != p->beg_)
-    {
-        --p->end_;
-        (*p->end_)->__c_ = nullptr;
+        size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
+        __c_node* p = __cbeg_[hc];
+        if (p == nullptr)
+            return;
+        __c_node* q = nullptr;
+        _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __erase_c A");
+        while (p->__c_ != __c)
+        {
+            q = p;
+            p = p->__next_;
+            if (p == nullptr)
+                return;
+            _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __erase_c B");
+        }
+        if (q == nullptr)
+            __cbeg_[hc] = p->__next_;
+        else
+            q->__next_ = p->__next_;
+        while (p->end_ != p->beg_)
+        {
+            --p->end_;
+            (*p->end_)->__c_ = nullptr;
+        }
+        free(p->beg_);
+        free(p);
+        --__csz_;
     }
-    free(p->beg_);
-    free(p);
-    --__csz_;
 }
 
 void
diff --git a/system/lib/libcxx/exception.cpp b/system/lib/libcxx/exception.cpp
index 3487bd8beea9f..83f6fd199c6ff 100644
--- a/system/lib/libcxx/exception.cpp
+++ b/system/lib/libcxx/exception.cpp
@@ -10,6 +10,7 @@
 #include <stdio.h>
 
 #include "exception"
+#include "new"
 
 #ifndef __has_include
 #define __has_include(inc) 0
@@ -90,14 +91,14 @@ terminate() _NOEXCEPT
         (*get_terminate())();
         // handler should not return
         printf("terminate_handler unexpectedly returned\n");
-        ::abort ();
+        ::abort();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         // handler should not throw exception
         printf("terminate_handler unexpectedly threw an exception\n");
-        ::abort ();
+        ::abort();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
@@ -111,12 +112,17 @@ bool uncaught_exception() _NOEXCEPT
     // on Darwin, there is a helper function so __cxa_get_globals is private
     return __cxa_uncaught_exception();
 #else  // __APPLE__
-    #warning uncaught_exception not yet implemented
+#   if defined(_MSC_VER) && ! defined(__clang__)
+        _LIBCPP_WARNING("uncaught_exception not yet implemented")
+#   else
+#       warning uncaught_exception not yet implemented
+#   endif
     printf("uncaught_exception not yet implemented\n");
     ::abort();
 #endif  // __APPLE__
 }
 
+
 #ifndef _LIBCPPABI_VERSION
 
 exception::~exception() _NOEXCEPT
@@ -143,16 +149,50 @@ const char* bad_exception::what() const _NOEXCEPT
 
 #endif
 
+#if defined(__GLIBCXX__)
+
+// libsupc++ does not implement the dependent EH ABI and the functionality
+// it uses to implement std::exception_ptr (which it declares as an alias of
+// std::__exception_ptr::exception_ptr) is not directly exported to clients. So
+// we have little choice but to hijack std::__exception_ptr::exception_ptr's
+// (which fortunately has the same layout as our std::exception_ptr) copy
+// constructor, assignment operator and destructor (which are part of its
+// stable ABI), and its rethrow_exception(std::__exception_ptr::exception_ptr)
+// function.
+
+namespace __exception_ptr
+{
+
+struct exception_ptr
+{
+    void* __ptr_;
+
+    exception_ptr(const exception_ptr&) _NOEXCEPT;
+    exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
+    ~exception_ptr() _NOEXCEPT;
+};
+
+}
+
+_LIBCPP_NORETURN void rethrow_exception(__exception_ptr::exception_ptr);
+
+#endif
 
 exception_ptr::~exception_ptr() _NOEXCEPT
 {
 #if HAVE_DEPENDENT_EH_ABI
     __cxa_decrement_exception_refcount(__ptr_);
+#elif defined(__GLIBCXX__)
+    reinterpret_cast<__exception_ptr::exception_ptr*>(this)->~exception_ptr();
 #else
-    #warning exception_ptr not yet implemented
+#   if defined(_MSC_VER) && ! defined(__clang__)
+        _LIBCPP_WARNING("exception_ptr not yet implemented")
+#   else
+#       warning exception_ptr not yet implemented
+#   endif
     printf("exception_ptr not yet implemented\n");
     ::abort();
-#endif  // __APPLE__
+#endif
 }
 
 exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
@@ -160,11 +200,18 @@ exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
 {
 #if HAVE_DEPENDENT_EH_ABI
     __cxa_increment_exception_refcount(__ptr_);
+#elif defined(__GLIBCXX__)
+    new (reinterpret_cast<void*>(this)) __exception_ptr::exception_ptr(
+        reinterpret_cast<const __exception_ptr::exception_ptr&>(other));
 #else
-    #warning exception_ptr not yet implemented
+#   if defined(_MSC_VER) && ! defined(__clang__)
+        _LIBCPP_WARNING("exception_ptr not yet implemented")
+#   else
+#       warning exception_ptr not yet implemented
+#   endif
     printf("exception_ptr not yet implemented\n");
     ::abort();
-#endif  // __APPLE__
+#endif
 }
 
 exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
@@ -177,11 +224,19 @@ exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
         __ptr_ = other.__ptr_;
     }
     return *this;
-#else  // __APPLE__
-    #warning exception_ptr not yet implemented
+#elif defined(__GLIBCXX__)
+    *reinterpret_cast<__exception_ptr::exception_ptr*>(this) =
+        reinterpret_cast<const __exception_ptr::exception_ptr&>(other);
+    return *this;
+#else
+#   if defined(_MSC_VER) && ! defined(__clang__)
+        _LIBCPP_WARNING("exception_ptr not yet implemented")
+#   else
+#       warning exception_ptr not yet implemented
+#   endif
     printf("exception_ptr not yet implemented\n");
     ::abort();
-#endif  // __APPLE__
+#endif
 }
 
 nested_exception::nested_exception() _NOEXCEPT
@@ -189,10 +244,14 @@ nested_exception::nested_exception() _NOEXCEPT
 {
 }
 
+#if !defined(__GLIBCXX__)
+
 nested_exception::~nested_exception() _NOEXCEPT
 {
 }
 
+#endif
+
 _LIBCPP_NORETURN
 void
 nested_exception::rethrow_nested() const
@@ -202,6 +261,7 @@ nested_exception::rethrow_nested() const
     rethrow_exception(__ptr_);
 }
 
+#if !defined(__GLIBCXX__)
 
 exception_ptr current_exception() _NOEXCEPT
 {
@@ -212,13 +272,19 @@ exception_ptr current_exception() _NOEXCEPT
     exception_ptr ptr;
     ptr.__ptr_ = __cxa_current_primary_exception();
     return ptr;
-#else  // __APPLE__
-    #warning exception_ptr not yet implemented
+#else
+#   if defined(_MSC_VER) && ! defined(__clang__)
+        _LIBCPP_WARNING( "exception_ptr not yet implemented" )
+#   else
+#       warning exception_ptr not yet implemented
+#   endif
     printf("exception_ptr not yet implemented\n");
     ::abort();
-#endif  // __APPLE__
+#endif
 }
 
+#endif  // !__GLIBCXX__
+
 _LIBCPP_NORETURN
 void rethrow_exception(exception_ptr p)
 {
@@ -226,10 +292,16 @@ void rethrow_exception(exception_ptr p)
     __cxa_rethrow_primary_exception(p.__ptr_);
     // if p.__ptr_ is NULL, above returns so we terminate
     terminate();
-#else  // __APPLE__
-    #warning exception_ptr not yet implemented
+#elif defined(__GLIBCXX__)
+    rethrow_exception(reinterpret_cast<__exception_ptr::exception_ptr&>(p));
+#else
+#   if defined(_MSC_VER) && ! defined(__clang__)
+        _LIBCPP_WARNING("exception_ptr not yet implemented")
+#   else
+#       warning exception_ptr not yet implemented
+#   endif
     printf("exception_ptr not yet implemented\n");
     ::abort();
-#endif  // __APPLE__
+#endif
 }
 } // std
diff --git a/system/lib/libcxx/future.cpp b/system/lib/libcxx/future.cpp
index 7d9a5b5da69a4..70919ab7df84a 100644
--- a/system/lib/libcxx/future.cpp
+++ b/system/lib/libcxx/future.cpp
@@ -26,11 +26,15 @@ __future_error_category::name() const _NOEXCEPT
     return "future";
 }
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wswitch"
+
 string
 __future_error_category::message(int ev) const
 {
     switch (static_cast<future_errc>(ev))
     {
+    case future_errc(0):  // For backwards compatibility with C++11 (LWG 2056)
     case future_errc::broken_promise:
         return string("The associated promise has been destructed prior "
                       "to the associated state becoming ready.");
@@ -46,6 +50,8 @@ __future_error_category::message(int ev) const
     return string("unspecified future_errc value\n");
 }
 
+#pragma clang diagnostic pop
+
 const error_category&
 future_category() _NOEXCEPT
 {
diff --git a/system/lib/libcxx/ios.cpp b/system/lib/libcxx/ios.cpp
index 732a61bb23906..bbe3c072e675a 100644
--- a/system/lib/libcxx/ios.cpp
+++ b/system/lib/libcxx/ios.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
+
 #include "ios"
 #include "streambuf"
 #include "istream"
@@ -61,7 +63,7 @@ __iostream_category::message(int ev) const
 }
 
 const error_category&
-iostream_category()
+iostream_category() _NOEXCEPT
 {
     static __iostream_category s;
     return s;
@@ -147,8 +149,11 @@ ios_base::getloc() const
 }
 
 // xalloc
-
+#if __has_feature(cxx_atomic)
+atomic<int> ios_base::__xindex_ = ATOMIC_VAR_INIT(0);
+#else
 int ios_base::__xindex_ = 0;
+#endif
 
 int
 ios_base::xalloc()
diff --git a/system/lib/libcxx/iostream.cpp b/system/lib/libcxx/iostream.cpp
index f413681f00643..7102e4389e063 100644
--- a/system/lib/libcxx/iostream.cpp
+++ b/system/lib/libcxx/iostream.cpp
@@ -22,14 +22,14 @@ _ALIGNAS_TYPE (__stdinbuf<wchar_t> ) static char __wcin [sizeof(__stdinbuf <wcha
 _ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcout[sizeof(__stdoutbuf<wchar_t>)];
 _ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcerr[sizeof(__stdoutbuf<wchar_t>)];
 
-_ALIGNAS_TYPE (istream) char cin [sizeof(istream)];
-_ALIGNAS_TYPE (ostream) char cout[sizeof(ostream)];
-_ALIGNAS_TYPE (ostream) char cerr[sizeof(ostream)];
-_ALIGNAS_TYPE (ostream) char clog[sizeof(ostream)];
-_ALIGNAS_TYPE (wistream) char wcin [sizeof(wistream)];
-_ALIGNAS_TYPE (wostream) char wcout[sizeof(wostream)];
-_ALIGNAS_TYPE (wostream) char wcerr[sizeof(wostream)];
-_ALIGNAS_TYPE (wostream) char wclog[sizeof(wostream)];
+_ALIGNAS_TYPE (istream)  _LIBCPP_FUNC_VIS char cin [sizeof(istream)];
+_ALIGNAS_TYPE (ostream)  _LIBCPP_FUNC_VIS char cout[sizeof(ostream)];
+_ALIGNAS_TYPE (ostream)  _LIBCPP_FUNC_VIS char cerr[sizeof(ostream)];
+_ALIGNAS_TYPE (ostream)  _LIBCPP_FUNC_VIS char clog[sizeof(ostream)];
+_ALIGNAS_TYPE (wistream) _LIBCPP_FUNC_VIS char wcin [sizeof(wistream)];
+_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcout[sizeof(wostream)];
+_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcerr[sizeof(wostream)];
+_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wclog[sizeof(wostream)];
 
 ios_base::Init __start_std_streams;
 
diff --git a/system/lib/libcxx/locale.cpp b/system/lib/libcxx/locale.cpp
index ad64668fd236e..a326323ac1ed0 100644
--- a/system/lib/libcxx/locale.cpp
+++ b/system/lib/libcxx/locale.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
+
 // On Solaris, we need to define something to make the C99 parts of localeconv
 // visible.
 #ifdef __sun__
@@ -26,7 +28,7 @@
 #include "cstring"
 #include "cwctype"
 #include "__sso_allocator"
-#ifdef _LIBCPP_MSVCRT
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
 #include <support/win32/locale_win32.h>
 #else // _LIBCPP_MSVCRT
 #include <langinfo.h>
@@ -36,7 +38,9 @@
 
 // On Linux, wint_t and wchar_t have different signed-ness, and this causes
 // lots of noise in the build log, but no bugs that I know of. 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wsign-conversion"
+#endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -107,6 +111,11 @@ countof(const T * const begin, const T * const end)
 
 }
 
+#if defined(_AIX)
+// Set priority to INT_MIN + 256 + 150
+# pragma priority ( -2147483242 )
+#endif
+
 const locale::category locale::none;
 const locale::category locale::collate;
 const locale::category locale::ctype;
@@ -116,14 +125,23 @@ const locale::category locale::time;
 const locale::category locale::messages;
 const locale::category locale::all;
 
+#if defined(__clang__)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wpadded"
+#endif
 
 class _LIBCPP_HIDDEN locale::__imp
     : public facet
 {
     enum {N = 28};
+#if defined(_LIBCPP_MSVC)
+// FIXME: MSVC doesn't support aligned parameters by value.
+// I can't get the __sso_allocator to work here
+// for MSVC I think for this reason.
+    vector<facet*> facets_;
+#else
     vector<facet*, __sso_allocator<facet*, N> > facets_;
+#endif
     string         name_;
 public:
     explicit __imp(size_t refs = 0);
@@ -147,7 +165,9 @@ class _LIBCPP_HIDDEN locale::__imp
     template <class F> void install_from(const __imp& other);
 };
 
+#if defined(__clang__)
 #pragma clang diagnostic pop
+#endif
 
 locale::__imp::__imp(size_t refs)
     : facet(refs),
@@ -757,7 +777,7 @@ ctype<wchar_t>::~ctype()
 bool
 ctype<wchar_t>::do_is(mask m, char_type c) const
 {
-    return isascii(c) ? ctype<char>::classic_table()[c] & m : false;
+    return isascii(c) ? (ctype<char>::classic_table()[c] & m) != 0 : false;
 }
 
 const wchar_t*
@@ -1009,12 +1029,14 @@ ctype<char>::classic_table()  _NOEXCEPT
     return __cloc()->__ctype_b;
 #elif __sun__
     return __ctype_mask;
-#elif defined(_LIBCPP_MSVCRT)
+#elif defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
     return _ctype+1; // internal ctype mask table defined in msvcrt.dll
 // This is assumed to be safe, which is a nonsense assumption because we're
 // going to end up dereferencing it later...
 #elif defined(__EMSCRIPTEN__)
     return *__ctype_b_loc();
+#elif defined(_AIX)
+    return (const unsigned long *)__lc_ctype_ptr->obj->mask;
 #else
     // Platform not supported: abort so the person doing the port knows what to
     // fix
@@ -4350,7 +4372,7 @@ __num_put_base::__format_float(char* __fmtp, const char* __len,
     if (__flags & ios_base::showpoint)
         *__fmtp++ = '#';
     ios_base::fmtflags floatfield = __flags & ios_base::floatfield;
-    bool uppercase = __flags & ios_base::uppercase;
+    bool uppercase = (__flags & ios_base::uppercase) != 0;
     if (floatfield == (ios_base::fixed | ios_base::scientific))
         specify_precision = false;
     else
@@ -4681,9 +4703,12 @@ __time_get::~__time_get()
 {
     freelocale(__loc_);
 }
-
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wmissing-field-initializers"
+#endif
+#if defined(__GNUG__)
 #pragma GCC   diagnostic ignored "-Wmissing-field-initializers"
+#endif
 
 template <>
 string
@@ -4829,7 +4854,9 @@ __time_get_storage<char>::__analyze(char fmt, const ctype<char>& ct)
     return result;
 }
 
+#if defined(__clang__)
 #pragma clang diagnostic ignored "-Wmissing-braces"
+#endif
 
 template <>
 wstring
@@ -5848,7 +5875,7 @@ moneypunct_byname<char, true>::init(const char* nm)
         __frac_digits_ = lc->int_frac_digits;
     else
         __frac_digits_ = base::do_frac_digits();
-#ifdef _LIBCPP_MSVCRT
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
     if (lc->p_sign_posn == 0)
 #else // _LIBCPP_MSVCRT
     if (lc->int_p_sign_posn == 0)
@@ -5856,7 +5883,7 @@ moneypunct_byname<char, true>::init(const char* nm)
         __positive_sign_ = "()";
     else
         __positive_sign_ = lc->positive_sign;
-#ifdef _LIBCPP_MSVCRT
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
     if(lc->n_sign_posn == 0)
 #else // _LIBCPP_MSVCRT
     if (lc->int_n_sign_posn == 0)
@@ -5868,7 +5895,7 @@ moneypunct_byname<char, true>::init(const char* nm)
     // the same places in curr_symbol since there's no way to
     // represent anything else.
     string_type __dummy_curr_symbol = __curr_symbol_;
-#ifdef _LIBCPP_MSVCRT
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
     __init_pat(__pos_format_, __dummy_curr_symbol, true,
                lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' ');
     __init_pat(__neg_format_, __curr_symbol_, true,
@@ -6007,7 +6034,7 @@ moneypunct_byname<wchar_t, true>::init(const char* nm)
         __frac_digits_ = lc->int_frac_digits;
     else
         __frac_digits_ = base::do_frac_digits();
-#ifdef _LIBCPP_MSVCRT
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
     if (lc->p_sign_posn == 0)
 #else // _LIBCPP_MSVCRT
     if (lc->int_p_sign_posn == 0)
@@ -6027,7 +6054,7 @@ moneypunct_byname<wchar_t, true>::init(const char* nm)
         wbe = wbuf + j;
         __positive_sign_.assign(wbuf, wbe);
     }
-#ifdef _LIBCPP_MSVCRT
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
     if (lc->n_sign_posn == 0)
 #else // _LIBCPP_MSVCRT
     if (lc->int_n_sign_posn == 0)
@@ -6051,7 +6078,7 @@ moneypunct_byname<wchar_t, true>::init(const char* nm)
     // the same places in curr_symbol since there's no way to
     // represent anything else.
     string_type __dummy_curr_symbol = __curr_symbol_;
-#ifdef _LIBCPP_MSVCRT
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
     __init_pat(__pos_format_, __dummy_curr_symbol, true,
                lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' ');
     __init_pat(__neg_format_, __curr_symbol_, true,
diff --git a/system/lib/libcxx/mutex.cpp b/system/lib/libcxx/mutex.cpp
index 42195aa806487..07678978a6788 100644
--- a/system/lib/libcxx/mutex.cpp
+++ b/system/lib/libcxx/mutex.cpp
@@ -42,6 +42,7 @@ void
 mutex::unlock() _NOEXCEPT
 {
     int ec = pthread_mutex_unlock(&__m_);
+    (void)ec;
     assert(ec == 0);
 }
 
@@ -79,6 +80,7 @@ recursive_mutex::recursive_mutex()
 recursive_mutex::~recursive_mutex()
 {
     int e = pthread_mutex_destroy(&__m_);
+    (void)e;
     assert(e == 0);
 }
 
@@ -94,6 +96,7 @@ void
 recursive_mutex::unlock() _NOEXCEPT
 {
     int e = pthread_mutex_unlock(&__m_);
+    (void)e;
     assert(e == 0);
 }
 
diff --git a/system/lib/libcxx/new.cpp b/system/lib/libcxx/new.cpp
index b23a516ff37f9..fa0331a8b711b 100644
--- a/system/lib/libcxx/new.cpp
+++ b/system/lib/libcxx/new.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define _LIBCPP_BUILDING_NEW
+
 #include <stdlib.h>
 
 #include "new"
@@ -28,16 +30,18 @@
     #if defined(LIBCXXRT) || __has_include(<cxxabi.h>)
         #include <cxxabi.h>
     #endif  // __has_include(<cxxabi.h>)
-    #ifndef _LIBCPPABI_VERSION
+    #if !defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__)
         static std::new_handler __new_handler;
     #endif  // _LIBCPPABI_VERSION
 #endif
 
+#ifndef __GLIBCXX__
+
 // Implement all new and delete operators as weak definitions
 // in this shared library, so that they can be overriden by programs
 // that define non-weak copies of the functions.
 
-__attribute__((__weak__, __visibility__("default")))
+_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
 void *
 operator new(std::size_t size)
 #if !__has_feature(cxx_noexcept)
@@ -64,7 +68,7 @@ operator new(std::size_t size)
     return p;
 }
 
-__attribute__((__weak__, __visibility__("default")))
+_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
 void*
 operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
 {
@@ -83,7 +87,7 @@ operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
     return p;
 }
 
-__attribute__((__weak__, __visibility__("default")))
+_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
 void*
 operator new[](size_t size)
 #if !__has_feature(cxx_noexcept)
@@ -93,7 +97,7 @@ operator new[](size_t size)
     return ::operator new(size);
 }
 
-__attribute__((__weak__, __visibility__("default")))
+_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
 void*
 operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT
 {
@@ -112,7 +116,7 @@ operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT
     return p;
 }
 
-__attribute__((__weak__, __visibility__("default")))
+_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
 void
 operator delete(void* ptr) _NOEXCEPT
 {
@@ -120,34 +124,40 @@ operator delete(void* ptr) _NOEXCEPT
         ::free(ptr);
 }
 
-__attribute__((__weak__, __visibility__("default")))
+_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
 void
 operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT
 {
     ::operator delete(ptr);
 }
 
-__attribute__((__weak__, __visibility__("default")))
+_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
 void
 operator delete[] (void* ptr) _NOEXCEPT
 {
     ::operator delete (ptr);
 }
 
-__attribute__((__weak__, __visibility__("default")))
+_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
 void
 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT
 {
     ::operator delete[](ptr);
 }
 
+#endif // !__GLIBCXX__
+
 namespace std
 {
 
+#ifndef __GLIBCXX__
 const nothrow_t nothrow = {};
+#endif
 
 #ifndef _LIBCPPABI_VERSION
 
+#ifndef __GLIBCXX__
+
 new_handler
 set_new_handler(new_handler handler) _NOEXCEPT
 {
@@ -160,12 +170,16 @@ get_new_handler() _NOEXCEPT
     return __sync_fetch_and_add(&__new_handler, (new_handler)0);
 }
 
+#endif // !__GLIBCXX__
+
 #ifndef LIBCXXRT
 
 bad_alloc::bad_alloc() _NOEXCEPT
 {
 }
 
+#ifndef __GLIBCXX__
+
 bad_alloc::~bad_alloc() _NOEXCEPT
 {
 }
@@ -176,6 +190,8 @@ bad_alloc::what() const _NOEXCEPT
     return "std::bad_alloc";
 }
 
+#endif // !__GLIBCXX__
+
 #endif //LIBCXXRT
 
 bad_array_new_length::bad_array_new_length() _NOEXCEPT
@@ -186,13 +202,29 @@ bad_array_new_length::~bad_array_new_length() _NOEXCEPT
 {
 }
 
+const char*
+bad_array_length::what() const _NOEXCEPT
+{
+    return "bad_array_length";
+}
+
+bad_array_length::bad_array_length() _NOEXCEPT
+{
+}
+
+bad_array_length::~bad_array_length() _NOEXCEPT
+{
+}
+
 const char*
 bad_array_new_length::what() const _NOEXCEPT
 {
     return "bad_array_new_length";
 }
 
-#endif
+#endif // _LIBCPPABI_VERSION
+
+#ifndef LIBSTDCXX
 
 void
 __throw_bad_alloc()
@@ -202,4 +234,6 @@ __throw_bad_alloc()
 #endif
 }
 
+#endif // !LIBSTDCXX
+
 }  // std
diff --git a/system/lib/libcxx/optional.cpp b/system/lib/libcxx/optional.cpp
new file mode 100644
index 0000000000000..fde071c9a1349
--- /dev/null
+++ b/system/lib/libcxx/optional.cpp
@@ -0,0 +1,25 @@
+//===------------------------ optional.cpp --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "optional"
+
+namespace std  // purposefully not using versioning namespace
+{
+
+#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
+
+bad_optional_access::~bad_optional_access() _NOEXCEPT {}
+
+#else
+
+bad_optional_access::~bad_optional_access() _NOEXCEPT = default;
+
+#endif
+
+}  // std
diff --git a/system/lib/libcxx/random.cpp b/system/lib/libcxx/random.cpp
index 97a40c509dc9a..47cdee402b7f8 100644
--- a/system/lib/libcxx/random.cpp
+++ b/system/lib/libcxx/random.cpp
@@ -7,6 +7,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if defined(_WIN32)
+// Must be defined before including stdlib.h to enable rand_s().
+#define _CRT_RAND_S
+#include <stdio.h>
+#endif
+
 #include "random"
 #include "system_error"
 
@@ -19,6 +25,25 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if defined(_WIN32)
+random_device::random_device(const string&)
+{
+}
+
+random_device::~random_device()
+{
+}
+
+unsigned
+random_device::operator()()
+{
+    unsigned r;
+    errno_t err = rand_s(&r);
+    if (err)
+        __throw_system_error(err, "random_device rand_s failed.");
+    return r;
+}
+#else
 random_device::random_device(const string& __token)
     : __f_(open(__token.c_str(), O_RDONLY))
 {
@@ -38,6 +63,7 @@ random_device::operator()()
     read(__f_, &r, sizeof(r));
     return r;
 }
+#endif // defined(_WIN32)
 
 double
 random_device::entropy() const _NOEXCEPT
diff --git a/system/lib/libcxx/readme.txt b/system/lib/libcxx/readme.txt
index 7687e5b2cd507..ae8090fd69a9d 100644
--- a/system/lib/libcxx/readme.txt
+++ b/system/lib/libcxx/readme.txt
@@ -1 +1 @@
-These files are from libc++, svn revision 187959, 2013-08-08.
+These files are from libc++, svn revision 194185, 2013-11-07.
diff --git a/system/lib/libcxx/shared_mutex.cpp b/system/lib/libcxx/shared_mutex.cpp
new file mode 100644
index 0000000000000..5fb22e44544df
--- /dev/null
+++ b/system/lib/libcxx/shared_mutex.cpp
@@ -0,0 +1,101 @@
+//===---------------------- shared_mutex.cpp ------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define _LIBCPP_BUILDING_SHARED_MUTEX
+#include "shared_mutex"
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+shared_mutex::shared_mutex()
+    : __state_(0)
+{
+}
+
+// Exclusive ownership
+
+void
+shared_mutex::lock()
+{
+    unique_lock<mutex> lk(__mut_);
+    while (__state_ & __write_entered_)
+        __gate1_.wait(lk);
+    __state_ |= __write_entered_;
+    while (__state_ & __n_readers_)
+        __gate2_.wait(lk);
+}
+
+bool
+shared_mutex::try_lock()
+{
+    unique_lock<mutex> lk(__mut_);
+    if (__state_ == 0)
+    {
+        __state_ = __write_entered_;
+        return true;
+    }
+    return false;
+}
+
+void
+shared_mutex::unlock()
+{
+    lock_guard<mutex> _(__mut_);
+    __state_ = 0;
+    __gate1_.notify_all();
+}
+
+// Shared ownership
+
+void
+shared_mutex::lock_shared()
+{
+    unique_lock<mutex> lk(__mut_);
+    while ((__state_ & __write_entered_) || (__state_ & __n_readers_) == __n_readers_)
+        __gate1_.wait(lk);
+    unsigned num_readers = (__state_ & __n_readers_) + 1;
+    __state_ &= ~__n_readers_;
+    __state_ |= num_readers;
+}
+
+bool
+shared_mutex::try_lock_shared()
+{
+    unique_lock<mutex> lk(__mut_);
+    unsigned num_readers = __state_ & __n_readers_;
+    if (!(__state_ & __write_entered_) && num_readers != __n_readers_)
+    {
+        ++num_readers;
+        __state_ &= ~__n_readers_;
+        __state_ |= num_readers;
+        return true;
+    }
+    return false;
+}
+
+void
+shared_mutex::unlock_shared()
+{
+    lock_guard<mutex> _(__mut_);
+    unsigned num_readers = (__state_ & __n_readers_) - 1;
+    __state_ &= ~__n_readers_;
+    __state_ |= num_readers;
+    if (__state_ & __write_entered_)
+    {
+        if (num_readers == 0)
+            __gate2_.notify_one();
+    }
+    else
+    {
+        if (num_readers == __n_readers_ - 1)
+            __gate1_.notify_one();
+    }
+}
+
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/system/lib/libcxx/stdexcept.cpp b/system/lib/libcxx/stdexcept.cpp
index 8d25f3ee54277..a4207d6058ff9 100644
--- a/system/lib/libcxx/stdexcept.cpp
+++ b/system/lib/libcxx/stdexcept.cpp
@@ -28,7 +28,9 @@
 
 // Note:  optimize for size
 
+#if ! defined(_LIBCPP_MSVC)
 #pragma GCC visibility push(hidden)
+#endif
 
 namespace
 {
@@ -47,9 +49,9 @@ class __libcpp_nmstr
     count_t& count() const _NOEXCEPT {return (count_t&)(*(str_ - sizeof(count_t)));}
 public:
     explicit __libcpp_nmstr(const char* msg);
-    __libcpp_nmstr(const __libcpp_nmstr& s) _LIBCPP_CANTTHROW;
-    __libcpp_nmstr& operator=(const __libcpp_nmstr& s) _LIBCPP_CANTTHROW;
-    ~__libcpp_nmstr() _LIBCPP_CANTTHROW;
+    __libcpp_nmstr(const __libcpp_nmstr& s) _NOEXCEPT;
+    __libcpp_nmstr& operator=(const __libcpp_nmstr& s) _NOEXCEPT;
+    ~__libcpp_nmstr();
     const char* c_str() const _NOEXCEPT {return str_;}
 };
 
@@ -65,14 +67,14 @@ __libcpp_nmstr::__libcpp_nmstr(const char* msg)
 }
 
 inline
-__libcpp_nmstr::__libcpp_nmstr(const __libcpp_nmstr& s)
+__libcpp_nmstr::__libcpp_nmstr(const __libcpp_nmstr& s) _NOEXCEPT
     : str_(s.str_)
 {
     __sync_add_and_fetch(&count(), 1);
 }
 
 __libcpp_nmstr&
-__libcpp_nmstr::operator=(const __libcpp_nmstr& s)
+__libcpp_nmstr::operator=(const __libcpp_nmstr& s) _NOEXCEPT
 {
     const char* p = str_;
     str_ = s.str_;
@@ -91,7 +93,9 @@ __libcpp_nmstr::~__libcpp_nmstr()
 
 }
 
+#if ! defined(_LIBCPP_MSVC)
 #pragma GCC visibility pop
+#endif
 
 namespace std  // purposefully not using versioning namespace
 {
@@ -123,7 +127,7 @@ logic_error::operator=(const logic_error& le) _NOEXCEPT
     return *this;
 }
 
-#ifndef _LIBCPPABI_VERSION
+#if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
 
 logic_error::~logic_error() _NOEXCEPT
 {
@@ -167,7 +171,7 @@ runtime_error::operator=(const runtime_error& le) _NOEXCEPT
     return *this;
 }
 
-#ifndef _LIBCPPABI_VERSION
+#if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
 
 runtime_error::~runtime_error() _NOEXCEPT
 {
diff --git a/system/lib/libcxx/string.cpp b/system/lib/libcxx/string.cpp
index 5a86911654dd9..fde52129e9fbb 100644
--- a/system/lib/libcxx/string.cpp
+++ b/system/lib/libcxx/string.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
+
 #include "string"
 #include "cstdlib"
 #include "cwchar"
@@ -89,7 +91,7 @@ inline
 int
 as_integer(const string& func, const string& s, size_t* idx, int base )
 {
-    // Use long as no Stantard string to integer exists.
+    // Use long as no Standard string to integer exists.
     long r = as_integer_helper<long>( func, s, idx, base, strtol );
     if (r < numeric_limits<int>::min() || numeric_limits<int>::max() < r)
         throw_from_string_out_of_range(func);
diff --git a/system/lib/libcxx/strstream.cpp b/system/lib/libcxx/strstream.cpp
index 518422bd2428e..c1965ea3762a3 100644
--- a/system/lib/libcxx/strstream.cpp
+++ b/system/lib/libcxx/strstream.cpp
@@ -156,13 +156,13 @@ strstreambuf::overflow(int_type __c)
     {
         if ((__strmode_ & __dynamic) == 0 || (__strmode_ & __frozen) != 0)
             return int_type(EOF);
-        streamsize old_size = (epptr() ? epptr() : egptr()) - eback();
-        streamsize new_size = max<streamsize>(__alsize_, 2*old_size);
+        size_t old_size = static_cast<size_t> ((epptr() ? epptr() : egptr()) - eback());
+        size_t new_size = max<size_t>(static_cast<size_t>(__alsize_), 2*old_size);
         if (new_size == 0)
             new_size = __default_alsize;
         char* buf = nullptr;
         if (__palloc_)
-            buf = static_cast<char*>(__palloc_(static_cast<size_t>(new_size)));
+            buf = static_cast<char*>(__palloc_(new_size));
         else
             buf = new char[new_size];
         if (buf == nullptr)
@@ -229,8 +229,8 @@ strstreambuf::pos_type
 strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which)
 {
     off_type __p(-1);
-    bool pos_in = __which & ios::in;
-    bool pos_out = __which & ios::out;
+    bool pos_in = (__which & ios::in) != 0;
+    bool pos_out = (__which & ios::out) != 0;
     bool legal = false;
     switch (__way)
     {
@@ -287,8 +287,8 @@ strstreambuf::pos_type
 strstreambuf::seekpos(pos_type __sp, ios_base::openmode __which)
 {
     off_type __p(-1);
-    bool pos_in = __which & ios::in;
-    bool pos_out = __which & ios::out;
+    bool pos_in = (__which & ios::in) != 0;
+    bool pos_out = (__which & ios::out) != 0;
     if (pos_in || pos_out)
     {
         if (!((pos_in && gptr() == nullptr) || (pos_out && pptr() == nullptr)))
diff --git a/system/lib/libcxx/support/win32/locale_win32.cpp b/system/lib/libcxx/support/win32/locale_win32.cpp
index a639ade4c21f7..1729d84a366a7 100644
--- a/system/lib/libcxx/support/win32/locale_win32.cpp
+++ b/system/lib/libcxx/support/win32/locale_win32.cpp
@@ -8,9 +8,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "support/win32/locale_win32.h"
+#include <locale>
 #include <cstdarg> // va_start, va_end
-#include <cwchar>  // mbstate_t
 
 // FIXME: base currently unused. Needs manual work to construct the new locale
 locale_t newlocale( int mask, const char * locale, locale_t /*base*/ )
@@ -34,38 +33,38 @@ lconv *localeconv_l( locale_t loc )
     __locale_raii __current( uselocale(loc), uselocale );
     return localeconv();
 }
-size_t mbrlen_l( const char *__restrict__ s, size_t n,
-                 mbstate_t *__restrict__ ps, locale_t loc )
+size_t mbrlen_l( const char *__restrict s, size_t n,
+                 mbstate_t *__restrict ps, locale_t loc )
 {
     __locale_raii __current( uselocale(loc), uselocale );
     return mbrlen( s, n, ps );
 }
-size_t mbsrtowcs_l( wchar_t *__restrict__ dst, const char **__restrict__ src,
-                    size_t len, mbstate_t *__restrict__ ps, locale_t loc )
+size_t mbsrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
+                    size_t len, mbstate_t *__restrict ps, locale_t loc )
 {
     __locale_raii __current( uselocale(loc), uselocale );
     return mbsrtowcs( dst, src, len, ps );
 }
-size_t wcrtomb_l( char *__restrict__ s, wchar_t wc, mbstate_t *__restrict__ ps,
+size_t wcrtomb_l( char *__restrict s, wchar_t wc, mbstate_t *__restrict ps,
                   locale_t loc )
 {
     __locale_raii __current( uselocale(loc), uselocale );
     return wcrtomb( s, wc, ps );
 }
-size_t mbrtowc_l( wchar_t *__restrict__ pwc, const char *__restrict__ s,
-                  size_t n, mbstate_t *__restrict__ ps, locale_t loc )
+size_t mbrtowc_l( wchar_t *__restrict pwc, const char *__restrict s,
+                  size_t n, mbstate_t *__restrict ps, locale_t loc )
 {
     __locale_raii __current( uselocale(loc), uselocale );
     return mbrtowc( pwc, s, n, ps );
 }
-size_t mbsnrtowcs_l( wchar_t *__restrict__ dst, const char **__restrict__ src,
-                     size_t nms, size_t len, mbstate_t *__restrict__ ps, locale_t loc )
+size_t mbsnrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
+                     size_t nms, size_t len, mbstate_t *__restrict ps, locale_t loc )
 {
     __locale_raii __current( uselocale(loc), uselocale );
     return mbsnrtowcs( dst, src, nms, len, ps );
 }
-size_t wcsnrtombs_l( char *__restrict__ dst, const wchar_t **__restrict__ src,
-                     size_t nwc, size_t len, mbstate_t *__restrict__ ps, locale_t loc )
+size_t wcsnrtombs_l( char *__restrict dst, const wchar_t **__restrict src,
+                     size_t nwc, size_t len, mbstate_t *__restrict ps, locale_t loc )
 {
     __locale_raii __current( uselocale(loc), uselocale );
     return wcsnrtombs( dst, src, nwc, len, ps );
diff --git a/system/lib/libcxx/support/win32/support.cpp b/system/lib/libcxx/support/win32/support.cpp
index 4215a70089b15..6ee31e0cb329b 100644
--- a/system/lib/libcxx/support/win32/support.cpp
+++ b/system/lib/libcxx/support/win32/support.cpp
@@ -14,14 +14,7 @@
 #include <cstdio>  // vsprintf, vsnprintf
 #include <cstring> // strcpy, wcsncpy
 #include <cwchar>  // mbstate_t
-#include <memory> // unique_ptr
 
-namespace { // Private
-
-    struct free_deleter { 
-        inline void operator()(char* p) { free(p); } 
-    }; 
-}
 // Some of these functions aren't standard or if they conform, the name does not.
 
 int asprintf(char **sptr, const char *__restrict format, ...)
@@ -29,44 +22,44 @@ int asprintf(char **sptr, const char *__restrict format, ...)
     va_list ap;
     va_start(ap, format);
     int result;
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    try {
-#endif
-        result = vasprintf(sptr, format, ap);
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    } catch( ... ) {
-        va_end(ap);
-        throw;
-    }
-#endif
+    result = vasprintf(sptr, format, ap);
     va_end(ap);
     return result;
 }
 
-// Like sprintf, but when return value >= 0 it returns a pointer to a malloc'd string in *sptr.
+// Like sprintf, but when return value >= 0 it returns
+// a pointer to a malloc'd string in *sptr.
 // If return >= 0, use free to delete *sptr.
 int vasprintf( char **sptr, const char *__restrict format, va_list ap )
 {
     *sptr = NULL;
-    int count = _vsnprintf( NULL, 0, format, ap ); // Query the buffer size required.
-    if( count >= 0 ) {
-        std::unique_ptr<char, free_deleter> p( static_cast<char*>(malloc(count+1)) );
-        if ( ! p )
-            return -1;
-        if ( vsnprintf( p.get(), count+1, format, ap ) == count ) // We should have used exactly what was required.
-            *sptr = p.release();
-        else // Otherwise something is wrong, likely a bug in vsnprintf. If so free the memory and report the error.
-            return -1; // Pointer will get automaticlaly deleted.
+    // Query the count required.
+    int count = _vsnprintf( NULL, 0, format, ap );
+    if (count < 0)
+        return count;
+    size_t buffer_size = static_cast<size_t>(count) + 1;
+    char* p = static_cast<char*>(malloc(buffer_size));
+    if ( ! p )
+        return -1;
+    // If we haven't used exactly what was required, something is wrong.
+    // Maybe bug in vsnprintf. Report the error and return.
+    if (_vsnprintf(p, buffer_size, format, ap) != count) {
+        free(p);
+        return -1;
     }
-
+    // All good. This is returning memory to the caller not freeing it.
+    *sptr = p;
     return count;
 }
 
-// Returns >= 0: the number of wide characters found in the multi byte sequence src (of src_size_bytes),
-// that fit in the buffer dst (of max_dest_chars elements size). The count returned excludes the null terminator.
-// When dst is NULL, no characters are copied and no "out" parameters are updated.
+// Returns >= 0: the number of wide characters found in the 
+// multi byte sequence src (of src_size_bytes), that fit in the buffer dst 
+// (of max_dest_chars elements size). The count returned excludes the
+// null terminator. When dst is NULL, no characters are copied 
+// and no "out" parameters are updated.
 // Returns (size_t) -1: an incomplete sequence encountered.
-// Leaves *src pointing the next character to convert or NULL if a null character was converted from *src.
+// Leaves *src pointing the next character to convert or NULL 
+// if a null character was converted from *src.
 size_t mbsnrtowcs( wchar_t *__restrict dst, const char **__restrict src,
                    size_t src_size_bytes, size_t max_dest_chars, mbstate_t *__restrict ps )
 {
@@ -112,10 +105,13 @@ size_t mbsnrtowcs( wchar_t *__restrict dst, const char **__restrict src,
 }
 
 // Converts max_source_chars from the wide character buffer pointer to by *src,
-// into the multi byte character sequence buffer stored at dst which must be dst_size_bytes bytes in size.
-// Returns >= 0: the number of bytes in the sequence sequence converted frome *src, excluding the null terminator.
+// into the multi byte character sequence buffer stored at dst which must be
+// dst_size_bytes bytes in size.
+// Returns >= 0: the number of bytes in the sequence sequence 
+// converted frome *src, excluding the null terminator.
 // Returns size_t(-1) if an error occurs, also sets errno.
-// If dst is NULL dst_size_bytes is ignored and no bytes are copied to dst and no "out" parameters are updated.
+// If dst is NULL dst_size_bytes is ignored and no bytes are copied to dst 
+// and no "out" parameters are updated.
 size_t wcsnrtombs( char *__restrict dst, const wchar_t **__restrict src,
                    size_t max_source_chars, size_t dst_size_bytes, mbstate_t *__restrict ps )
 {
@@ -138,7 +134,8 @@ size_t wcsnrtombs( char *__restrict dst, const wchar_t **__restrict src,
             result = wcrtomb_s( &char_size, dst + dest_converted, dest_remaining, c, ps);
         else
             result = wcrtomb_s( &char_size, NULL, 0, c, ps);
-        // If result is zero there is no error and char_size contains the size of the multi-byte-sequence converted.
+        // If result is zero there is no error and char_size contains the 
+        // size of the multi-byte-sequence converted.
         // Otherwise result indicates an errno type error.
         if ( result == no_error ) {
             if ( c == L'\0' ) {
diff --git a/system/lib/libcxx/system_error.cpp b/system/lib/libcxx/system_error.cpp
index 7376b770ecf89..b40409f854ab9 100644
--- a/system/lib/libcxx/system_error.cpp
+++ b/system/lib/libcxx/system_error.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define	_LIBCPP_BUILDING_SYSTEM_ERROR
 #include "system_error"
 #include "string"
 #include "cstring"
diff --git a/system/lib/libcxx/thread.cpp b/system/lib/libcxx/thread.cpp
index 1fd8bb047c892..338a8a24cef56 100644
--- a/system/lib/libcxx/thread.cpp
+++ b/system/lib/libcxx/thread.cpp
@@ -14,9 +14,9 @@
 #include "limits"
 #include <sys/types.h>
 #if !defined(_WIN32)
-#if !defined(__sun__) && !defined(__linux__)
+#if !defined(__sun__) && !defined(__linux__) && !defined(_AIX)
 #include <sys/sysctl.h>
-#endif // !__sun__ && !__linux__
+#endif // !__sun__ && !__linux__ && !_AIX
 #include <unistd.h>
 #endif // !_WIN32
 
@@ -89,7 +89,11 @@ thread::hardware_concurrency() _NOEXCEPT
 #else  // defined(CTL_HW) && defined(HW_NCPU)
     // TODO: grovel through /proc or check cpuid on x86 and similar
     // instructions on other architectures.
-#warning hardware_concurrency not yet implemented
+#   if defined(_MSC_VER) && ! defined(__clang__)
+        _LIBCPP_WARNING("hardware_concurrency not yet implemented")
+#   else
+#       warning hardware_concurrency not yet implemented
+#   endif
     return 0;  // Means not computable [thread.thread.static]
 #endif  // defined(CTL_HW) && defined(HW_NCPU)
 }
diff --git a/system/lib/libcxx/typeinfo.cpp b/system/lib/libcxx/typeinfo.cpp
index 60828944a1bc8..b4281209170cd 100644
--- a/system/lib/libcxx/typeinfo.cpp
+++ b/system/lib/libcxx/typeinfo.cpp
@@ -20,12 +20,18 @@
 
 #include "typeinfo"
 
-#if !(defined(_LIBCPPABI_VERSION) || defined(LIBCXXRT))
+#if !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION)
 
 std::bad_cast::bad_cast() _NOEXCEPT
 {
 }
 
+std::bad_typeid::bad_typeid() _NOEXCEPT
+{
+}
+
+#ifndef __GLIBCXX__
+
 std::bad_cast::~bad_cast() _NOEXCEPT
 {
 }
@@ -36,10 +42,6 @@ std::bad_cast::what() const _NOEXCEPT
   return "std::bad_cast";
 }
 
-std::bad_typeid::bad_typeid() _NOEXCEPT
-{
-}
-
 std::bad_typeid::~bad_typeid() _NOEXCEPT
 {
 }
@@ -67,4 +69,5 @@ std::bad_typeid::what() const _NOEXCEPT
   }
 #endif
 
-#endif  // _LIBCPPABI_VERSION
+#endif  // !__GLIBCXX__
+#endif  // !LIBCXXRT && !_LIBCPPABI_VERSION
diff --git a/system/lib/libcxx/valarray.cpp b/system/lib/libcxx/valarray.cpp
index 2d8db52ac36b2..e4c9ed024620c 100644
--- a/system/lib/libcxx/valarray.cpp
+++ b/system/lib/libcxx/valarray.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
+
 #include "valarray"
 
 _LIBCPP_BEGIN_NAMESPACE_STD

From 8a8f0348a15b274ab2fc1f98a434fe8c7e02ff82 Mon Sep 17 00:00:00 2001
From: Bruce Mitchener <bruce.mitchener@gmail.com>
Date: Thu, 7 Nov 2013 16:08:02 +0700
Subject: [PATCH 87/93] Don't use atomic as that breaks our version of clang.

---
 system/include/libcxx/ios | 2 +-
 system/lib/libcxx/ios.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/system/include/libcxx/ios b/system/include/libcxx/ios
index d95f18a5e1e0f..b6cf07665172a 100644
--- a/system/include/libcxx/ios
+++ b/system/include/libcxx/ios
@@ -367,7 +367,7 @@ private:
     int*            __index_;
     size_t          __event_size_;
     size_t          __event_cap_;
-#if __has_feature(cxx_atomic)
+#if __has_feature(cxx_atomic) && !defined(__EMSCRIPTEN__)
     static atomic<int> __xindex_;
 #else
     static int      __xindex_;
diff --git a/system/lib/libcxx/ios.cpp b/system/lib/libcxx/ios.cpp
index bbe3c072e675a..004d318320c05 100644
--- a/system/lib/libcxx/ios.cpp
+++ b/system/lib/libcxx/ios.cpp
@@ -149,7 +149,7 @@ ios_base::getloc() const
 }
 
 // xalloc
-#if __has_feature(cxx_atomic)
+#if __has_feature(cxx_atomic) && !defined(__EMSCRIPTEN__)
 atomic<int> ios_base::__xindex_ = ATOMIC_VAR_INIT(0);
 #else
 int ios_base::__xindex_ = 0;

From ad1da1e6685d4483e096d7e0bbd8e38e686bd322 Mon Sep 17 00:00:00 2001
From: Bruce Mitchener <bruce.mitchener@gmail.com>
Date: Thu, 7 Nov 2013 16:08:19 +0700
Subject: [PATCH 88/93] Bump version & regen symbols for libcxx.

---
 system/lib/libcxx/symbols | 355 ++++++++++++++++++++------------------
 tools/shared.py           |   2 +-
 2 files changed, 188 insertions(+), 169 deletions(-)

diff --git a/system/lib/libcxx/symbols b/system/lib/libcxx/symbols
index 92a665d861a4b..51368bce4ef8a 100644
--- a/system/lib/libcxx/symbols
+++ b/system/lib/libcxx/symbols
@@ -235,27 +235,27 @@
          W _ZNKSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentrycvbEv
          W _ZNKSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentrycvbEv
          T _ZNKSt3__113random_device7entropyEv
-         T _ZNKSt3__114__codecvt_utf8IDiE10do_unshiftER10_mbstate_tPcS4_RS4_
+         T _ZNKSt3__114__codecvt_utf8IDiE10do_unshiftER11__mbstate_tPcS4_RS4_
          T _ZNKSt3__114__codecvt_utf8IDiE11do_encodingEv
          T _ZNKSt3__114__codecvt_utf8IDiE13do_max_lengthEv
          T _ZNKSt3__114__codecvt_utf8IDiE16do_always_noconvEv
-         T _ZNKSt3__114__codecvt_utf8IDiE5do_inER10_mbstate_tPKcS5_RS5_PDiS7_RS7_
-         T _ZNKSt3__114__codecvt_utf8IDiE6do_outER10_mbstate_tPKDiS5_RS5_PcS7_RS7_
-         T _ZNKSt3__114__codecvt_utf8IDiE9do_lengthER10_mbstate_tPKcS5_j
-         T _ZNKSt3__114__codecvt_utf8IDsE10do_unshiftER10_mbstate_tPcS4_RS4_
+         T _ZNKSt3__114__codecvt_utf8IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_
+         T _ZNKSt3__114__codecvt_utf8IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_
+         T _ZNKSt3__114__codecvt_utf8IDiE9do_lengthER11__mbstate_tPKcS5_j
+         T _ZNKSt3__114__codecvt_utf8IDsE10do_unshiftER11__mbstate_tPcS4_RS4_
          T _ZNKSt3__114__codecvt_utf8IDsE11do_encodingEv
          T _ZNKSt3__114__codecvt_utf8IDsE13do_max_lengthEv
          T _ZNKSt3__114__codecvt_utf8IDsE16do_always_noconvEv
-         T _ZNKSt3__114__codecvt_utf8IDsE5do_inER10_mbstate_tPKcS5_RS5_PDsS7_RS7_
-         T _ZNKSt3__114__codecvt_utf8IDsE6do_outER10_mbstate_tPKDsS5_RS5_PcS7_RS7_
-         T _ZNKSt3__114__codecvt_utf8IDsE9do_lengthER10_mbstate_tPKcS5_j
-         T _ZNKSt3__114__codecvt_utf8IwE10do_unshiftER10_mbstate_tPcS4_RS4_
+         T _ZNKSt3__114__codecvt_utf8IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_
+         T _ZNKSt3__114__codecvt_utf8IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_
+         T _ZNKSt3__114__codecvt_utf8IDsE9do_lengthER11__mbstate_tPKcS5_j
+         T _ZNKSt3__114__codecvt_utf8IwE10do_unshiftER11__mbstate_tPcS4_RS4_
          T _ZNKSt3__114__codecvt_utf8IwE11do_encodingEv
          T _ZNKSt3__114__codecvt_utf8IwE13do_max_lengthEv
          T _ZNKSt3__114__codecvt_utf8IwE16do_always_noconvEv
-         T _ZNKSt3__114__codecvt_utf8IwE5do_inER10_mbstate_tPKcS5_RS5_PwS7_RS7_
-         T _ZNKSt3__114__codecvt_utf8IwE6do_outER10_mbstate_tPKwS5_RS5_PcS7_RS7_
-         T _ZNKSt3__114__codecvt_utf8IwE9do_lengthER10_mbstate_tPKcS5_j
+         T _ZNKSt3__114__codecvt_utf8IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_
+         T _ZNKSt3__114__codecvt_utf8IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_
+         T _ZNKSt3__114__codecvt_utf8IwE9do_lengthER11__mbstate_tPKcS5_j
          T _ZNKSt3__114collate_bynameIcE10do_compareEPKcS3_S3_S3_
          T _ZNKSt3__114collate_bynameIcE12do_transformEPKcS3_
          T _ZNKSt3__114collate_bynameIwE10do_compareEPKwS3_S3_S3_
@@ -263,48 +263,48 @@
          T _ZNKSt3__114error_category10equivalentERKNS_10error_codeEi
          T _ZNKSt3__114error_category10equivalentEiRKNS_15error_conditionE
          T _ZNKSt3__114error_category23default_error_conditionEi
-         T _ZNKSt3__115__codecvt_utf16IDiLb0EE10do_unshiftER10_mbstate_tPcS4_RS4_
+         T _ZNKSt3__115__codecvt_utf16IDiLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_
          T _ZNKSt3__115__codecvt_utf16IDiLb0EE11do_encodingEv
          T _ZNKSt3__115__codecvt_utf16IDiLb0EE13do_max_lengthEv
          T _ZNKSt3__115__codecvt_utf16IDiLb0EE16do_always_noconvEv
-         T _ZNKSt3__115__codecvt_utf16IDiLb0EE5do_inER10_mbstate_tPKcS5_RS5_PDiS7_RS7_
-         T _ZNKSt3__115__codecvt_utf16IDiLb0EE6do_outER10_mbstate_tPKDiS5_RS5_PcS7_RS7_
-         T _ZNKSt3__115__codecvt_utf16IDiLb0EE9do_lengthER10_mbstate_tPKcS5_j
-         T _ZNKSt3__115__codecvt_utf16IDiLb1EE10do_unshiftER10_mbstate_tPcS4_RS4_
+         T _ZNKSt3__115__codecvt_utf16IDiLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_
+         T _ZNKSt3__115__codecvt_utf16IDiLb0EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_
+         T _ZNKSt3__115__codecvt_utf16IDiLb0EE9do_lengthER11__mbstate_tPKcS5_j
+         T _ZNKSt3__115__codecvt_utf16IDiLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_
          T _ZNKSt3__115__codecvt_utf16IDiLb1EE11do_encodingEv
          T _ZNKSt3__115__codecvt_utf16IDiLb1EE13do_max_lengthEv
          T _ZNKSt3__115__codecvt_utf16IDiLb1EE16do_always_noconvEv
-         T _ZNKSt3__115__codecvt_utf16IDiLb1EE5do_inER10_mbstate_tPKcS5_RS5_PDiS7_RS7_
-         T _ZNKSt3__115__codecvt_utf16IDiLb1EE6do_outER10_mbstate_tPKDiS5_RS5_PcS7_RS7_
-         T _ZNKSt3__115__codecvt_utf16IDiLb1EE9do_lengthER10_mbstate_tPKcS5_j
-         T _ZNKSt3__115__codecvt_utf16IDsLb0EE10do_unshiftER10_mbstate_tPcS4_RS4_
+         T _ZNKSt3__115__codecvt_utf16IDiLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_
+         T _ZNKSt3__115__codecvt_utf16IDiLb1EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_
+         T _ZNKSt3__115__codecvt_utf16IDiLb1EE9do_lengthER11__mbstate_tPKcS5_j
+         T _ZNKSt3__115__codecvt_utf16IDsLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_
          T _ZNKSt3__115__codecvt_utf16IDsLb0EE11do_encodingEv
          T _ZNKSt3__115__codecvt_utf16IDsLb0EE13do_max_lengthEv
          T _ZNKSt3__115__codecvt_utf16IDsLb0EE16do_always_noconvEv
-         T _ZNKSt3__115__codecvt_utf16IDsLb0EE5do_inER10_mbstate_tPKcS5_RS5_PDsS7_RS7_
-         T _ZNKSt3__115__codecvt_utf16IDsLb0EE6do_outER10_mbstate_tPKDsS5_RS5_PcS7_RS7_
-         T _ZNKSt3__115__codecvt_utf16IDsLb0EE9do_lengthER10_mbstate_tPKcS5_j
-         T _ZNKSt3__115__codecvt_utf16IDsLb1EE10do_unshiftER10_mbstate_tPcS4_RS4_
+         T _ZNKSt3__115__codecvt_utf16IDsLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_
+         T _ZNKSt3__115__codecvt_utf16IDsLb0EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_
+         T _ZNKSt3__115__codecvt_utf16IDsLb0EE9do_lengthER11__mbstate_tPKcS5_j
+         T _ZNKSt3__115__codecvt_utf16IDsLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_
          T _ZNKSt3__115__codecvt_utf16IDsLb1EE11do_encodingEv
          T _ZNKSt3__115__codecvt_utf16IDsLb1EE13do_max_lengthEv
          T _ZNKSt3__115__codecvt_utf16IDsLb1EE16do_always_noconvEv
-         T _ZNKSt3__115__codecvt_utf16IDsLb1EE5do_inER10_mbstate_tPKcS5_RS5_PDsS7_RS7_
-         T _ZNKSt3__115__codecvt_utf16IDsLb1EE6do_outER10_mbstate_tPKDsS5_RS5_PcS7_RS7_
-         T _ZNKSt3__115__codecvt_utf16IDsLb1EE9do_lengthER10_mbstate_tPKcS5_j
-         T _ZNKSt3__115__codecvt_utf16IwLb0EE10do_unshiftER10_mbstate_tPcS4_RS4_
+         T _ZNKSt3__115__codecvt_utf16IDsLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_
+         T _ZNKSt3__115__codecvt_utf16IDsLb1EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_
+         T _ZNKSt3__115__codecvt_utf16IDsLb1EE9do_lengthER11__mbstate_tPKcS5_j
+         T _ZNKSt3__115__codecvt_utf16IwLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_
          T _ZNKSt3__115__codecvt_utf16IwLb0EE11do_encodingEv
          T _ZNKSt3__115__codecvt_utf16IwLb0EE13do_max_lengthEv
          T _ZNKSt3__115__codecvt_utf16IwLb0EE16do_always_noconvEv
-         T _ZNKSt3__115__codecvt_utf16IwLb0EE5do_inER10_mbstate_tPKcS5_RS5_PwS7_RS7_
-         T _ZNKSt3__115__codecvt_utf16IwLb0EE6do_outER10_mbstate_tPKwS5_RS5_PcS7_RS7_
-         T _ZNKSt3__115__codecvt_utf16IwLb0EE9do_lengthER10_mbstate_tPKcS5_j
-         T _ZNKSt3__115__codecvt_utf16IwLb1EE10do_unshiftER10_mbstate_tPcS4_RS4_
+         T _ZNKSt3__115__codecvt_utf16IwLb0EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_
+         T _ZNKSt3__115__codecvt_utf16IwLb0EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_
+         T _ZNKSt3__115__codecvt_utf16IwLb0EE9do_lengthER11__mbstate_tPKcS5_j
+         T _ZNKSt3__115__codecvt_utf16IwLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_
          T _ZNKSt3__115__codecvt_utf16IwLb1EE11do_encodingEv
          T _ZNKSt3__115__codecvt_utf16IwLb1EE13do_max_lengthEv
          T _ZNKSt3__115__codecvt_utf16IwLb1EE16do_always_noconvEv
-         T _ZNKSt3__115__codecvt_utf16IwLb1EE5do_inER10_mbstate_tPKcS5_RS5_PwS7_RS7_
-         T _ZNKSt3__115__codecvt_utf16IwLb1EE6do_outER10_mbstate_tPKwS5_RS5_PcS7_RS7_
-         T _ZNKSt3__115__codecvt_utf16IwLb1EE9do_lengthER10_mbstate_tPKcS5_j
+         T _ZNKSt3__115__codecvt_utf16IwLb1EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_
+         T _ZNKSt3__115__codecvt_utf16IwLb1EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_
+         T _ZNKSt3__115__codecvt_utf16IwLb1EE9do_lengthER11__mbstate_tPKcS5_j
          W _ZNKSt3__115basic_streambufIcNS_11char_traitsIcEEE4gptrEv
          W _ZNKSt3__115basic_streambufIcNS_11char_traitsIcEEE4pptrEv
          W _ZNKSt3__115basic_streambufIcNS_11char_traitsIcEEE5ebackEv
@@ -377,27 +377,27 @@
          T _ZNKSt3__119__iostream_category4nameEv
          T _ZNKSt3__119__iostream_category7messageEi
          T _ZNKSt3__119__shared_weak_count13__get_deleterERKSt9type_info
-         T _ZNKSt3__120__codecvt_utf8_utf16IDiE10do_unshiftER10_mbstate_tPcS4_RS4_
+         T _ZNKSt3__120__codecvt_utf8_utf16IDiE10do_unshiftER11__mbstate_tPcS4_RS4_
          T _ZNKSt3__120__codecvt_utf8_utf16IDiE11do_encodingEv
          T _ZNKSt3__120__codecvt_utf8_utf16IDiE13do_max_lengthEv
          T _ZNKSt3__120__codecvt_utf8_utf16IDiE16do_always_noconvEv
-         T _ZNKSt3__120__codecvt_utf8_utf16IDiE5do_inER10_mbstate_tPKcS5_RS5_PDiS7_RS7_
-         T _ZNKSt3__120__codecvt_utf8_utf16IDiE6do_outER10_mbstate_tPKDiS5_RS5_PcS7_RS7_
-         T _ZNKSt3__120__codecvt_utf8_utf16IDiE9do_lengthER10_mbstate_tPKcS5_j
-         T _ZNKSt3__120__codecvt_utf8_utf16IDsE10do_unshiftER10_mbstate_tPcS4_RS4_
+         T _ZNKSt3__120__codecvt_utf8_utf16IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_
+         T _ZNKSt3__120__codecvt_utf8_utf16IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_
+         T _ZNKSt3__120__codecvt_utf8_utf16IDiE9do_lengthER11__mbstate_tPKcS5_j
+         T _ZNKSt3__120__codecvt_utf8_utf16IDsE10do_unshiftER11__mbstate_tPcS4_RS4_
          T _ZNKSt3__120__codecvt_utf8_utf16IDsE11do_encodingEv
          T _ZNKSt3__120__codecvt_utf8_utf16IDsE13do_max_lengthEv
          T _ZNKSt3__120__codecvt_utf8_utf16IDsE16do_always_noconvEv
-         T _ZNKSt3__120__codecvt_utf8_utf16IDsE5do_inER10_mbstate_tPKcS5_RS5_PDsS7_RS7_
-         T _ZNKSt3__120__codecvt_utf8_utf16IDsE6do_outER10_mbstate_tPKDsS5_RS5_PcS7_RS7_
-         T _ZNKSt3__120__codecvt_utf8_utf16IDsE9do_lengthER10_mbstate_tPKcS5_j
-         T _ZNKSt3__120__codecvt_utf8_utf16IwE10do_unshiftER10_mbstate_tPcS4_RS4_
+         T _ZNKSt3__120__codecvt_utf8_utf16IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_
+         T _ZNKSt3__120__codecvt_utf8_utf16IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_
+         T _ZNKSt3__120__codecvt_utf8_utf16IDsE9do_lengthER11__mbstate_tPKcS5_j
+         T _ZNKSt3__120__codecvt_utf8_utf16IwE10do_unshiftER11__mbstate_tPcS4_RS4_
          T _ZNKSt3__120__codecvt_utf8_utf16IwE11do_encodingEv
          T _ZNKSt3__120__codecvt_utf8_utf16IwE13do_max_lengthEv
          T _ZNKSt3__120__codecvt_utf8_utf16IwE16do_always_noconvEv
-         T _ZNKSt3__120__codecvt_utf8_utf16IwE5do_inER10_mbstate_tPKcS5_RS5_PwS7_RS7_
-         T _ZNKSt3__120__codecvt_utf8_utf16IwE6do_outER10_mbstate_tPKwS5_RS5_PcS7_RS7_
-         T _ZNKSt3__120__codecvt_utf8_utf16IwE9do_lengthER10_mbstate_tPKcS5_j
+         T _ZNKSt3__120__codecvt_utf8_utf16IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_
+         T _ZNKSt3__120__codecvt_utf8_utf16IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_
+         T _ZNKSt3__120__codecvt_utf8_utf16IwE9do_lengthER11__mbstate_tPKcS5_j
          T _ZNKSt3__120__time_get_c_storageIcE3__XEv
          T _ZNKSt3__120__time_get_c_storageIcE3__cEv
          T _ZNKSt3__120__time_get_c_storageIcE3__rEv
@@ -450,34 +450,34 @@
          T _ZNKSt3__16locale9has_facetERNS0_2idE
          T _ZNKSt3__16locale9use_facetERNS0_2idE
          T _ZNKSt3__16localeeqERKS0_
-         T _ZNKSt3__17codecvtIDic10_mbstate_tE10do_unshiftERS1_PcS4_RS4_
-         T _ZNKSt3__17codecvtIDic10_mbstate_tE11do_encodingEv
-         T _ZNKSt3__17codecvtIDic10_mbstate_tE13do_max_lengthEv
-         T _ZNKSt3__17codecvtIDic10_mbstate_tE16do_always_noconvEv
-         T _ZNKSt3__17codecvtIDic10_mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_
-         T _ZNKSt3__17codecvtIDic10_mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_
-         T _ZNKSt3__17codecvtIDic10_mbstate_tE9do_lengthERS1_PKcS5_j
-         T _ZNKSt3__17codecvtIDsc10_mbstate_tE10do_unshiftERS1_PcS4_RS4_
-         T _ZNKSt3__17codecvtIDsc10_mbstate_tE11do_encodingEv
-         T _ZNKSt3__17codecvtIDsc10_mbstate_tE13do_max_lengthEv
-         T _ZNKSt3__17codecvtIDsc10_mbstate_tE16do_always_noconvEv
-         T _ZNKSt3__17codecvtIDsc10_mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_
-         T _ZNKSt3__17codecvtIDsc10_mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_
-         T _ZNKSt3__17codecvtIDsc10_mbstate_tE9do_lengthERS1_PKcS5_j
-         T _ZNKSt3__17codecvtIcc10_mbstate_tE10do_unshiftERS1_PcS4_RS4_
-         T _ZNKSt3__17codecvtIcc10_mbstate_tE11do_encodingEv
-         T _ZNKSt3__17codecvtIcc10_mbstate_tE13do_max_lengthEv
-         T _ZNKSt3__17codecvtIcc10_mbstate_tE16do_always_noconvEv
-         T _ZNKSt3__17codecvtIcc10_mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_
-         T _ZNKSt3__17codecvtIcc10_mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_
-         T _ZNKSt3__17codecvtIcc10_mbstate_tE9do_lengthERS1_PKcS5_j
-         T _ZNKSt3__17codecvtIwc10_mbstate_tE10do_unshiftERS1_PcS4_RS4_
-         T _ZNKSt3__17codecvtIwc10_mbstate_tE11do_encodingEv
-         T _ZNKSt3__17codecvtIwc10_mbstate_tE13do_max_lengthEv
-         T _ZNKSt3__17codecvtIwc10_mbstate_tE16do_always_noconvEv
-         T _ZNKSt3__17codecvtIwc10_mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_
-         T _ZNKSt3__17codecvtIwc10_mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_
-         T _ZNKSt3__17codecvtIwc10_mbstate_tE9do_lengthERS1_PKcS5_j
+         T _ZNKSt3__17codecvtIDic11__mbstate_tE10do_unshiftERS1_PcS4_RS4_
+         T _ZNKSt3__17codecvtIDic11__mbstate_tE11do_encodingEv
+         T _ZNKSt3__17codecvtIDic11__mbstate_tE13do_max_lengthEv
+         T _ZNKSt3__17codecvtIDic11__mbstate_tE16do_always_noconvEv
+         T _ZNKSt3__17codecvtIDic11__mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_
+         T _ZNKSt3__17codecvtIDic11__mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_
+         T _ZNKSt3__17codecvtIDic11__mbstate_tE9do_lengthERS1_PKcS5_j
+         T _ZNKSt3__17codecvtIDsc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_
+         T _ZNKSt3__17codecvtIDsc11__mbstate_tE11do_encodingEv
+         T _ZNKSt3__17codecvtIDsc11__mbstate_tE13do_max_lengthEv
+         T _ZNKSt3__17codecvtIDsc11__mbstate_tE16do_always_noconvEv
+         T _ZNKSt3__17codecvtIDsc11__mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_
+         T _ZNKSt3__17codecvtIDsc11__mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_
+         T _ZNKSt3__17codecvtIDsc11__mbstate_tE9do_lengthERS1_PKcS5_j
+         T _ZNKSt3__17codecvtIcc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_
+         T _ZNKSt3__17codecvtIcc11__mbstate_tE11do_encodingEv
+         T _ZNKSt3__17codecvtIcc11__mbstate_tE13do_max_lengthEv
+         T _ZNKSt3__17codecvtIcc11__mbstate_tE16do_always_noconvEv
+         T _ZNKSt3__17codecvtIcc11__mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_
+         T _ZNKSt3__17codecvtIcc11__mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_
+         T _ZNKSt3__17codecvtIcc11__mbstate_tE9do_lengthERS1_PKcS5_j
+         T _ZNKSt3__17codecvtIwc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_
+         T _ZNKSt3__17codecvtIwc11__mbstate_tE11do_encodingEv
+         T _ZNKSt3__17codecvtIwc11__mbstate_tE13do_max_lengthEv
+         T _ZNKSt3__17codecvtIwc11__mbstate_tE16do_always_noconvEv
+         T _ZNKSt3__17codecvtIwc11__mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_
+         T _ZNKSt3__17codecvtIwc11__mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_
+         T _ZNKSt3__17codecvtIwc11__mbstate_tE9do_lengthERS1_PKcS5_j
          W _ZNKSt3__17collateIcE10do_compareEPKcS3_S3_S3_
          W _ZNKSt3__17collateIcE12do_transformEPKcS3_
          W _ZNKSt3__17collateIcE4hashEPKcS3_
@@ -490,6 +490,15 @@
          W _ZNKSt3__17collateIwE7compareEPKwS3_S3_S3_
          W _ZNKSt3__17collateIwE7do_hashEPKwS3_
          W _ZNKSt3__17collateIwE9transformEPKwS3_
+         C _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__do_get_signedIlEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__do_get_signedIxEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__do_get_unsignedIjEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__do_get_unsignedImEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__do_get_unsignedItEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__do_get_unsignedIyEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE23__do_get_floating_pointIdEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE23__do_get_floating_pointIeEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE23__do_get_floating_pointIfEES4_S4_S4_RNS_8ios_baseERjRT_
          W _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjRPv
          W _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjRb
          W _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjRd
@@ -512,6 +521,15 @@
          W _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRx
          W _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRy
          W _ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_
+         C _ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__do_get_signedIlEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__do_get_signedIxEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__do_get_unsignedIjEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__do_get_unsignedImEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__do_get_unsignedItEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__do_get_unsignedIyEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE23__do_get_floating_pointIdEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE23__do_get_floating_pointIeEES4_S4_S4_RNS_8ios_baseERjRT_
+         C _ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE23__do_get_floating_pointIfEES4_S4_S4_RNS_8ios_baseERjRT_
          W _ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjRPv
          W _ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjRb
          W _ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjRd
@@ -751,21 +769,21 @@
          T _ZNSt16nested_exceptionD0Ev
          T _ZNSt16nested_exceptionD1Ev
          T _ZNSt16nested_exceptionD2Ev
-         C _ZNSt3__110__sscanf_lEPKcPvS1_z
+         C _ZNSt3__110__sscanf_lEPKcP15__locale_structS1_z
          C _ZNSt3__110__stdinbufIcE5imbueERKNS_6localeE
          C _ZNSt3__110__stdinbufIcE5uflowEv
          C _ZNSt3__110__stdinbufIcE9__getcharEb
          C _ZNSt3__110__stdinbufIcE9pbackfailEi
          C _ZNSt3__110__stdinbufIcE9underflowEv
-         C _ZNSt3__110__stdinbufIcEC2EP7__sFILEP10_mbstate_t
+         C _ZNSt3__110__stdinbufIcEC2EP8_IO_FILEP11__mbstate_t
          C _ZNSt3__110__stdinbufIcED0Ev
          C _ZNSt3__110__stdinbufIcED1Ev
          C _ZNSt3__110__stdinbufIwE5imbueERKNS_6localeE
          C _ZNSt3__110__stdinbufIwE5uflowEv
          C _ZNSt3__110__stdinbufIwE9__getcharEb
-         C _ZNSt3__110__stdinbufIwE9pbackfailEi
+         C _ZNSt3__110__stdinbufIwE9pbackfailEj
          C _ZNSt3__110__stdinbufIwE9underflowEv
-         C _ZNSt3__110__stdinbufIwEC2EP7__sFILEP10_mbstate_t
+         C _ZNSt3__110__stdinbufIwEC2EP8_IO_FILEP11__mbstate_t
          C _ZNSt3__110__stdinbufIwED0Ev
          C _ZNSt3__110__stdinbufIwED1Ev
          T _ZNSt3__110__time_getC1EPKc
@@ -867,12 +885,14 @@
          W _ZNSt3__111__money_putIwEC2Ev
          C _ZNSt3__111__stdoutbufIcE4syncEv
          C _ZNSt3__111__stdoutbufIcE5imbueERKNS_6localeE
+         C _ZNSt3__111__stdoutbufIcE6xsputnEPKci
          C _ZNSt3__111__stdoutbufIcE8overflowEi
          C _ZNSt3__111__stdoutbufIcED0Ev
          C _ZNSt3__111__stdoutbufIcED1Ev
          C _ZNSt3__111__stdoutbufIwE4syncEv
          C _ZNSt3__111__stdoutbufIwE5imbueERKNS_6localeE
-         C _ZNSt3__111__stdoutbufIwE8overflowEi
+         C _ZNSt3__111__stdoutbufIwE6xsputnEPKwi
+         C _ZNSt3__111__stdoutbufIwE8overflowEj
          C _ZNSt3__111__stdoutbufIwED0Ev
          C _ZNSt3__111__stdoutbufIwED1Ev
          T _ZNSt3__111regex_errorC1ENS_15regex_constants10error_typeE
@@ -889,7 +909,7 @@
          T _ZNSt3__111timed_mutexD1Ev
          T _ZNSt3__111timed_mutexD2Ev
          D _ZNSt3__111try_to_lockE
-         C _ZNSt3__112__asprintf_lEPPcPvPKcz
+         C _ZNSt3__112__asprintf_lEPPcP15__locale_structPKcz
          C _ZNSt3__112__do_messageD0Ev
          C _ZNSt3__112__do_messageD1Ev
          T _ZNSt3__112__do_nothingEPv
@@ -903,7 +923,7 @@
          T _ZNSt3__112__rs_defaultD1Ev
          T _ZNSt3__112__rs_defaultD2Ev
          T _ZNSt3__112__rs_defaultclEv
-         C _ZNSt3__112__snprintf_lEPcjPvPKcz
+         C _ZNSt3__112__snprintf_lEPcjP15__locale_structPKcz
          T _ZNSt3__112bad_weak_ptrD0Ev
          T _ZNSt3__112bad_weak_ptrD1Ev
          T _ZNSt3__112bad_weak_ptrD2Ev
@@ -1190,7 +1210,7 @@
          T _ZNSt3__112strstreambuf6__initEPciS1_
          T _ZNSt3__112strstreambuf6freezeEb
          T _ZNSt3__112strstreambuf7seekoffExNS_8ios_base7seekdirEj
-         T _ZNSt3__112strstreambuf7seekposENS_4fposI10_mbstate_tEEj
+         T _ZNSt3__112strstreambuf7seekposENS_4fposI11__mbstate_tEEj
          T _ZNSt3__112strstreambuf8overflowEi
          T _ZNSt3__112strstreambuf9pbackfailEi
          T _ZNSt3__112strstreambuf9underflowEv
@@ -1240,7 +1260,7 @@
          W _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4readEPci
          W _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4swapERS3_
          W _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4syncEv
-         W _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI10_mbstate_tEE
+         W _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI11__mbstate_tEE
          W _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgExNS_8ios_base7seekdirE
          W _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5tellgEv
          W _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5ungetEv
@@ -1286,11 +1306,11 @@
          W _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4readEPwi
          W _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4swapERS3_
          W _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4syncEv
-         W _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI10_mbstate_tEE
+         W _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI11__mbstate_tEE
          W _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgExNS_8ios_base7seekdirE
          W _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5tellgEv
          W _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5ungetEv
-         W _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6ignoreEii
+         W _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6ignoreEij
          W _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC1ERS3_b
          W _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC2ERS3_b
          W _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwi
@@ -1325,7 +1345,7 @@
          W _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE3putEc
          W _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE4swapERS3_
          W _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5flushEv
-         W _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpENS_4fposI10_mbstate_tEE
+         W _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpENS_4fposI11__mbstate_tEE
          W _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpExNS_8ios_base7seekdirE
          W _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5tellpEv
          W _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5writeEPKci
@@ -1363,7 +1383,7 @@
          W _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE3putEw
          W _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE4swapERS3_
          W _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5flushEv
-         W _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpENS_4fposI10_mbstate_tEE
+         W _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpENS_4fposI11__mbstate_tEE
          W _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpExNS_8ios_base7seekdirE
          W _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5tellpEv
          W _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5writeEPKwi
@@ -1436,34 +1456,34 @@
          W _ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev
          W _ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED2Ev
          W _ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEaSEOS3_
-         W _ZNSt3__114codecvt_bynameIDic10_mbstate_tEC1EPKcj
-         W _ZNSt3__114codecvt_bynameIDic10_mbstate_tEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
-         W _ZNSt3__114codecvt_bynameIDic10_mbstate_tEC2EPKcj
-         W _ZNSt3__114codecvt_bynameIDic10_mbstate_tEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
-         W _ZNSt3__114codecvt_bynameIDic10_mbstate_tED0Ev
-         W _ZNSt3__114codecvt_bynameIDic10_mbstate_tED1Ev
-         W _ZNSt3__114codecvt_bynameIDic10_mbstate_tED2Ev
-         W _ZNSt3__114codecvt_bynameIDsc10_mbstate_tEC1EPKcj
-         W _ZNSt3__114codecvt_bynameIDsc10_mbstate_tEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
-         W _ZNSt3__114codecvt_bynameIDsc10_mbstate_tEC2EPKcj
-         W _ZNSt3__114codecvt_bynameIDsc10_mbstate_tEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
-         W _ZNSt3__114codecvt_bynameIDsc10_mbstate_tED0Ev
-         W _ZNSt3__114codecvt_bynameIDsc10_mbstate_tED1Ev
-         W _ZNSt3__114codecvt_bynameIDsc10_mbstate_tED2Ev
-         W _ZNSt3__114codecvt_bynameIcc10_mbstate_tEC1EPKcj
-         W _ZNSt3__114codecvt_bynameIcc10_mbstate_tEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
-         W _ZNSt3__114codecvt_bynameIcc10_mbstate_tEC2EPKcj
-         W _ZNSt3__114codecvt_bynameIcc10_mbstate_tEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
-         W _ZNSt3__114codecvt_bynameIcc10_mbstate_tED0Ev
-         W _ZNSt3__114codecvt_bynameIcc10_mbstate_tED1Ev
-         W _ZNSt3__114codecvt_bynameIcc10_mbstate_tED2Ev
-         W _ZNSt3__114codecvt_bynameIwc10_mbstate_tEC1EPKcj
-         W _ZNSt3__114codecvt_bynameIwc10_mbstate_tEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
-         W _ZNSt3__114codecvt_bynameIwc10_mbstate_tEC2EPKcj
-         W _ZNSt3__114codecvt_bynameIwc10_mbstate_tEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
-         W _ZNSt3__114codecvt_bynameIwc10_mbstate_tED0Ev
-         W _ZNSt3__114codecvt_bynameIwc10_mbstate_tED1Ev
-         W _ZNSt3__114codecvt_bynameIwc10_mbstate_tED2Ev
+         W _ZNSt3__114codecvt_bynameIDic11__mbstate_tEC1EPKcj
+         W _ZNSt3__114codecvt_bynameIDic11__mbstate_tEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
+         W _ZNSt3__114codecvt_bynameIDic11__mbstate_tEC2EPKcj
+         W _ZNSt3__114codecvt_bynameIDic11__mbstate_tEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
+         W _ZNSt3__114codecvt_bynameIDic11__mbstate_tED0Ev
+         W _ZNSt3__114codecvt_bynameIDic11__mbstate_tED1Ev
+         W _ZNSt3__114codecvt_bynameIDic11__mbstate_tED2Ev
+         W _ZNSt3__114codecvt_bynameIDsc11__mbstate_tEC1EPKcj
+         W _ZNSt3__114codecvt_bynameIDsc11__mbstate_tEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
+         W _ZNSt3__114codecvt_bynameIDsc11__mbstate_tEC2EPKcj
+         W _ZNSt3__114codecvt_bynameIDsc11__mbstate_tEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
+         W _ZNSt3__114codecvt_bynameIDsc11__mbstate_tED0Ev
+         W _ZNSt3__114codecvt_bynameIDsc11__mbstate_tED1Ev
+         W _ZNSt3__114codecvt_bynameIDsc11__mbstate_tED2Ev
+         W _ZNSt3__114codecvt_bynameIcc11__mbstate_tEC1EPKcj
+         W _ZNSt3__114codecvt_bynameIcc11__mbstate_tEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
+         W _ZNSt3__114codecvt_bynameIcc11__mbstate_tEC2EPKcj
+         W _ZNSt3__114codecvt_bynameIcc11__mbstate_tEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
+         W _ZNSt3__114codecvt_bynameIcc11__mbstate_tED0Ev
+         W _ZNSt3__114codecvt_bynameIcc11__mbstate_tED1Ev
+         W _ZNSt3__114codecvt_bynameIcc11__mbstate_tED2Ev
+         W _ZNSt3__114codecvt_bynameIwc11__mbstate_tEC1EPKcj
+         W _ZNSt3__114codecvt_bynameIwc11__mbstate_tEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
+         W _ZNSt3__114codecvt_bynameIwc11__mbstate_tEC2EPKcj
+         W _ZNSt3__114codecvt_bynameIwc11__mbstate_tEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
+         W _ZNSt3__114codecvt_bynameIwc11__mbstate_tED0Ev
+         W _ZNSt3__114codecvt_bynameIwc11__mbstate_tED1Ev
+         W _ZNSt3__114codecvt_bynameIwc11__mbstate_tED2Ev
          T _ZNSt3__114collate_bynameIcEC1EPKcj
          T _ZNSt3__114collate_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj
          T _ZNSt3__114collate_bynameIcEC2EPKcj
@@ -1509,7 +1529,7 @@
          C _ZNSt3__115__time_get_tempIwED0Ev
          C _ZNSt3__115__time_get_tempIwED1Ev
          W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekoffExNS_8ios_base7seekdirEj
-         W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekposENS_4fposI10_mbstate_tEEj
+         W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekposENS_4fposI11__mbstate_tEEj
          W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setgEPcS4_S4_
          W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setpEPcS4_
          W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4swapERS3_
@@ -1529,7 +1549,7 @@
          W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsputnEPKci
          W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7pubsyncEv
          W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj
-         W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI10_mbstate_tEEj
+         W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj
          W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7sungetcEv
          W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8in_availEv
          W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8overflowEi
@@ -1548,7 +1568,7 @@
          W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED2Ev
          W _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEaSERKS3_
          W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekoffExNS_8ios_base7seekdirEj
-         W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekposENS_4fposI10_mbstate_tEEj
+         W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekposENS_4fposI11__mbstate_tEEj
          W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setgEPwS4_S4_
          W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setpEPwS4_
          W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4swapERS3_
@@ -1568,12 +1588,12 @@
          W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsputnEPKwi
          W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7pubsyncEv
          W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekoffExNS_8ios_base7seekdirEj
-         W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI10_mbstate_tEEj
+         W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI11__mbstate_tEEj
          W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7sungetcEv
          W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8in_availEv
-         W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8overflowEi
+         W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8overflowEj
          W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8pubimbueERKNS_6localeE
-         W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pbackfailEi
+         W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pbackfailEj
          W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pubsetbufEPwi
          W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9showmanycEv
          W _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9sputbackcEw
@@ -1956,26 +1976,26 @@
          C _ZNSt3__17__sort5IRNS_6__lessIwwEEPwEEjT0_S5_S5_S5_S5_T_
          C _ZNSt3__17__sort5IRNS_6__lessIxxEEPxEEjT0_S5_S5_S5_S5_T_
          C _ZNSt3__17__sort5IRNS_6__lessIyyEEPyEEjT0_S5_S5_S5_S5_T_
-         D _ZNSt3__17codecvtIDic10_mbstate_tE2idE
-         T _ZNSt3__17codecvtIDic10_mbstate_tED0Ev
-         T _ZNSt3__17codecvtIDic10_mbstate_tED1Ev
-         T _ZNSt3__17codecvtIDic10_mbstate_tED2Ev
-         D _ZNSt3__17codecvtIDsc10_mbstate_tE2idE
-         T _ZNSt3__17codecvtIDsc10_mbstate_tED0Ev
-         T _ZNSt3__17codecvtIDsc10_mbstate_tED1Ev
-         T _ZNSt3__17codecvtIDsc10_mbstate_tED2Ev
-         D _ZNSt3__17codecvtIcc10_mbstate_tE2idE
-         T _ZNSt3__17codecvtIcc10_mbstate_tED0Ev
-         T _ZNSt3__17codecvtIcc10_mbstate_tED1Ev
-         T _ZNSt3__17codecvtIcc10_mbstate_tED2Ev
-         D _ZNSt3__17codecvtIwc10_mbstate_tE2idE
-         T _ZNSt3__17codecvtIwc10_mbstate_tEC1EPKcj
-         T _ZNSt3__17codecvtIwc10_mbstate_tEC1Ej
-         T _ZNSt3__17codecvtIwc10_mbstate_tEC2EPKcj
-         T _ZNSt3__17codecvtIwc10_mbstate_tEC2Ej
-         T _ZNSt3__17codecvtIwc10_mbstate_tED0Ev
-         T _ZNSt3__17codecvtIwc10_mbstate_tED1Ev
-         T _ZNSt3__17codecvtIwc10_mbstate_tED2Ev
+         D _ZNSt3__17codecvtIDic11__mbstate_tE2idE
+         T _ZNSt3__17codecvtIDic11__mbstate_tED0Ev
+         T _ZNSt3__17codecvtIDic11__mbstate_tED1Ev
+         T _ZNSt3__17codecvtIDic11__mbstate_tED2Ev
+         D _ZNSt3__17codecvtIDsc11__mbstate_tE2idE
+         T _ZNSt3__17codecvtIDsc11__mbstate_tED0Ev
+         T _ZNSt3__17codecvtIDsc11__mbstate_tED1Ev
+         T _ZNSt3__17codecvtIDsc11__mbstate_tED2Ev
+         D _ZNSt3__17codecvtIcc11__mbstate_tE2idE
+         T _ZNSt3__17codecvtIcc11__mbstate_tED0Ev
+         T _ZNSt3__17codecvtIcc11__mbstate_tED1Ev
+         T _ZNSt3__17codecvtIcc11__mbstate_tED2Ev
+         D _ZNSt3__17codecvtIwc11__mbstate_tE2idE
+         T _ZNSt3__17codecvtIwc11__mbstate_tEC1EPKcj
+         T _ZNSt3__17codecvtIwc11__mbstate_tEC1Ej
+         T _ZNSt3__17codecvtIwc11__mbstate_tEC2EPKcj
+         T _ZNSt3__17codecvtIwc11__mbstate_tEC2Ej
+         T _ZNSt3__17codecvtIwc11__mbstate_tED0Ev
+         T _ZNSt3__17codecvtIwc11__mbstate_tED1Ev
+         T _ZNSt3__17codecvtIwc11__mbstate_tED2Ev
          W _ZNSt3__17collateIcE2idE
          W _ZNSt3__17collateIcEC1Ej
          W _ZNSt3__17collateIcEC2Ej
@@ -2241,7 +2261,6 @@
          T _ZNSt3__19to_stringEx
          T _ZNSt3__19to_stringEy
          W _ZNSt3__1plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EEPKS6_RKS9_
-         C _ZNSt3__1plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EERKS9_PKS6_
          T _ZSt10unexpectedv
          T _ZSt13get_terminatev
          T _ZSt13set_terminatePFvvE
@@ -2295,10 +2314,10 @@
          C _ZTINSt3__114__num_put_baseE
          D _ZTINSt3__114__shared_countE
          W _ZTINSt3__114basic_iostreamIcNS_11char_traitsIcEEEE
-         W _ZTINSt3__114codecvt_bynameIDic10_mbstate_tEE
-         W _ZTINSt3__114codecvt_bynameIDsc10_mbstate_tEE
-         W _ZTINSt3__114codecvt_bynameIcc10_mbstate_tEE
-         W _ZTINSt3__114codecvt_bynameIwc10_mbstate_tEE
+         W _ZTINSt3__114codecvt_bynameIDic11__mbstate_tEE
+         W _ZTINSt3__114codecvt_bynameIDsc11__mbstate_tEE
+         W _ZTINSt3__114codecvt_bynameIcc11__mbstate_tEE
+         W _ZTINSt3__114codecvt_bynameIwc11__mbstate_tEE
          D _ZTINSt3__114collate_bynameIcEE
          D _ZTINSt3__114collate_bynameIwEE
          D _ZTINSt3__114error_categoryE
@@ -2345,10 +2364,10 @@
          D _ZTINSt3__15ctypeIwEE
          D _ZTINSt3__16locale5__impE
          D _ZTINSt3__16locale5facetE
-         D _ZTINSt3__17codecvtIDic10_mbstate_tEE
-         D _ZTINSt3__17codecvtIDsc10_mbstate_tEE
-         D _ZTINSt3__17codecvtIcc10_mbstate_tEE
-         D _ZTINSt3__17codecvtIwc10_mbstate_tEE
+         D _ZTINSt3__17codecvtIDic11__mbstate_tEE
+         D _ZTINSt3__17codecvtIDsc11__mbstate_tEE
+         D _ZTINSt3__17codecvtIcc11__mbstate_tEE
+         D _ZTINSt3__17codecvtIwc11__mbstate_tEE
          W _ZTINSt3__17collateIcEE
          W _ZTINSt3__17collateIwEE
          W _ZTINSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE
@@ -2429,10 +2448,10 @@
          C _ZTSNSt3__114__num_put_baseE
          D _ZTSNSt3__114__shared_countE
          W _ZTSNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE
-         W _ZTSNSt3__114codecvt_bynameIDic10_mbstate_tEE
-         W _ZTSNSt3__114codecvt_bynameIDsc10_mbstate_tEE
-         W _ZTSNSt3__114codecvt_bynameIcc10_mbstate_tEE
-         W _ZTSNSt3__114codecvt_bynameIwc10_mbstate_tEE
+         W _ZTSNSt3__114codecvt_bynameIDic11__mbstate_tEE
+         W _ZTSNSt3__114codecvt_bynameIDsc11__mbstate_tEE
+         W _ZTSNSt3__114codecvt_bynameIcc11__mbstate_tEE
+         W _ZTSNSt3__114codecvt_bynameIwc11__mbstate_tEE
          D _ZTSNSt3__114collate_bynameIcEE
          D _ZTSNSt3__114collate_bynameIwEE
          D _ZTSNSt3__114error_categoryE
@@ -2479,10 +2498,10 @@
          D _ZTSNSt3__15ctypeIwEE
          D _ZTSNSt3__16locale5__impE
          D _ZTSNSt3__16locale5facetE
-         D _ZTSNSt3__17codecvtIDic10_mbstate_tEE
-         D _ZTSNSt3__17codecvtIDsc10_mbstate_tEE
-         D _ZTSNSt3__17codecvtIcc10_mbstate_tEE
-         D _ZTSNSt3__17codecvtIwc10_mbstate_tEE
+         D _ZTSNSt3__17codecvtIDic11__mbstate_tEE
+         D _ZTSNSt3__17codecvtIDsc11__mbstate_tEE
+         D _ZTSNSt3__17codecvtIcc11__mbstate_tEE
+         D _ZTSNSt3__17codecvtIwc11__mbstate_tEE
          W _ZTSNSt3__17collateIcEE
          W _ZTSNSt3__17collateIwEE
          W _ZTSNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE
@@ -2559,10 +2578,10 @@
          D _ZTVNSt3__114__codecvt_utf8IwEE
          D _ZTVNSt3__114__shared_countE
          W _ZTVNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE
-         W _ZTVNSt3__114codecvt_bynameIDic10_mbstate_tEE
-         W _ZTVNSt3__114codecvt_bynameIDsc10_mbstate_tEE
-         W _ZTVNSt3__114codecvt_bynameIcc10_mbstate_tEE
-         W _ZTVNSt3__114codecvt_bynameIwc10_mbstate_tEE
+         W _ZTVNSt3__114codecvt_bynameIDic11__mbstate_tEE
+         W _ZTVNSt3__114codecvt_bynameIDsc11__mbstate_tEE
+         W _ZTVNSt3__114codecvt_bynameIcc11__mbstate_tEE
+         W _ZTVNSt3__114codecvt_bynameIwc11__mbstate_tEE
          D _ZTVNSt3__114collate_bynameIcEE
          D _ZTVNSt3__114collate_bynameIwEE
          D _ZTVNSt3__114error_categoryE
@@ -2605,10 +2624,10 @@
          D _ZTVNSt3__15ctypeIwEE
          D _ZTVNSt3__16locale5__impE
          D _ZTVNSt3__16locale5facetE
-         D _ZTVNSt3__17codecvtIDic10_mbstate_tEE
-         D _ZTVNSt3__17codecvtIDsc10_mbstate_tEE
-         D _ZTVNSt3__17codecvtIcc10_mbstate_tEE
-         D _ZTVNSt3__17codecvtIwc10_mbstate_tEE
+         D _ZTVNSt3__17codecvtIDic11__mbstate_tEE
+         D _ZTVNSt3__17codecvtIDsc11__mbstate_tEE
+         D _ZTVNSt3__17codecvtIcc11__mbstate_tEE
+         D _ZTVNSt3__17codecvtIwc11__mbstate_tEE
          W _ZTVNSt3__17collateIcEE
          W _ZTVNSt3__17collateIwEE
          W _ZTVNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE
diff --git a/tools/shared.py b/tools/shared.py
index f6c0cc95b8637..d38aef4cf1ae8 100644
--- a/tools/shared.py
+++ b/tools/shared.py
@@ -314,7 +314,7 @@ def find_temp_directory():
 # we re-check sanity when the settings are changed)
 # We also re-check sanity and clear the cache when the version changes
 
-EMSCRIPTEN_VERSION = '1.7.1'
+EMSCRIPTEN_VERSION = '1.7.2'
 
 def generate_sanity():
   return EMSCRIPTEN_VERSION + '|' + get_llvm_target() + '|' + LLVM_ROOT

From 4259c8b65351ae91c5d8265fdb51b2b59073691b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Thu, 7 Nov 2013 14:29:18 +0200
Subject: [PATCH 89/93] Add more names for functions that show up in Firefox
 profiler as anonymous.

---
 src/library_browser.js | 2 +-
 src/library_gl.js      | 6 +++---
 src/library_openal.js  | 8 ++++----
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/library_browser.js b/src/library_browser.js
index b70dbc8441f4b..39a1c55d8da64 100644
--- a/src/library_browser.js
+++ b/src/library_browser.js
@@ -359,7 +359,7 @@ mergeInto(LibraryManager.library, {
       canvas.requestFullScreen();
     },
 
-    requestAnimationFrame: function(func) {
+    requestAnimationFrame: function requestAnimationFrame(func) {
       if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
         setTimeout(func, 1000/60);
       } else {
diff --git a/src/library_gl.js b/src/library_gl.js
index 7074f844f9976..14e708685a86d 100644
--- a/src/library_gl.js
+++ b/src/library_gl.js
@@ -277,7 +277,7 @@ var LibraryGL = {
     },
 
 #if FULL_ES2
-    calcBufLength: function(size, type, stride, count) {
+    calcBufLength: function calcBufLength(size, type, stride, count) {
       if (stride > 0) {
         return count * stride;  // XXXvlad this is not exactly correct I don't think
       }
@@ -287,7 +287,7 @@ var LibraryGL = {
 
     usedTempBuffers: [],
 
-    preDrawHandleClientVertexAttribBindings: function(count) {
+    preDrawHandleClientVertexAttribBindings: function preDrawHandleClientVertexAttribBindings(count) {
       GL.resetBufferBinding = false;
 
       var used = GL.usedTempBuffers;
@@ -321,7 +321,7 @@ var LibraryGL = {
       }
     },
 
-    postDrawHandleClientVertexAttribBindings: function() {
+    postDrawHandleClientVertexAttribBindings: function postDrawHandleClientVertexAttribBindings() {
       if (GL.resetBufferBinding) {
         Module.ctx.bindBuffer(Module.ctx.ARRAY_BUFFER, GL.buffers[GL.currArrayBuffer]);
       }
diff --git a/src/library_openal.js b/src/library_openal.js
index e8a2e22321b11..eb152f629ddaa 100644
--- a/src/library_openal.js
+++ b/src/library_openal.js
@@ -8,13 +8,13 @@ var LibraryOpenAL = {
     QUEUE_INTERVAL: 25,
     QUEUE_LOOKAHEAD: 100,
 
-    updateSources: function(context) {
+    updateSources: function updateSources(context) {
       for (var i = 0; i < context.src.length; i++) {
         AL.updateSource(context.src[i]);
       }
     },
 
-    updateSource: function(src) {
+    updateSource: function updateSource(src) {
 #if OPENAL_DEBUG
       var idx = AL.currentContext.src.indexOf(src);
 #endif
@@ -65,7 +65,7 @@ var LibraryOpenAL = {
       }
     },
 
-    setSourceState: function(src, state) {
+    setSourceState: function setSourceState(src, state) {
 #if OPENAL_DEBUG
       var idx = AL.currentContext.src.indexOf(src);
 #endif
@@ -119,7 +119,7 @@ var LibraryOpenAL = {
       }
     },
 
-    stopSourceQueue: function(src) {
+    stopSourceQueue: function stopSourceQueue(src) {
       for (var i = 0; i < src.queue.length; i++) {
         var entry = src.queue[i];
         if (entry.src) {

From df185bf8d4b44903ec454158c07ad7ca3231cf26 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Thu, 7 Nov 2013 17:23:25 +0200
Subject: [PATCH 90/93] Implement GLES2 glShaderBinary and
 glReleaseShaderCompiler functions as no-op stubs. Add a machinery for
 glGetError() to report errors generated by the library_gl.js interop layer.

---
 src/library_gl.js | 43 +++++++++++++++++++++++++++++++++----------
 1 file changed, 33 insertions(+), 10 deletions(-)

diff --git a/src/library_gl.js b/src/library_gl.js
index 7074f844f9976..15eb0d5231234 100644
--- a/src/library_gl.js
+++ b/src/library_gl.js
@@ -11,6 +11,7 @@ var LibraryGL = {
 #endif
 
     counter: 1, // 0 is reserved as 'null' in gl
+    lastError: 0,
     buffers: [],
     programs: [],
     framebuffers: [],
@@ -51,6 +52,13 @@ var LibraryGL = {
       Browser.moduleContextCreatedCallbacks.push(GL.initExtensions);
     },
 
+    // Records a GL error condition that occurred, stored until user calls glGetError() to fetch it. As per GLES2 spec, only the first error 
+    // is remembered, and subsequent errors are discarded until the user has cleared the stored error by a call to glGetError().
+    recordError: function recordError(errorCode) {
+      if (!GL.lastError) {
+        GL.lastError = errorCode;
+      }
+    },
     // Get a new ID for a texture/buffer/etc., while keeping the table dense and fast. Creation is farely rare so it is worth optimizing lookups later.
     getNewId: function(table) {
       var ret = GL.counter++;
@@ -2123,9 +2131,6 @@ var LibraryGL = {
   glGetShaderPrecisionFormat__sig: 'v',
   glGetShaderPrecisionFormat: function() { throw 'glGetShaderPrecisionFormat: TODO' },
 
-  glShaderBinary__sig: 'v',
-  glShaderBinary: function() { throw 'glShaderBinary: TODO' },
-
   glDeleteObject__sig: 'vi',
   glDeleteObject: function(id) {
     if (GL.programs[id]) {
@@ -2137,11 +2142,6 @@ var LibraryGL = {
     }
   },
 
-  glReleaseShaderCompiler__sig: 'v',
-  glReleaseShaderCompiler: function() {
-    // NOP (as allowed by GLES 2.0 spec)
-  },
-
   glGetObjectParameteriv__sig: 'viii',
   glGetObjectParameteriv: function(id, type, result) {
     if (GL.programs[id]) {
@@ -4618,6 +4618,30 @@ var LibraryGL = {
 #endif
   },
 
+  glShaderBinary__sig: 'v',
+  glShaderBinary: function() {
+    GL.recordError(0x0500/*GL_INVALID_ENUM*/);
+#if GL_ASSERTIONS
+    Module.printErr("GL_INVALID_ENUM in glShaderBinary: WebGL does not support binary shader formats! Calls to glShaderBinary always fail.");
+#endif    
+  },
+
+  glReleaseShaderCompiler__sig: 'v',
+  glReleaseShaderCompiler: function() {
+    // NOP (as allowed by GLES 2.0 spec)
+  },
+
+  glGetError__sig: 'i',
+  glGetError: function() {
+    // First return any GL error generated by the emscripten library_gl.js interop layer.
+    if (GL.lastError) {
+      var error = GL.lastError;
+      GL.lastError = 0/*GL_NO_ERROR*/;
+      return error;
+    } else { // If there were none, return the GL error from the browser GL context.
+      return Module.ctx.getError();
+    }
+  },
   // signatures of simple pass-through functions, see later
 
   glActiveTexture__sig: 'vi',
@@ -4651,14 +4675,13 @@ var LibraryGL = {
   glFlush__sig: 'v',
   glClearColor__sig: 'viiii',
   glIsEnabled__sig: 'ii',
-  glGetError__sig: 'i',
   glFrontFace__sig: 'vi',
   glSampleCoverage__sig: 'vi',
 };
 
 
 // Simple pass-through functions. Starred ones have return values. [X] ones have X in the C name but not in the JS name
-[[0, 'getError* finish flush'],
+[[0, 'finish flush'],
  [1, 'clearDepth clearDepth[f] depthFunc enable disable frontFace cullFace clear lineWidth clearStencil depthMask stencilMask checkFramebufferStatus* generateMipmap activeTexture blendEquation sampleCoverage isEnabled*'],
  [2, 'blendFunc blendEquationSeparate depthRange depthRange[f] stencilMaskSeparate hint polygonOffset vertexAttrib1f'],
  [3, 'texParameteri texParameterf vertexAttrib2f stencilFunc stencilOp'],

From 18036a4d2f9e41220444f45295097733b0c1863a Mon Sep 17 00:00:00 2001
From: bobroberts177 <bobroberts177@gmail.com>
Date: Thu, 7 Nov 2013 09:19:03 -0800
Subject: [PATCH 91/93] Add self to AUTHORS

---
 AUTHORS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/AUTHORS b/AUTHORS
index 5c49e65ee70ed..0b8fdf3370558 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -106,4 +106,4 @@ a license to everyone to use it as detailed in LICENSE.)
 * Fraser Adams <fraser.adams@blueyonder.co.uk>
 * Michael Tirado <icetooth333@gmail.com>
 * Ben Noordhuis <info@bnoordhuis.nl>
-
+* Bob Roberts <bobroberts177@gmail.com>

From c715cec68f4c965ca443669fcf48eecfa70b52d8 Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Fri, 8 Nov 2013 14:54:18 -0800
Subject: [PATCH 92/93] invalidate calls on conditionals in js optimizer, to
 avoid eliminating into a non-executing code path

---
 tools/eliminator/asm-eliminator-test-output.js |  7 +++++++
 tools/eliminator/asm-eliminator-test.js        | 10 +++++++++-
 tools/js-optimizer.js                          |  4 ++++
 3 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/tools/eliminator/asm-eliminator-test-output.js b/tools/eliminator/asm-eliminator-test-output.js
index dda82047ca757..434fbaf9c0f52 100644
--- a/tools/eliminator/asm-eliminator-test-output.js
+++ b/tools/eliminator/asm-eliminator-test-output.js
@@ -291,4 +291,11 @@ function watIf() {
   if ($cmp38) {} else {}
  }
 }
+function select2($foundBase_0_off0) {
+ $foundBase_0_off0 = $foundBase_0_off0 | 0;
+ var $call24 = 0;
+ $call24 = MUST_RUN() | 0;
+ STACKTOP = sp;
+ return ($foundBase_0_off0 ? 0 : $call24) | 0;
+}
 
diff --git a/tools/eliminator/asm-eliminator-test.js b/tools/eliminator/asm-eliminator-test.js
index 6f426150428ff..7ec277d586968 100644
--- a/tools/eliminator/asm-eliminator-test.js
+++ b/tools/eliminator/asm-eliminator-test.js
@@ -362,5 +362,13 @@ function watIf() {
   }
  }
 }
-// EMSCRIPTEN_GENERATED_FUNCTIONS: ["asm", "__Z11printResultPiS_j", "_segment_holding", "__ZN5identC2EiPKcPci", "_vec2Length", "exc", "label", "confuusion", "tempDouble", "_org_apache_harmony_luni_util_NumberConverter_freeFormat__", "__ZN23b2EdgeAndPolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_", "_java_nio_charset_Charset_forNameInternal___java_lang_String", "looop2", "looop3", "looop4", "looop5", "looop6", "looop7", "looop8", "multiloop", "multiloop2", "tempDouble2", "watIf"]
+function select2($foundBase_0_off0) {
+ $foundBase_0_off0 = $foundBase_0_off0 | 0;
+ var $call24 = 0, $retval_0 = 0;
+ $call24 = MUST_RUN() | 0;
+ $retval_0 = $foundBase_0_off0 ? 0 : $call24;
+ STACKTOP = sp;
+ return $retval_0 | 0;
+}
+// EMSCRIPTEN_GENERATED_FUNCTIONS: ["asm", "__Z11printResultPiS_j", "_segment_holding", "__ZN5identC2EiPKcPci", "_vec2Length", "exc", "label", "confuusion", "tempDouble", "_org_apache_harmony_luni_util_NumberConverter_freeFormat__", "__ZN23b2EdgeAndPolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_", "_java_nio_charset_Charset_forNameInternal___java_lang_String", "looop2", "looop3", "looop4", "looop5", "looop6", "looop7", "looop8", "multiloop", "multiloop2", "tempDouble2", "watIf", "select2"]
 
diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js
index 022bdf477d47e..36244298431f9 100644
--- a/tools/js-optimizer.js
+++ b/tools/js-optimizer.js
@@ -2485,6 +2485,10 @@ function eliminate(ast, memSafe) {
         } else if (type === 'return') {
           if (node[1]) traverseInOrder(node[1]);
         } else if (type === 'conditional') {
+          if (!callsInvalidated) { // invalidate calls, since we cannot eliminate them into a branch of an LLVM select/JS conditional that does not execute
+            invalidateCalls();
+            callsInvalidated = true;
+          }
           traverseInOrder(node[1]);
           traverseInOrder(node[2]);
           traverseInOrder(node[3]);

From cca74d2500b1e05b2927b68a50345875bbe91eff Mon Sep 17 00:00:00 2001
From: Alon Zakai <alonzakai@gmail.com>
Date: Fri, 8 Nov 2013 15:36:29 -0800
Subject: [PATCH 93/93] no-op for __builtin_prefetch; fixes #1765

---
 src/library.js | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/library.js b/src/library.js
index 501f766cf4f1f..e244491b03327 100644
--- a/src/library.js
+++ b/src/library.js
@@ -4163,6 +4163,11 @@ LibraryManager.library = {
     return me.ret;
   },
 
+  // ==========================================================================
+  // GCC/LLVM specifics
+  // ==========================================================================
+  __builtin_prefetch: function(){},
+
   // ==========================================================================
   // LLVM specifics
   // ==========================================================================