Index: lib/CodeGen/CGCXXABI.h
===================================================================
--- lib/CodeGen/CGCXXABI.h	(revision 216541)
+++ lib/CodeGen/CGCXXABI.h	(working copy)
@@ -236,6 +236,10 @@
 
   virtual bool EmitBadCastCall(CodeGenFunction &CGF) = 0;
 
+  /// Emit the code required to throw a std::bad_array_new_length exception by
+  /// the ABI.
+  virtual void EmitBadArrayNewLengthCall(CodeGenFunction &CGF) = 0;
+
   virtual llvm::Value *GetVirtualBaseClassOffset(CodeGenFunction &CGF,
                                                  llvm::Value *This,
                                                  const CXXRecordDecl *ClassDecl,
Index: lib/CodeGen/CGExprCXX.cpp
===================================================================
--- lib/CodeGen/CGExprCXX.cpp	(revision 216541)
+++ lib/CodeGen/CGExprCXX.cpp	(working copy)
@@ -574,9 +574,19 @@
     // On overflow, produce a -1 so operator new will fail.
     if (hasAnyOverflow) {
       size = llvm::Constant::getAllOnesValue(CGF.SizeTy);
-    } else {
+
+      // In C++11 and later, overflow for a call to operator new[] should throw
+      // a std::bad_array_new_length exception.
+      if (CGF.getLangOpts().CPlusPlus11) {
+        llvm::BasicBlock *BadArrayNewLengthBlock =
+          CGF.createBasicBlock("new.bad_array_new_length");
+        llvm::BasicBlock *EndBlock = CGF.createBasicBlock("new.end");
+        CGF.EmitBlock(BadArrayNewLengthBlock);
+        CGF.CGM.getCXXABI().EmitBadArrayNewLengthCall(CGF);
+        CGF.EmitBlock(EndBlock);
+      }
+    } else
       size = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
-    }
 
   // Otherwise, we might need to use the overflow intrinsics.
   } else {
@@ -713,10 +723,22 @@
     // If we had any possibility of dynamic overflow, make a select to
     // overwrite 'size' with an all-ones value, which should cause
     // operator new to throw.
-    if (hasOverflow)
-      size = CGF.Builder.CreateSelect(hasOverflow,
-                                 llvm::Constant::getAllOnesValue(CGF.SizeTy),
-                                      size);
+    if (hasOverflow) {
+      // In C++11 and later, overflow for a call to operator new[] should throw
+      // a std::bad_array_new_length exception.
+      if (CGF.getLangOpts().CPlusPlus11) {
+        llvm::BasicBlock *BadArrayNewLengthBlock =
+          CGF.createBasicBlock("new.bad_array_new_length");
+        llvm::BasicBlock *EndBlock = CGF.createBasicBlock("new.end");
+
+        CGF.Builder.CreateCondBr(hasOverflow, BadArrayNewLengthBlock, EndBlock);
+        CGF.EmitBlock(BadArrayNewLengthBlock);
+        CGF.CGM.getCXXABI().EmitBadArrayNewLengthCall(CGF);
+        CGF.EmitBlock(EndBlock);
+      } else
+        size = CGF.Builder.CreateSelect(
+            hasOverflow, llvm::Constant::getAllOnesValue(CGF.SizeTy), size);
+    }
   }
 
   if (cookieSize == 0)
Index: lib/CodeGen/ItaniumCXXABI.cpp
===================================================================
--- lib/CodeGen/ItaniumCXXABI.cpp	(revision 216541)
+++ lib/CodeGen/ItaniumCXXABI.cpp	(working copy)
@@ -132,6 +132,7 @@
                                      QualType DestTy) override;
 
   bool EmitBadCastCall(CodeGenFunction &CGF) override;
+  void EmitBadArrayNewLengthCall(CodeGenFunction &CGF) override;
 
   llvm::Value *
     GetVirtualBaseClassOffset(CodeGenFunction &CGF, llvm::Value *This,
@@ -1044,6 +1045,15 @@
   return true;
 }
 
+void ItaniumCXXABI::EmitBadArrayNewLengthCall(CodeGenFunction &CGF) {
+  // void __cxa_bad_array_new_length();
+  llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
+  llvm::Value *Fn =
+      CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_array_new_length");
+  CGF.EmitRuntimeCallOrInvoke(Fn).setDoesNotReturn();
+  CGF.Builder.CreateUnreachable();
+}
+
 llvm::Value *
 ItaniumCXXABI::GetVirtualBaseClassOffset(CodeGenFunction &CGF,
                                          llvm::Value *This,
Index: lib/CodeGen/MicrosoftCXXABI.cpp
===================================================================
--- lib/CodeGen/MicrosoftCXXABI.cpp	(revision 216541)
+++ lib/CodeGen/MicrosoftCXXABI.cpp	(working copy)
@@ -83,6 +83,7 @@
                                      QualType DestTy) override;
 
   bool EmitBadCastCall(CodeGenFunction &CGF) override;
+  void EmitBadArrayNewLengthCall(CodeGenFunction &CGF) override;
 
   llvm::Value *
   GetVirtualBaseClassOffset(CodeGenFunction &CGF, llvm::Value *This,
@@ -740,6 +741,10 @@
   return false;
 }
 
+void MicrosoftCXXABI::EmitBadArrayNewLengthCall(CodeGenFunction &CGF) {
+  // Not currently implemented.
+}
+
 llvm::Value *
 MicrosoftCXXABI::GetVirtualBaseClassOffset(CodeGenFunction &CGF,
                                            llvm::Value *This,
Index: test/CodeGenCXX/operator-new.cpp
===================================================================
--- test/CodeGenCXX/operator-new.cpp	(revision 216541)
+++ test/CodeGenCXX/operator-new.cpp	(working copy)
@@ -1,7 +1,11 @@
-// RUN: %clang_cc1 -triple i686-pc-linux-gnu -emit-llvm -o %t-1.ll %s
-// RUN: FileCheck -check-prefix SANE --input-file=%t-1.ll %s
-// RUN: %clang_cc1 -triple i686-pc-linux-gnu -emit-llvm -fno-assume-sane-operator-new -o %t-2.ll %s
-// RUN: FileCheck -check-prefix SANENOT --input-file=%t-2.ll %s
+// RUN: %clang_cc1 -triple i686-pc-linux-gnu -std=c++98 -emit-llvm -o %t-1.ll %s
+// RUN: FileCheck -check-prefix SANE98 --input-file=%t-1.ll %s
+// RUN: %clang_cc1 -triple i686-pc-linux-gnu -std=c++11 -emit-llvm -o %t-2.ll %s
+// RUN: FileCheck -check-prefix SANE11 --input-file=%t-2.ll %s
+// RUN: %clang_cc1 -triple i686-pc-win32-msvc -std=c++11 -emit-llvm -o %t-3.ll %s
+// RUN: FileCheck -check-prefix SANE11MS --input-file=%t-3.ll %s
+// RUN: %clang_cc1 -triple i686-pc-linux-gnu -emit-llvm -fno-assume-sane-operator-new -o %t-4.ll %s
+// RUN: FileCheck -check-prefix SANENOT --input-file=%t-4.ll %s
 
 
 class teste {
@@ -20,10 +24,31 @@
 // rdar://5739832 - operator new should check for overflow in multiply.
 void *f2(long N) {
   return new int[N];
-  
-// SANE:      [[UWO:%.*]] = call {{.*}} @llvm.umul.with.overflow
-// SANE-NEXT: [[OVER:%.*]] = extractvalue {{.*}} [[UWO]], 1
-// SANE-NEXT: [[SUM:%.*]] = extractvalue {{.*}} [[UWO]], 0
-// SANE-NEXT: [[RESULT:%.*]] = select i1 [[OVER]], i32 -1, i32 [[SUM]]
-// SANE-NEXT: call noalias i8* @_Znaj(i32 [[RESULT]])
+
+// SANE98:      [[UWO:%.*]] = call {{.*}} @llvm.umul.with.overflow
+// SANE98-NEXT: [[OVER:%.*]] = extractvalue {{.*}} [[UWO]], 1
+// SANE98-NEXT: [[SUM:%.*]] = extractvalue {{.*}} [[UWO]], 0
+// SANE98-NEXT: [[RESULT:%.*]] = select i1 [[OVER]], i32 -1, i32 [[SUM]]
+// SANE98-NEXT: call noalias i8* @_Znaj(i32 [[RESULT]])
+
+// SANE11:      [[UWO:%.*]] = call {{.*}} @llvm.umul.with.overflow
+// SANE11-NEXT: [[OVER:%.*]] = extractvalue {{.*}} [[UWO]], 1
+// SANE11-NEXT: [[SUM:%.*]] = extractvalue {{.*}} [[UWO]], 0
+// SANE11-NEXT: br i1 [[OVER]], label %[[BAD:.*]], label %[[GOOD:.*]]
+// SANE11: [[BAD]]:
+// SANE11-NEXT: call void @__cxa_bad_array_new_length()
+// SANE11-NEXT: unreachable
+// SANE11: [[GOOD]]:
+// SANE11-NEXT: call noalias i8* @_Znaj(i32 [[SUM]])
+
+// FIXME: There should be a call to generate the std::bad_array_new_length
+// exception in the Microsoft ABI, however, this is not implemented currently.
+// SANE11MS:      [[UWO:%.*]] = call {{.*}} @llvm.umul.with.overflow
+// SANE11MS-NEXT: [[OVER:%.*]] = extractvalue {{.*}} [[UWO]], 1
+// SANE11MS-NEXT: [[SUM:%.*]] = extractvalue {{.*}} [[UWO]], 0
+// SANE11MS-NEXT: br i1 [[OVER]], label %[[BAD:.*]], label %[[GOOD:.*]]
+// SANE11MS: [[BAD]]:
+// SANE11MS-NEXT: br label %[[GOOD]]
+// SANE11MS: [[GOOD]]:
+// SANE11MS-NEXT: call noalias i8* @"\01??_U@YAPAXI@Z"(i32 [[SUM]])
 }