c++11 ud suffix fixes for tcmalloc files

third_party/tcmalloc/chromium/src/memory_region_map.cc

 /* Copyright (c) 2006, 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 639 matching lines @@
     Unlock();
     return;
   }
   if (!recursive_insert) {
     HandleSavedRegionsLocked(&InsertRegionLocked);
   }
     // first handle adding saved regions if any
   uintptr_t start_addr = reinterpret_cast<uintptr_t>(start);
   uintptr_t end_addr = start_addr + size;
   // subtract start_addr, end_addr from all the regions
-  RAW_VLOG(10, "Removing global region %p..%p; have %"PRIuS" regions",
+  RAW_VLOG(10, "Removing global region %p..%p; have %" PRIuS " regions",
               reinterpret_cast<void*>(start_addr),
               reinterpret_cast<void*>(end_addr),
               regions_->size());
   Region sample;
   sample.SetRegionSetKey(start_addr);
   // Only iterate over the regions that might overlap start_addr..end_addr:
   for (RegionSet::iterator region = regions_->lower_bound(sample);
        region != regions_->end()  &&  region->start_addr < end_addr;
        /*noop*/) {
     RAW_VLOG(13, "Looking at region %p..%p",
@@ skipping 46 matching lines @@
       RegionSet::iterator d = region;
       ++region;
       // It's safe to erase before inserting since r is independent of *d:
       // r contains an own copy of the call stack:
       regions_->erase(d);
       InsertRegionLocked(r);
       continue;
     }
     ++region;
   }
-  RAW_VLOG(12, "Removed region %p..%p; have %"PRIuS" regions",
+  RAW_VLOG(12, "Removed region %p..%p; have %" PRIuS " regions",
               reinterpret_cast<void*>(start_addr),
               reinterpret_cast<void*>(end_addr),
               regions_->size());
   if (VLOG_IS_ON(12))  LogAllLocked();
   unmap_size_ += size;
   Unlock();
 }
 
 void MemoryRegionMap::RecordRegionRemovalInBucket(int depth,
                                                   const void* const stack[],
                                                   size_t size) {
   RAW_CHECK(LockIsHeld(), "should be held (by this thread)");
   if (bucket_table_ == NULL) return;
   HeapProfileBucket* b = GetBucket(depth, stack);
   ++b->frees;
   b->free_size += size;
 }
 
 void MemoryRegionMap::MmapHook(const void* result,
                                const void* start, size_t size,
                                int prot, int flags,
                                int fd, off_t offset) {
   // TODO(maxim): replace all 0x%"PRIxS" by %p when RAW_VLOG uses a safe
   // snprintf reimplementation that does not malloc to pretty-print NULL
-  RAW_VLOG(10, "MMap = 0x%"PRIxPTR" of %"PRIuS" at %"PRIu64" "
-              "prot %d flags %d fd %d offs %"PRId64,
+  RAW_VLOG(10, "MMap = 0x%" PRIxPTR " of %" PRIuS " at %" PRIu64 " "
+              "prot %d flags %d fd %d offs %" PRId64,
               reinterpret_cast<uintptr_t>(result), size,
               reinterpret_cast<uint64>(start), prot, flags, fd,
               static_cast<int64>(offset));
   if (result != reinterpret_cast<void*>(MAP_FAILED)  &&  size != 0) {
     RecordRegionAddition(result, size);
   }
 }
 
 void MemoryRegionMap::MunmapHook(const void* ptr, size_t size) {
-  RAW_VLOG(10, "MUnmap of %p %"PRIuS"", ptr, size);
+  RAW_VLOG(10, "MUnmap of %p %" PRIuS, ptr, size);
   if (size != 0) {
     RecordRegionRemoval(ptr, size);
   }
 }
 
 void MemoryRegionMap::MremapHook(const void* result,
                                  const void* old_addr, size_t old_size,
                                  size_t new_size, int flags,
                                  const void* new_addr) {
-  RAW_VLOG(10, "MRemap = 0x%"PRIxPTR" of 0x%"PRIxPTR" %"PRIuS" "
-              "to %"PRIuS" flags %d new_addr=0x%"PRIxPTR,
+  RAW_VLOG(10, "MRemap = 0x%" PRIxPTR " of 0x%" PRIxPTR " %" PRIuS " "
+              "to %" PRIuS " flags %d new_addr=0x%" PRIxPTR,
               (uintptr_t)result, (uintptr_t)old_addr,
                old_size, new_size, flags,
                flags & MREMAP_FIXED ? (uintptr_t)new_addr : 0);
   if (result != reinterpret_cast<void*>(-1)) {
     RecordRegionRemoval(old_addr, old_size);
     RecordRegionAddition(result, new_size);
   }
 }
 
 extern "C" void* __sbrk(ptrdiff_t increment);  // defined in libc
 
 void MemoryRegionMap::SbrkHook(const void* result, ptrdiff_t increment) {
-  RAW_VLOG(10, "Sbrk = 0x%"PRIxPTR" of %"PRIdS"", (uintptr_t)result, increment);
+  RAW_VLOG(10, "Sbrk = 0x%" PRIxPTR " of %" PRIdS,
+           (uintptr_t)result, increment);
   if (result != reinterpret_cast<void*>(-1)) {
     if (increment > 0) {
       void* new_end = sbrk(0);
       RecordRegionAddition(result, reinterpret_cast<uintptr_t>(new_end) -
                                    reinterpret_cast<uintptr_t>(result));
     } else if (increment < 0) {
       void* new_end = sbrk(0);
       RecordRegionRemoval(new_end, reinterpret_cast<uintptr_t>(result) -
                                    reinterpret_cast<uintptr_t>(new_end));
     }
   }
 }
 
 void MemoryRegionMap::LogAllLocked() {
   RAW_CHECK(LockIsHeld(), "should be held (by this thread)");
   RAW_LOG(INFO, "List of regions:");
   uintptr_t previous = 0;
   for (RegionSet::const_iterator r = regions_->begin();
        r != regions_->end(); ++r) {
-    RAW_LOG(INFO, "Memory region 0x%"PRIxPTR"..0x%"PRIxPTR" "
-                  "from 0x%"PRIxPTR" stack=%d",
+    RAW_LOG(INFO, "Memory region 0x%" PRIxPTR "..0x%" PRIxPTR " "
+                  "from 0x%" PRIxPTR " stack=%d",
                   r->start_addr, r->end_addr, r->caller(), r->is_stack);
     RAW_CHECK(previous < r->end_addr, "wow, we messed up the set order");
       // this must be caused by uncontrolled recursive operations on regions_
     previous = r->end_addr;
   }
   RAW_LOG(INFO, "End of regions list");
 }