Experiment for updating the tcmalloc chromium branch to r144 (gperftools 2.0).

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 67 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);      \
-      exit(1);                                                          \
+      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);\
-      exit(1);                                                                 \
+      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);                            \
-      exit(1);                                                          \
+      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);   \
-      exit(1);                                                          \
+      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 100 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_