Add a chromium version abort function for tcmalloc: Abort().

third_party/tcmalloc/chromium/src/base/logging.h

 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // 
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 27 matching lines @@
 #include <config.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <stdio.h>
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>    // for write()
 #endif
 #include <string.h>    // for strlen(), strcmp()
 #include <assert.h>
 #include <errno.h>     // for errno
+#include "base/abort.h"
 #include "base/commandlineflags.h"
 
 // On some systems (like freebsd), we can't call write() at all in a
 // global constructor, perhaps because errno hasn't been set up.
 // (In windows, we can't call it because it might call malloc.)
 // Calling the write syscall is safer (it doesn't set errno), so we
 // prefer that.  Note we don't care about errno for logging: we just
 // do logging on a best-effort basis.
 #if defined(_MSC_VER)
 #define WRITE_TO_STDERR(buf, len) WriteToStderr(buf, len);  // in port.cc
@@ skipping 20 matching lines @@
 // controlled by NDEBUG, so the check will be executed regardless of
 // compilation mode.  Therefore, it is safe to do things like:
 //    CHECK(fp->Write(x) == 4)
 // Note we use write instead of printf/puts to avoid the risk we'll
 // call malloc().
 #define CHECK(condition)                                                \
   do {                                                                  \
     if (!(condition)) {                                                 \
       WRITE_TO_STDERR("Check failed: " #condition "\n",                 \
                       sizeof("Check failed: " #condition "\n")-1);      \
-      abort();                                                          \
+      tcmalloc::Abort();                                                \
     }                                                                   \
   } while (0)
 
 // This takes a message to print.  The name is historical.
 #define RAW_CHECK(condition, message)                                          \
   do {                                                                         \
     if (!(condition)) {                                                        \
       WRITE_TO_STDERR("Check failed: " #condition ": " message "\n",           \
                       sizeof("Check failed: " #condition ": " message "\n")-1);\
-      abort();                                                                 \
+      tcmalloc::Abort();                                                       \
     }                                                                          \
   } while (0)
 
 // This is like RAW_CHECK, but only in debug-mode
 #ifdef NDEBUG
 enum { DEBUG_MODE = 0 };
 #define RAW_DCHECK(condition, message)
 #else
 enum { DEBUG_MODE = 1 };
 #define RAW_DCHECK(condition, message)  RAW_CHECK(condition, message)
 #endif
 
 // This prints errno as well.  Note we use write instead of printf/puts to
 // avoid the risk we'll call malloc().
 #define PCHECK(condition)                                               \
   do {                                                                  \
     if (!(condition)) {                                                 \
       const int err_no = errno;                                         \
       WRITE_TO_STDERR("Check failed: " #condition ": ",                 \
                       sizeof("Check failed: " #condition ": ")-1);      \
       WRITE_TO_STDERR(strerror(err_no), strlen(strerror(err_no)));      \
       WRITE_TO_STDERR("\n", sizeof("\n")-1);                            \
-      abort();                                                          \
+      tcmalloc::Abort();                                                \
     }                                                                   \
   } while (0)
 
 // Helper macro for binary operators; prints the two values on error
 // Don't use this macro directly in your code, use CHECK_EQ et al below
 
 // WARNING: These don't compile correctly if one of the arguments is a pointer
 // and the other is NULL. To work around this, simply static_cast NULL to the
 // type of the desired pointer.
 
 // TODO(jandrews): Also print the values in case of failure.  Requires some
 // sort of type-sensitive ToString() function.
 #define CHECK_OP(op, val1, val2)                                        \
   do {                                                                  \
     if (!((val1) op (val2))) {                                          \
       fprintf(stderr, "Check failed: %s %s %s\n", #val1, #op, #val2);   \
-      abort();                                                          \
+      tcmalloc::Abort();                                                \
     }                                                                   \
   } while (0)
 
 #define CHECK_EQ(val1, val2) CHECK_OP(==, val1, val2)
 #define CHECK_NE(val1, val2) CHECK_OP(!=, val1, val2)
 #define CHECK_LE(val1, val2) CHECK_OP(<=, val1, val2)
 #define CHECK_LT(val1, val2) CHECK_OP(< , val1, val2)
 #define CHECK_GE(val1, val2) CHECK_OP(>=, val1, val2)
 #define CHECK_GT(val1, val2) CHECK_OP(> , val1, val2)
 
@@ skipping 48 matching lines @@
 inline void LogPrintf(int severity, const char* pat, va_list ap) {
   // We write directly to the stderr file descriptor and avoid FILE
   // buffering because that may invoke malloc()
   char buf[1600];
   perftools_vsnprintf(buf, sizeof(buf)-1, pat, ap);
   if (buf[0] != '\0' && buf[strlen(buf)-1] != '\n') {
     assert(strlen(buf)+1 < sizeof(buf));
     strcat(buf, "\n");
   }
   WRITE_TO_STDERR(buf, strlen(buf));
-  if ((severity) == FATAL)
-    abort(); // LOG(FATAL) indicates a big problem, so don't run atexit() calls
+  if ((severity) == FATAL) {
+    // LOG(FATAL) indicates a big problem, so don't run atexit() calls
+    tcmalloc::Abort();
+  }
 }
 
 // Note that since the order of global constructors is unspecified,
 // global code that calls RAW_LOG may execute before FLAGS_verbose is set.
 // Such code will run with verbosity == 0 no matter what.
 #define VLOG_IS_ON(severity) (FLAGS_verbose >= severity)
 
 // In a better world, we'd use __VA_ARGS__, but VC++ 7 doesn't support it.
 #define LOG_PRINTF(severity, pat) do {          \
   if (VLOG_IS_ON(severity)) {                   \
@@ skipping 30 matching lines @@
 #else
 typedef int RawFD;
 const RawFD kIllegalRawFD = -1;   // what open returns if it fails
 #endif  // defined(_WIN32) || defined(__CYGWIN__) || defined(__CYGWIN32__)
 
 RawFD RawOpenForWriting(const char* filename);   // uses default permissions
 void RawWrite(RawFD fd, const char* buf, size_t len);
 void RawClose(RawFD fd);
 
 #endif // _LOGGING_H_