Update the tcmalloc vendor branch to r111 (perftools version 1.8)

third_party/tcmalloc/vendor/src/malloc_extension.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 30 matching lines @@
 #else
 #include <sys/types.h>
 #endif
 #include <string>
 #include "base/dynamic_annotations.h"
 #include "base/sysinfo.h"    // for FillProcSelfMaps
 #ifndef NO_HEAP_CHECK
 #include "google/heap-checker.h"
 #endif
 #include "google/malloc_extension.h"
+#include "google/malloc_extension_c.h"
 #include "maybe_threads.h"
 
 using STL_NAMESPACE::string;
 using STL_NAMESPACE::vector;
 
 static void DumpAddressMap(string* result) {
   *result += "\nMAPPED_LIBRARIES:\n";
   // We keep doubling until we get a fit
   const size_t old_resultlen = result->size();
   for (int amap_size = 10240; amap_size < 10000000; amap_size *= 2) {
@@ skipping 109 matching lines @@
 
 double MallocExtension::GetMemoryReleaseRate() {
   return -1.0;
 }
 
 size_t MallocExtension::GetEstimatedAllocatedSize(size_t size) {
   return size;
 }
 
 size_t MallocExtension::GetAllocatedSize(void* p) {
+  assert(GetOwnership(p) != kNotOwned);
   return 0;
 }
 
+MallocExtension::Ownership MallocExtension::GetOwnership(const void* p) {
+  return kUnknownOwnership;
+}
+
 void MallocExtension::GetFreeListSizes(
     vector<MallocExtension::FreeListInfo>* v) {
   v->clear();
 }
 
 // The current malloc extension object.
 
 static pthread_once_t module_init = PTHREAD_ONCE_INIT;
 static MallocExtension* current_instance = NULL;
 
@@ skipping 38 matching lines @@
   return reinterpret_cast<uintptr_t>(entry[2]);
 }
 void* PC(void** entry, int i) {
   return entry[3+i];
 }
 
 void PrintCountAndSize(MallocExtensionWriter* writer,
                        uintptr_t count, uintptr_t size) {
   char buf[100];
   snprintf(buf, sizeof(buf),
-           "%6lld: %8lld [%6lld: %8lld] @",
-           static_cast<long long>(count),
-           static_cast<long long>(size),
-           static_cast<long long>(count),
-           static_cast<long long>(size));
+           "%6"PRIu64": %8"PRIu64" [%6"PRIu64": %8"PRIu64"] @",
+           static_cast<uint64>(count),
+           static_cast<uint64>(size),
+           static_cast<uint64>(count),
+           static_cast<uint64>(size));
   writer->append(buf, strlen(buf));
 }
 
 void PrintHeader(MallocExtensionWriter* writer,
                  const char* label, void** entries) {
   // Compute the total count and total size
   uintptr_t total_count = 0;
   uintptr_t total_size = 0;
   for (void** entry = entries; Count(entry) != 0; entry += 3 + Depth(entry)) {
     total_count += Count(entry);
@@ skipping 94 matching lines @@
        (const char* property, size_t* value), (property, value));
 C_SHIM(SetNumericProperty, int,
        (const char* property, size_t value), (property, value));
 
 C_SHIM(MarkThreadIdle, void, (void), ());
 C_SHIM(MarkThreadBusy, void, (void), ());
 C_SHIM(ReleaseFreeMemory, void, (void), ());
 C_SHIM(ReleaseToSystem, void, (size_t num_bytes), (num_bytes));
 C_SHIM(GetEstimatedAllocatedSize, size_t, (size_t size), (size));
 C_SHIM(GetAllocatedSize, size_t, (void* p), (p));
+
+// Can't use the shim here because of the need to translate the enums.
+extern "C"
+MallocExtension_Ownership MallocExtension_GetOwnership(const void* p) {
+  return static_cast<MallocExtension_Ownership>(
+      MallocExtension::instance()->GetOwnership(p));
+}