Switch to standard integer types in tools/.

tools/android/memdump/memdump.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <fcntl.h>
 #include <signal.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <cstring>
 #include <fstream>
 #include <iostream>
 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/base64.h"
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 
 const unsigned int kPageSize = getpagesize();
 
 namespace {
 
 class BitSet {
  public:
   void resize(size_t nbits) {
     data_.resize((nbits + 7) / 8);
   }
 
-  void set(uint32 bit) {
-    const uint32 byte_idx = bit / 8;
+  void set(uint32_t bit) {
+    const uint32_t byte_idx = bit / 8;
     CHECK(byte_idx < data_.size());
     data_[byte_idx] |= (1 << (bit & 7));
   }
 
   std::string AsB64String() const {
     // Simple optimization: strip trailing zero bytes from the bitmap.
     // For instance, if a region has 32 pages but only the first 9 are resident,
     // The full bitmap would be 0xff 0x01 0x00 0x00, the stripped one 0xff 0x01.
     // It can save up to some seconds when printing large mmaps, in particular
     // in presence of large virtual address space reservations (where none of
     // the pages are resident).
     size_t end = data_.size();
     while (end > 0 && data_[end - 1] == '\0')
       --end;
     std::string bits(&data_[0], end);
     std::string b64_string;
     base::Base64Encode(bits, &b64_string);
     return b64_string;
   }
 
  private:
   std::vector<char> data_;
 };
 
 // An entry in /proc/<pid>/pagemap.
 struct PageMapEntry {
-  uint64 page_frame_number : 55;
+  uint64_t page_frame_number : 55;
   uint unused : 8;
   uint present : 1;
 };
 
 // Describes a memory page.
 struct PageInfo {
-  int64 page_frame_number; // Physical page id, also known as PFN.
-  int64 flags;
-  int32 times_mapped;
+  int64_t page_frame_number;  // Physical page id, also known as PFN.
+  int64_t flags;
+  int32_t times_mapped;
 };
 
 struct PageCount {
   PageCount() : total_count(0), unevictable_count(0) {}
 
   int total_count;
   int unevictable_count;
 };
 
 struct MemoryMap {
   std::string name;
   std::string flags;
-  uint64 start_address;
-  uint64 end_address;
-  uint64 offset;
+  uint64_t start_address;
+  uint64_t end_address;
+  uint64_t offset;
   PageCount private_pages;
   // app_shared_pages[i] contains the number of pages mapped in i+2 processes
   // (only among the processes that are being analyzed).
   std::vector<PageCount> app_shared_pages;
   PageCount other_shared_pages;
   std::vector<PageInfo> committed_pages;
   // committed_pages_bits is a bitset reflecting the present bit for all the
   // virtual pages of the mapping.
   BitSet committed_pages_bits;
 };
@@ skipping 11 matching lines @@
   const int KPF_MLOCKED = 33;
 
   return (page_info.flags & ((1ll << KPF_DIRTY) |
                              (1ll << KPF_ANON) |
                              (1ll << KPF_UNEVICTABLE) |
                              (1ll << KPF_MLOCKED))) ?
                              true : false;
 }
 
 // Number of times a physical page is mapped in a process.
-typedef base::hash_map<uint64, int> PFNMap;
+typedef base::hash_map<uint64_t, int> PFNMap;
 
 // Parses lines from /proc/<PID>/maps, e.g.:
 // 401e7000-401f5000 r-xp 00000000 103:02 158       /system/bin/linker
 bool ParseMemoryMapLine(const std::string& line,
                         std::vector<std::string>* tokens,
                         MemoryMap* memory_map) {
   *tokens = base::SplitString(
       line, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (tokens->size() < 2)
     return false;
@@ skipping 69 matching lines @@
 // provided memory map.
 bool GetPagesForMemoryMap(int pagemap_fd,
                           const MemoryMap& memory_map,
                           std::vector<PageInfo>* committed_pages,
                           BitSet* committed_pages_bits) {
   const off64_t offset = memory_map.start_address / kPageSize;
   if (lseek64(pagemap_fd, offset * sizeof(PageMapEntry), SEEK_SET) < 0) {
     PLOG(ERROR) << "lseek";
     return false;
   }
-  for (uint64 addr = memory_map.start_address, page_index = 0;
-       addr < memory_map.end_address;
-       addr += kPageSize, ++page_index) {
+  for (uint64_t addr = memory_map.start_address, page_index = 0;
+       addr < memory_map.end_address; addr += kPageSize, ++page_index) {
     DCHECK_EQ(0u, addr % kPageSize);
     PageMapEntry page_map_entry = {};
-    static_assert(sizeof(PageMapEntry) == sizeof(uint64), "unexpected size");
+    static_assert(sizeof(PageMapEntry) == sizeof(uint64_t), "unexpected size");
     ssize_t bytes = read(pagemap_fd, &page_map_entry, sizeof(page_map_entry));
     if (bytes != sizeof(PageMapEntry) && bytes != 0) {
       PLOG(ERROR) << "read";
       return false;
     }
     if (page_map_entry.present) {  // Ignore non-committed pages.
       if (page_map_entry.page_frame_number == 0)
         continue;
       PageInfo page_info = {};
       page_info.page_frame_number = page_map_entry.page_frame_number;
       committed_pages->push_back(page_info);
       committed_pages_bits->set(page_index);
     }
   }
   return true;
 }
 
 // Fills |committed_pages| with mapping count and flags information gathered
 // looking-up /proc/kpagecount and /proc/kpageflags.
 bool SetPagesInfo(int pagecount_fd,
                   int pageflags_fd,
                   std::vector<PageInfo>* pages) {
   for (std::vector<PageInfo>::iterator it = pages->begin();
        it != pages->end(); ++it) {
     PageInfo* const page_info = &*it;
-    int64 times_mapped;
+    int64_t times_mapped;
     if (!ReadFromFileAtOffset(
             pagecount_fd, page_info->page_frame_number, &times_mapped)) {
       return false;
     }
     DCHECK(times_mapped <= std::numeric_limits<int32_t>::max());
-    page_info->times_mapped = static_cast<int32>(times_mapped);
+    page_info->times_mapped = static_cast<int32_t>(times_mapped);
 
-    int64 page_flags;
+    int64_t page_flags;
     if (!ReadFromFileAtOffset(
             pageflags_fd, page_info->page_frame_number, &page_flags)) {
       return false;
     }
     page_info->flags = page_flags;
   }
   return true;
 }
 
 // Fills in the provided vector of Page Frame Number maps. This lets
@@ skipping 19 matching lines @@
   }
 }
 
 // Sets the private_count/app_shared_pages/other_shared_count fields of the
 // provided memory maps for each process.
 void ClassifyPages(std::vector<ProcessMemory>* processes_memory) {
   std::vector<PFNMap> pfn_maps(processes_memory->size());
   FillPFNMaps(*processes_memory, &pfn_maps);
   // Hash set keeping track of the physical pages mapped in a single process so
   // that they can be counted only once.
-  base::hash_set<uint64> physical_pages_mapped_in_process;
+  base::hash_set<uint64_t> physical_pages_mapped_in_process;
 
   for (std::vector<ProcessMemory>::iterator it = processes_memory->begin();
        it != processes_memory->end(); ++it) {
     std::vector<MemoryMap>* const memory_maps = &it->memory_maps;
     physical_pages_mapped_in_process.clear();
     for (std::vector<MemoryMap>::iterator it = memory_maps->begin();
          it != memory_maps->end(); ++it) {
       MemoryMap* const memory_map = &*it;
       const size_t processes_count = processes_memory->size();
       memory_map->app_shared_pages.resize(processes_count - 1);
       const std::vector<PageInfo>& pages = memory_map->committed_pages;
       for (std::vector<PageInfo>::const_iterator it = pages.begin();
            it != pages.end(); ++it) {
         const PageInfo& page_info = *it;
         if (page_info.times_mapped == 1) {
           ++memory_map->private_pages.total_count;
           if (PageIsUnevictable(page_info))
             ++memory_map->private_pages.unevictable_count;
           continue;
         }
-        const uint64 page_frame_number = page_info.page_frame_number;
-        const std::pair<base::hash_set<uint64>::iterator, bool> result =
+        const uint64_t page_frame_number = page_info.page_frame_number;
+        const std::pair<base::hash_set<uint64_t>::iterator, bool> result =
             physical_pages_mapped_in_process.insert(page_frame_number);
         const bool did_insert = result.second;
         if (!did_insert) {
           // This physical page (mapped multiple times in the same process) was
           // already counted.
           continue;
         }
         // See if the current physical page is also mapped in the other
         // processes that are being analyzed.
         int times_mapped = 0;
@@ skipping 197 matching lines @@
     }
   }
 
   ClassifyPages(&processes_memory);
   if (short_output)
     DumpProcessesMemoryMapsInShortFormat(processes_memory);
   else
     DumpProcessesMemoryMapsInExtendedFormat(processes_memory);
   return EXIT_SUCCESS;
 }