diff --git a/src/base/basictypes.h b/src/base/basictypes.h
index a22bd9a..42dbe5c 100644
--- a/src/base/basictypes.h
+++ b/src/base/basictypes.h
@@ -433,11 +433,4 @@ namespace base {
 enum LinkerInitialized { LINKER_INITIALIZED };
 }
 
-#if __cpp_noexcept_function_type >= 201510
-// Deprecated in C++17
-# define PERFTOOLS_THROW(...)
-#else
-# define PERFTOOLS_THROW(...) throw(__VA_ARGS__)
-#endif
-
 #endif  // _BASICTYPES_H_
diff --git a/src/libc_override.h b/src/libc_override.h
index c01a97c..7f9cd91 100644
--- a/src/libc_override.h
+++ b/src/libc_override.h
@@ -58,6 +58,14 @@
 #endif
 #include <gperftools/tcmalloc.h>
 
+#if __cplusplus >= 201103L
+#define CPP_NOTHROW noexcept
+#define CPP_BADALLOC
+#else
+#define CPP_NOTHROW throw()
+#define CPP_BADALLOC throw(std::bad_alloc)
+#endif
+
 static void ReplaceSystemAlloc();  // defined in the .h files below
 
 // For windows, there are two ways to get tcmalloc.  If we're
diff --git a/src/libc_override_gcc_and_weak.h b/src/libc_override_gcc_and_weak.h
index c7091d3..6875164 100644
--- a/src/libc_override_gcc_and_weak.h
+++ b/src/libc_override_gcc_and_weak.h
@@ -57,38 +57,34 @@
 
 #define ALIAS(tc_fn)   __attribute__ ((alias (#tc_fn), used))
 
-void* operator new(size_t size) PERFTOOLS_THROW(std::bad_alloc)
-    ALIAS(tc_new);
-void operator delete(void* p) PERFTOOLS_NOTHROW
-    ALIAS(tc_delete);
-void* operator new[](size_t size) PERFTOOLS_THROW(std::bad_alloc)
-    ALIAS(tc_newarray);
-void operator delete[](void* p) PERFTOOLS_NOTHROW
-    ALIAS(tc_deletearray);
-void* operator new(size_t size, const std::nothrow_t& nt) PERFTOOLS_NOTHROW
-    ALIAS(tc_new_nothrow);
-void* operator new[](size_t size, const std::nothrow_t& nt) PERFTOOLS_NOTHROW
-    ALIAS(tc_newarray_nothrow);
-void operator delete(void* p, const std::nothrow_t& nt) PERFTOOLS_NOTHROW
-    ALIAS(tc_delete_nothrow);
-void operator delete[](void* p, const std::nothrow_t& nt) PERFTOOLS_NOTHROW
-    ALIAS(tc_deletearray_nothrow);
+void* operator new(size_t size) CPP_BADALLOC  ALIAS(tc_new);
+void operator delete(void* p) CPP_NOTHROW     ALIAS(tc_delete);
+void* operator new[](size_t size) CPP_BADALLOC ALIAS(tc_newarray);
+void operator delete[](void* p) CPP_NOTHROW   ALIAS(tc_deletearray);
+void* operator new(size_t size, const std::nothrow_t& nt) CPP_NOTHROW
+                                              ALIAS(tc_new_nothrow);
+void* operator new[](size_t size, const std::nothrow_t& nt) CPP_NOTHROW
+                                              ALIAS(tc_newarray_nothrow);
+void operator delete(void* p, const std::nothrow_t& nt) CPP_NOTHROW
+                                              ALIAS(tc_delete_nothrow);
+void operator delete[](void* p, const std::nothrow_t& nt) CPP_NOTHROW
+                                              ALIAS(tc_deletearray_nothrow);
 
 #if defined(ENABLE_SIZED_DELETE)
 
-void operator delete(void *p, size_t size) PERFTOOLS_NOTHROW
+void operator delete(void *p, size_t size) CPP_NOTHROW
     ALIAS(tc_delete_sized);
-void operator delete[](void *p, size_t size) PERFTOOLS_NOTHROW
+void operator delete[](void *p, size_t size) CPP_NOTHROW
     ALIAS(tc_deletearray_sized);
 
 #elif defined(ENABLE_DYNAMIC_SIZED_DELETE) && \
   (__GNUC__ * 100 + __GNUC_MINOR__) >= 405
 
-static void delegate_sized_delete(void *p, size_t s) PERFTOOLS_NOTHROW {
+static void delegate_sized_delete(void *p, size_t s) {
   (operator delete)(p);
 }
 
-static void delegate_sized_deletearray(void *p, size_t s) PERFTOOLS_NOTHROW {
+static void delegate_sized_deletearray(void *p, size_t s) {
   (operator delete[])(p);
 }
 
@@ -122,44 +118,44 @@ static void *resolve_deletearray_sized(void) {
 
 }
 
-void operator delete(void *p, size_t size) PERFTOOLS_NOTHROW
+void operator delete(void *p, size_t size) CPP_NOTHROW
   __attribute__((ifunc("resolve_delete_sized")));
-void operator delete[](void *p, size_t size) PERFTOOLS_NOTHROW
+void operator delete[](void *p, size_t size) CPP_NOTHROW
   __attribute__((ifunc("resolve_deletearray_sized")));
 
 #else /* !ENABLE_SIZED_DELETE && !ENABLE_DYN_SIZED_DELETE */
 
-void operator delete(void *p, size_t size) PERFTOOLS_NOTHROW
+void operator delete(void *p, size_t size) CPP_NOTHROW
   ALIAS(tc_delete);
-void operator delete[](void *p, size_t size) PERFTOOLS_NOTHROW
+void operator delete[](void *p, size_t size) CPP_NOTHROW
   ALIAS(tc_deletearray);
 
 #endif /* !ENABLE_SIZED_DELETE && !ENABLE_DYN_SIZED_DELETE */
 
 #if defined(ENABLE_ALIGNED_NEW_DELETE)
 
-void* operator new(size_t size, std::align_val_t al) PERFTOOLS_THROW(std::bad_alloc)
+void* operator new(size_t size, std::align_val_t al)
     ALIAS(tc_new_aligned);
-void operator delete(void* p, std::align_val_t al) PERFTOOLS_NOTHROW
+void operator delete(void* p, std::align_val_t al) CPP_NOTHROW
     ALIAS(tc_delete_aligned);
-void* operator new[](size_t size, std::align_val_t al) PERFTOOLS_THROW(std::bad_alloc)
+void* operator new[](size_t size, std::align_val_t al)
     ALIAS(tc_newarray_aligned);
-void operator delete[](void* p, std::align_val_t al) PERFTOOLS_NOTHROW
+void operator delete[](void* p, std::align_val_t al) CPP_NOTHROW
     ALIAS(tc_deletearray_aligned);
-void* operator new(size_t size, std::align_val_t al, const std::nothrow_t& nt) PERFTOOLS_NOTHROW
+void* operator new(size_t size, std::align_val_t al, const std::nothrow_t& nt) CPP_NOTHROW
     ALIAS(tc_new_aligned_nothrow);
-void* operator new[](size_t size, std::align_val_t al, const std::nothrow_t& nt) PERFTOOLS_NOTHROW
+void* operator new[](size_t size, std::align_val_t al, const std::nothrow_t& nt) CPP_NOTHROW
     ALIAS(tc_newarray_aligned_nothrow);
-void operator delete(void* p, std::align_val_t al, const std::nothrow_t& nt) PERFTOOLS_NOTHROW
+void operator delete(void* p, std::align_val_t al, const std::nothrow_t& nt) CPP_NOTHROW
     ALIAS(tc_delete_aligned_nothrow);
-void operator delete[](void* p, std::align_val_t al, const std::nothrow_t& nt) PERFTOOLS_NOTHROW
+void operator delete[](void* p, std::align_val_t al, const std::nothrow_t& nt) CPP_NOTHROW
     ALIAS(tc_deletearray_aligned_nothrow);
 
 #if defined(ENABLE_SIZED_DELETE)
 
-void operator delete(void *p, size_t size, std::align_val_t al) PERFTOOLS_NOTHROW
+void operator delete(void *p, size_t size, std::align_val_t al) CPP_NOTHROW
     ALIAS(tc_delete_sized_aligned);
-void operator delete[](void *p, size_t size, std::align_val_t al) PERFTOOLS_NOTHROW
+void operator delete[](void *p, size_t size, std::align_val_t al) CPP_NOTHROW
     ALIAS(tc_deletearray_sized_aligned);
 
 #else /* defined(ENABLE_SIZED_DELETE) */
@@ -167,11 +163,11 @@ void operator delete[](void *p, size_t size, std::align_val_t al) PERFTOOLS_NOTH
 #if defined(ENABLE_DYNAMIC_SIZED_DELETE) && \
   (__GNUC__ * 100 + __GNUC_MINOR__) >= 405
 
-static void delegate_sized_aligned_delete(void *p, size_t s, std::align_val_t al) PERFTOOLS_NOTHROW {
+static void delegate_sized_aligned_delete(void *p, size_t s, std::align_val_t al) {
   (operator delete)(p, al);
 }
 
-static void delegate_sized_aligned_deletearray(void *p, size_t s, std::align_val_t al) PERFTOOLS_NOTHROW {
+static void delegate_sized_aligned_deletearray(void *p, size_t s, std::align_val_t al) {
   (operator delete[])(p, al);
 }
 
@@ -193,16 +189,16 @@ static void *resolve_deletearray_sized_aligned(void) {
 
 }
 
-void operator delete(void *p, size_t size, std::align_val_t al) PERFTOOLS_NOTHROW
+void operator delete(void *p, size_t size, std::align_val_t al) CPP_NOTHROW
   __attribute__((ifunc("resolve_delete_sized_aligned")));
-void operator delete[](void *p, size_t size, std::align_val_t al) PERFTOOLS_NOTHROW
+void operator delete[](void *p, size_t size, std::align_val_t al) CPP_NOTHROW
   __attribute__((ifunc("resolve_deletearray_sized_aligned")));
 
 #else /* defined(ENABLE_DYN_SIZED_DELETE) */
 
-void operator delete(void *p, size_t size, std::align_val_t al) PERFTOOLS_NOTHROW
+void operator delete(void *p, size_t size, std::align_val_t al) CPP_NOTHROW
   ALIAS(tc_delete);
-void operator delete[](void *p, size_t size, std::align_val_t al) PERFTOOLS_NOTHROW
+void operator delete[](void *p, size_t size, std::align_val_t al) CPP_NOTHROW
   ALIAS(tc_deletearray);
 
 #endif /* defined(ENABLE_DYN_SIZED_DELETE) */
diff --git a/src/libc_override_redefine.h b/src/libc_override_redefine.h
index c7ae885..4d61b25 100644
--- a/src/libc_override_redefine.h
+++ b/src/libc_override_redefine.h
@@ -43,25 +43,25 @@
 #define TCMALLOC_LIBC_OVERRIDE_REDEFINE_H_
 
 void* operator new(size_t size)                  { return tc_new(size);       }
-void operator delete(void* p) PERFTOOLS_NOTHROW            { tc_delete(p);              }
+void operator delete(void* p) CPP_NOTHROW        { tc_delete(p);              }
 void* operator new[](size_t size)                { return tc_newarray(size);  }
-void operator delete[](void* p) PERFTOOLS_NOTHROW          { tc_deletearray(p);         }
-void* operator new(size_t size, const std::nothrow_t& nt) PERFTOOLS_NOTHROW {
+void operator delete[](void* p) CPP_NOTHROW      { tc_deletearray(p);         }
+void* operator new(size_t size, const std::nothrow_t& nt) CPP_NOTHROW {
   return tc_new_nothrow(size, nt);
 }
-void* operator new[](size_t size, const std::nothrow_t& nt) PERFTOOLS_NOTHROW {
+void* operator new[](size_t size, const std::nothrow_t& nt) CPP_NOTHROW {
   return tc_newarray_nothrow(size, nt);
 }
-void operator delete(void* ptr, const std::nothrow_t& nt) PERFTOOLS_NOTHROW {
+void operator delete(void* ptr, const std::nothrow_t& nt) CPP_NOTHROW {
   return tc_delete_nothrow(ptr, nt);
 }
-void operator delete[](void* ptr, const std::nothrow_t& nt) PERFTOOLS_NOTHROW {
+void operator delete[](void* ptr, const std::nothrow_t& nt) CPP_NOTHROW {
   return tc_deletearray_nothrow(ptr, nt);
 }
 
 #ifdef ENABLE_SIZED_DELETE
-void operator delete(void* p, size_t s) PERFTOOLS_NOTHROW  { tc_delete_sized(p, s);     }
-void operator delete[](void* p, size_t s) PERFTOOLS_NOTHROW{ tc_deletearray_sized(p, s); }
+void operator delete(void* p, size_t s) CPP_NOTHROW  { tc_delete_sized(p, s);     }
+void operator delete[](void* p, size_t s) CPP_NOTHROW{ tc_deletearray_sized(p, s);}
 #endif
 
 #if defined(ENABLE_ALIGNED_NEW_DELETE)
@@ -69,33 +69,33 @@ void operator delete[](void* p, size_t s) PERFTOOLS_NOTHROW{ tc_deletearray_size
 void* operator new(size_t size, std::align_val_t al) {
   return tc_new_aligned(size, al);
 }
-void operator delete(void* p, std::align_val_t al) PERFTOOLS_NOTHROW {
+void operator delete(void* p, std::align_val_t al) CPP_NOTHROW {
   tc_delete_aligned(p, al);
 }
 void* operator new[](size_t size, std::align_val_t al) {
   return tc_newarray_aligned(size, al);
 }
-void operator delete[](void* p, std::align_val_t al) PERFTOOLS_NOTHROW {
+void operator delete[](void* p, std::align_val_t al) CPP_NOTHROW {
   tc_deletearray_aligned(p, al);
 }
-void* operator new(size_t size, std::align_val_t al, const std::nothrow_t& nt) PERFTOOLS_NOTHROW {
+void* operator new(size_t size, std::align_val_t al, const std::nothrow_t& nt) CPP_NOTHROW {
   return tc_new_aligned_nothrow(size, al, nt);
 }
-void* operator new[](size_t size, std::align_val_t al, const std::nothrow_t& nt) PERFTOOLS_NOTHROW {
+void* operator new[](size_t size, std::align_val_t al, const std::nothrow_t& nt) CPP_NOTHROW {
   return tc_newarray_aligned_nothrow(size, al, nt);
 }
-void operator delete(void* ptr, std::align_val_t al, const std::nothrow_t& nt) PERFTOOLS_NOTHROW {
+void operator delete(void* ptr, std::align_val_t al, const std::nothrow_t& nt) CPP_NOTHROW {
   return tc_delete_aligned_nothrow(ptr, al, nt);
 }
-void operator delete[](void* ptr, std::align_val_t al, const std::nothrow_t& nt) PERFTOOLS_NOTHROW {
+void operator delete[](void* ptr, std::align_val_t al, const std::nothrow_t& nt) CPP_NOTHROW {
   return tc_deletearray_aligned_nothrow(ptr, al, nt);
 }
 
 #ifdef ENABLE_SIZED_DELETE
-void operator delete(void* p, size_t s, std::align_val_t al) PERFTOOLS_NOTHROW {
+void operator delete(void* p, size_t s, std::align_val_t al) CPP_NOTHROW {
   tc_delete_sized_aligned(p, s, al);
 }
-void operator delete[](void* p, size_t s, std::align_val_t al) PERFTOOLS_NOTHROW {
+void operator delete[](void* p, size_t s, std::align_val_t al) CPP_NOTHROW {
   tc_deletearray_sized_aligned(p, s, al);
 }
 #endif
diff --git a/src/tests/tcmalloc_unittest.cc b/src/tests/tcmalloc_unittest.cc
index 1f362f6..25b2e41 100644
--- a/src/tests/tcmalloc_unittest.cc
+++ b/src/tests/tcmalloc_unittest.cc
@@ -679,7 +679,7 @@ static void TestRealloc() {
 #endif
 }
 
-static void TestNewHandler() PERFTOOLS_THROW(std::bad_alloc) {
+static void TestNewHandler() {
   ++news_handled;
   throw std::bad_alloc();
 }
diff --git a/src/windows/get_mangled_names.cc b/src/windows/get_mangled_names.cc
index 30ac20e..08bd03b 100644
--- a/src/windows/get_mangled_names.cc
+++ b/src/windows/get_mangled_names.cc
@@ -55,11 +55,11 @@
 static char m;   // some dummy memory so new doesn't return NULL.
 
 void* operator new(size_t size) { return &m; }
-void operator delete(void* p) PERFTOOLS_NOTHROW { }
+void operator delete(void* p) throw() { }
 void* operator new[](size_t size) { return &m; }
-void operator delete[](void* p) PERFTOOLS_NOTHROW { }
+void operator delete[](void* p) throw() { }
 
-void* operator new(size_t size, const std::nothrow_t&) PERFTOOLS_NOTHROW { return &m; }
-void operator delete(void* p, const std::nothrow_t&) PERFTOOLS_NOTHROW { }
-void* operator new[](size_t size, const std::nothrow_t&) PERFTOOLS_NOTHROW { return &m; }
-void operator delete[](void* p, const std::nothrow_t&) PERFTOOLS_NOTHROW { }
+void* operator new(size_t size, const std::nothrow_t&) throw() { return &m; }
+void operator delete(void* p, const std::nothrow_t&) throw() { }
+void* operator new[](size_t size, const std::nothrow_t&) throw() { return &m; }
+void operator delete[](void* p, const std::nothrow_t&) throw() { }