Merge google-perftools r109 (the current contents of third_party/tcmalloc/vendor)

third_party/tcmalloc/chromium/src/tests/debugallocation_test.cc

 // Copyright (c) 2007, 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 195 matching lines @@
   int *x = new int;
   delete x;
   int old_x_value = *x;
   *x = 1;
   // verify that dangling writes are caught at program termination if the
   // corrupted block never got pushed off of the end of the free queue.
   IF_DEBUG_EXPECT_DEATH(exit(0), "Memory was written to after being freed.");
   *x = old_x_value;  // restore x so that the test can exit successfully.
 }
 
+TEST(DebugAllocationTest, StackTraceWithDanglingWriteAtExitTest) {
+  int *x = new int;
+  delete x;
+  int old_x_value = *x;
+  *x = 1;
+  // verify that we also get a stack trace when we have a dangling write.
+  // The " @ " is part of the stack trace output.
+  IF_DEBUG_EXPECT_DEATH(exit(0), " @ .*main");
+  *x = old_x_value;  // restore x so that the test can exit successfully.
+}
+
 static size_t CurrentlyAllocatedBytes() {
   size_t value;
   CHECK(MallocExtension::instance()->GetNumericProperty(
             "generic.current_allocated_bytes", &value));
   return value;
 }
 
 TEST(DebugAllocationTest, CurrentlyAllocated) {
   // Clear the free queue
 #if 1
@@ skipping 26 matching lines @@
 #endif
   void* a = malloc(1000);
   EXPECT_GE(MallocExtension::instance()->GetAllocatedSize(a), 1000);
   // This is just a sanity check.  If we allocated too much, alloc is broken
   EXPECT_LE(MallocExtension::instance()->GetAllocatedSize(a), 5000);
   EXPECT_GE(MallocExtension::instance()->GetEstimatedAllocatedSize(1000), 1000);
   free(a);
 }
 
 TEST(DebugAllocationTest, HugeAlloc) {
-  const size_t kTooBig = ~static_cast<size_t>(0);
+  // This must not be a const variable so it doesn't form an
+  // integral-constant-expression which can be *statically* rejected by the
+  // compiler as too large for the allocation.
+  size_t kTooBig = ~static_cast<size_t>(0);
   void* a = NULL;
-  char* b = NULL;
 
 #ifndef NDEBUG
 
   a = malloc(kTooBig);
   EXPECT_EQ(NULL, a);
-  b = NULL;
-  IF_DEBUG_EXPECT_DEATH(b = new char[kTooBig],
-                        "Unable to allocate.*new\\[\\] failed\\.");
-  EXPECT_EQ(NULL, b);
 
   // kAlsoTooBig is small enough not to get caught by debugallocation's check,
-  // but will still fall through to tcmalloc's check.
-  const size_t kAlsoTooBig = kTooBig - 1024;
+  // but will still fall through to tcmalloc's check. This must also be
+  // a non-const variable. See kTooBig for more details.
+  size_t kAlsoTooBig = kTooBig - 1024;
 
   a = malloc(kAlsoTooBig);
   EXPECT_EQ(NULL, a);
-  IF_DEBUG_EXPECT_DEATH(b = new char[kAlsoTooBig], "Unable to allocate.*new failed");
-  EXPECT_EQ(NULL, b);
 #endif
 }
 
 int main(int argc, char** argv) {
   // If you run without args, we run the non-death parts of the test.
   // Otherwise, argv[1] should be a number saying which death-test
   // to run.  We will output a regexp we expect the death-message
   // to include, and then run the given death test (which hopefully
   // will produce that error message).  If argv[1] > the number of
   // death tests, we will run only the non-death parts.  One way to
   // tell when you are done with all tests is when no 'expected
   // regexp' message is printed for a given argv[1].
   if (argc < 2) {
     test_to_run = -1;   // will never match
   } else {
     test_to_run = atoi(argv[1]);
   }
   return RUN_ALL_TESTS();
 }