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

third_party/tcmalloc/chromium/src/tests/heap-checker_unittest.cc

 // 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 58 matching lines @@
 #include <sys/types.h>
 #include <stdlib.h>
 #include <errno.h>              // errno
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>             // for sleep(), geteuid()
 #endif
 #ifdef HAVE_MMAP
 #include <sys/mman.h>
 #endif
 #include <fcntl.h>              // for open(), close()
-// FreeBSD has malloc.h, but complains if you use it
-#if defined(HAVE_MALLOC_H) && !defined(__FreeBSD__)
-#include <malloc.h>
-#endif
-
 #ifdef HAVE_EXECINFO_H
 #include <execinfo.h>           // backtrace
 #endif
 #ifdef HAVE_GRP_H
 #include <grp.h>                // getgrent, getgrnam
 #endif
 #ifdef HAVE_PWD_H
 #include <pwd.h>
 #endif
 
+#include <algorithm>
 #include <iostream>             // for cout
 #include <iomanip>              // for hex
+#include <list>
+#include <map>
+#include <memory>
 #include <set>
-#include <map>
-#include <list>
-#include <memory>
+#include <string>
 #include <vector>
-#include <string>
 
+#include "base/commandlineflags.h"
 #include "base/googleinit.h"
 #include "base/logging.h"
 #include "base/commandlineflags.h"
 #include "base/thread_lister.h"
 #include <google/heap-checker.h>
 #include "memory_region_map.h"
 #include <google/malloc_extension.h>
 #include <google/stacktrace.h>
 
 // On systems (like freebsd) that don't define MAP_ANONYMOUS, use the old
@@ skipping 171 matching lines @@
 }
 
 // Make gcc think a pointer is "used"
 template <class T>
 static void Use(T** foo) {
   VLOG(2) << "Dummy-using " << static_cast<void*>(*foo) << " at " << foo;
 }
 
 // Arbitrary value, but not such that xor'ing with it is likely
 // to map one valid pointer to another valid pointer:
-static const uintptr_t kHideMask = 0xF03A5F7B;
+static const uintptr_t kHideMask =
+  static_cast<uintptr_t>(0xF03A5F7BF03A5F7BLL);
 
 // Helpers to hide a pointer from live data traversal.
 // We just xor the pointer so that (with high probability)
 // it's not a valid address of a heap object anymore.
 // Both Hide and UnHide must be executed within RunHidden() below
 // to prevent leaving stale data on active stack that can be a pointer
 // to a heap object that is not actually reachable via live variables.
 // (UnHide might leave heap pointer value for an object
 //  that will be deallocated but later another object
 //  can be allocated at the same heap address.)
@@ skipping 371 matching lines @@
 // simple leak
 static void TransLeaks() {
   AllocHidden(1 * sizeof(char));
 }
 
 // range-based disabling using Disabler
 static void ScopedDisabledLeaks() {
   HeapLeakChecker::Disabler disabler;
   AllocHidden(3 * sizeof(int));
   TransLeaks();
-  malloc(10);  // Direct leak
+  (void)malloc(10);  // Direct leak
 }
 
 // have different disabled leaks
 static void* RunDisabledLeaks(void* a) {
   ScopedDisabledLeaks();
   return a;
 }
 
 // have different disabled leaks inside of a thread
 static void ThreadDisabledLeaks() {
@@ skipping 787 matching lines @@
     CHECK(heap_check.SameHeap());
   } else {
     WARN_IF(heap_check.SameHeap() != true,
             "overall leaks are caught; we must be using a stripped binary");
   }
 
   CHECK(HeapLeakChecker::NoGlobalLeaks());  // so far, so good
 
   return Pass();
 }