clang/win: Fix a few warnings.

base/allocator/allocator_shim.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/allocator/allocator_shim.h"
 
 #include <config.h>
 #include "base/allocator/allocator_extension_thunks.h"
 #include "base/profiler/alternate_timer.h"
 #include "base/sysinfo.h"
 
 // This shim make it possible to use different allocators via an environment
 // variable set before running the program. This may reduce the
 // amount of inlining that we get with malloc/free/etc.
 
 // TODO(mbelshe): Ensure that all calls to tcmalloc have the proper call depth
 // from the "user code" so that debugging tools (HeapChecker) can work.
 
-// __THROW is defined in glibc systems.  It means, counter-intuitively,
-// "This function will never throw an exception."  It's an optional
-// optimization tool, but we may need to use it to match glibc prototypes.
-#ifndef __THROW    // I guess we're not on a glibc system
-# define __THROW   // __THROW is just an optimization, so ok to make it ""
-#endif
-
 // new_mode behaves similarly to MSVC's _set_new_mode.
 // If flag is 0 (default), calls to malloc will behave normally.
 // If flag is 1, calls to malloc will behave like calls to new,
 // and the std_new_handler will be invoked on failure.
 // Can be set by calling _set_new_mode().
 static int new_mode = 0;
 
 typedef enum {
   TCMALLOC,    // TCMalloc is the default allocator.
   WINHEAP,     // Windows Heap (standard Windows allocator).
@@ skipping 59 matching lines @@
   } catch (const std::bad_alloc&) {
     if (!nothrow)
       throw;
     return true;
   }
 #endif  // (defined(__GNUC__) && !defined(__EXCEPTIONS)) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS)
   return false;
 }
 
 extern "C" {
-void* malloc(size_t size) __THROW {
+void* malloc(size_t size) {
   void* ptr;
   for (;;) {
     switch (allocator) {
       case WINHEAP:
       case WINLFH:
         ptr = win_heap_malloc(size);
         break;
       case TCMALLOC:
       default:
         ptr = do_malloc(size);
         break;
     }
     if (ptr)
       return ptr;
 
     if (!new_mode || !call_new_handler(true))
       break;
   }
   return ptr;
 }
 
-void free(void* p) __THROW {
+void free(void* p) {
   switch (allocator) {
     case WINHEAP:
     case WINLFH:
       win_heap_free(p);
       return;
     case TCMALLOC:
       do_free(p);
       return;
   }
 }
 
-void* realloc(void* ptr, size_t size) __THROW {
+void* realloc(void* ptr, size_t size) {
   // Webkit is brittle for allocators that return NULL for malloc(0).  The
   // realloc(0, 0) code path does not guarantee a non-NULL return, so be sure
   // to call malloc for this case.
   if (!ptr)
     return malloc(size);
 
   void* new_ptr;
   for (;;) {
     switch (allocator) {
       case WINHEAP:
@@ skipping 11 matching lines @@
     // NULL.
     if (new_ptr || !size)
       return new_ptr;
     if (!new_mode || !call_new_handler(true))
       break;
   }
   return new_ptr;
 }
 
 // TODO(mbelshe): Implement this for other allocators.
-void malloc_stats(void) __THROW {
+void malloc_stats(void) {
   switch (allocator) {
     case WINHEAP:
     case WINLFH:
       // No stats.
       return;
     case TCMALLOC:
       tc_malloc_stats();
       return;
   }
 }
@@ skipping 194 matching lines @@
 void TCMallocDoFreeForTest(void* ptr) {
   do_free(ptr);
 }
 
 size_t ExcludeSpaceForMarkForTest(size_t size) {
   return ExcludeSpaceForMark(size);
 }
 
 }  // namespace allocator.
 }  // namespace base.