bug 848880 - Update to Breakpad SVN r1128. r=upstream
authorTed Mielczarek <ted@mielczarek.org>
Thu, 07 Mar 2013 13:50:42 -0500
changeset 134538 e0d9902b2bbfe9829cdd888b58f6fa7d4e0e1507
parent 134537 83d1008f43115843ca4bcdbbbf0f02e0f4090dab
child 134539 c1ef9a062a881813022c38d51d66c71546a21dab
push id2452
push userlsblakk@mozilla.com
push dateMon, 13 May 2013 16:59:38 +0000
treeherdermozilla-beta@d4b152d29d8d [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersupstream
bugs848880
milestone22.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
bug 848880 - Update to Breakpad SVN r1128. r=upstream
toolkit/crashreporter/breakpad-patches/00-module-api-extras.patch
toolkit/crashreporter/breakpad-patches/00-stdint.patch
toolkit/crashreporter/breakpad-patches/01-dump-symbols-just-cfi.patch
toolkit/crashreporter/breakpad-patches/02-cfi-rule-repr.patch
toolkit/crashreporter/breakpad-patches/03-unique-string.patch
toolkit/crashreporter/breakpad-patches/04-uniquestringmap.patch
toolkit/crashreporter/breakpad-patches/05-androidfixup.patch
toolkit/crashreporter/breakpad-patches/06-readsymboldata-mac.patch
toolkit/crashreporter/breakpad-patches/07-processor-win32.patch
toolkit/crashreporter/breakpad-patches/08-dwarf2reader-dynamic-cast.patch
toolkit/crashreporter/breakpad-patches/09-no-stabs.patch
toolkit/crashreporter/google-breakpad/SVN-INFO
toolkit/crashreporter/google-breakpad/src/client/mac/handler/exception_handler.cc
toolkit/crashreporter/google-breakpad/src/client/windows/crash_generation/minidump_generator.h
toolkit/crashreporter/google-breakpad/src/common/dwarf_cu_to_module.cc.orig
toolkit/crashreporter/google-breakpad/src/common/mac/MachIPC.h
toolkit/crashreporter/google-breakpad/src/common/mac/dump_syms.mm
toolkit/crashreporter/google-breakpad/src/common/module.cc
toolkit/crashreporter/google-breakpad/src/google_breakpad/common/breakpad_types.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/common/minidump_cpu_amd64.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/common/minidump_cpu_arm.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/common/minidump_cpu_ppc.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/common/minidump_cpu_ppc64.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/common/minidump_cpu_sparc.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/common/minidump_format.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/memory_region.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/process_state.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/stackwalker.h
toolkit/crashreporter/google-breakpad/src/processor/basic_source_line_resolver.cc
toolkit/crashreporter/google-breakpad/src/processor/basic_source_line_resolver.cc.orig
toolkit/crashreporter/google-breakpad/src/processor/minidump.cc
toolkit/crashreporter/google-breakpad/src/processor/minidump_processor.cc
toolkit/crashreporter/google-breakpad/src/processor/minidump_stackwalk.cc
toolkit/crashreporter/google-breakpad/src/processor/process_state.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_amd64_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_arm_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_selftest.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_x86_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/windows_frame_info.h
--- a/toolkit/crashreporter/breakpad-patches/00-module-api-extras.patch
+++ b/toolkit/crashreporter/breakpad-patches/00-module-api-extras.patch
@@ -1,46 +1,70 @@
 # HG changeset patch
 # User Ted Mielczarek <ted@mielczarek.org>
 # Date 1352220493 18000
-# Node ID a38d670da97e338234375756313b2f47650e01fb
-# Parent  201b7c6793586b6b7cfcaa02f4e29700c4c12ef1
+# Node ID c3b1109dd392c16a9fe4e85da693010966dbbf0b
+# Parent  03db269a2868503cca9e80f62ce676aabbf967fd
 Add APIs for querying Module data
 R=glandium at https://breakpad.appspot.com/511003/
 
 diff --git a/src/common/module.cc b/src/common/module.cc
 --- a/src/common/module.cc
 +++ b/src/common/module.cc
-@@ -63,7 +63,7 @@
+@@ -58,17 +58,17 @@
+ 
+ Module::~Module() {
+   for (FileByNameMap::iterator it = files_.begin(); it != files_.end(); ++it)
+     delete it->second;
+   for (FunctionSet::iterator it = functions_.begin();
         it != functions_.end(); ++it) {
      delete *it;
    }
 -  for (vector<StackFrameEntry *>::iterator it = stack_frame_entries_.begin();
 +  for (StackFrameEntrySet::iterator it = stack_frame_entries_.begin();
         it != stack_frame_entries_.end(); ++it) {
      delete *it;
    }
-@@ -93,8 +93,14 @@
+   for (ExternSet::iterator it = externs_.begin(); it != externs_.end(); ++it)
+     delete *it;
+ }
+ 
+ void Module::SetLoadAddress(Address address) {
+@@ -88,39 +88,84 @@
+ }
+ 
+ void Module::AddFunctions(vector<Function *>::iterator begin,
+                           vector<Function *>::iterator end) {
+   for (vector<Function *>::iterator it = begin; it != end; ++it)
      AddFunction(*it);
  }
  
 -void Module::AddStackFrameEntry(StackFrameEntry *stack_frame_entry) {
 -  stack_frame_entries_.push_back(stack_frame_entry);
 +void Module::AddStackFrameEntry(StackFrameEntry* stack_frame_entry) {
 +  std::pair<StackFrameEntrySet::iterator,bool> ret =
 +      stack_frame_entries_.insert(stack_frame_entry);
 +  if (!ret.second) {
 +    // Free the duplicate that was not inserted because this Module
 +    // now owns it.
 +    delete stack_frame_entry;
 +  }
  }
  
  void Module::AddExtern(Extern *ext) {
-@@ -111,11 +117,50 @@
+   std::pair<ExternSet::iterator,bool> ret = externs_.insert(ext);
+   if (!ret.second) {
+     // Free the duplicate that was not inserted because this Module
+     // now owns it.
+     delete ext;
+   }
+ }
+ 
+ void Module::GetFunctions(vector<Function *> *vec,
+                           vector<Function *>::iterator i) {
    vec->insert(i, functions_.begin(), functions_.end());
  }
  
 +template<typename T>
 +bool EntryContainsAddress(T entry, Module::Address address) {
 +  return entry->address <= address && address < entry->address + entry->size;
 +}
 +
@@ -81,17 +105,27 @@ diff --git a/src/common/module.cc b/src/
 +    return NULL;
 +
 +  return *it;
 +}
 +
  Module::File *Module::FindFile(const string &name) {
    // A tricky bit here.  The key of each map entry needs to be a
    // pointer to the entry's File's name string.  This means that we
-@@ -155,8 +200,25 @@
+   // can't do the initial lookup with any operation that would create
+   // an empty entry for us if the name isn't found (like, say,
+   // operator[] or insert do), because such a created entry's key will
+   // be a pointer the string passed as our argument.  Since the key of
+   // a map's value type is const, we can't fix it up once we've
+@@ -150,18 +195,35 @@
+ }
+ 
+ void Module::GetFiles(vector<File *> *vec) {
+   vec->clear();
+   for (FileByNameMap::iterator it = files_.begin(); it != files_.end(); ++it)
      vec->push_back(it->second);
  }
  
 -void Module::GetStackFrameEntries(vector<StackFrameEntry *> *vec) {
 -  *vec = stack_frame_entries_;
 +void Module::GetStackFrameEntries(vector<StackFrameEntry *>* vec) {
 +  vec->clear();
 +  vec->insert(vec->begin(), stack_frame_entries_.begin(),
@@ -109,124 +143,182 @@ diff --git a/src/common/module.cc b/src/
 +  it--;
 +  if (EntryContainsAddress(*it, address))
 +    return *it;
 +
 +  return NULL;
  }
  
  void Module::AssignSourceIds() {
-@@ -261,7 +323,7 @@
+   // First, give every source file an id of -1.
+   for (FileByNameMap::iterator file_it = files_.begin();
+        file_it != files_.end(); ++file_it) {
+     file_it->second->source_id = -1;
+   }
+@@ -256,17 +318,17 @@
+       stream << "PUBLIC " << hex
+              << (ext->address - load_address_) << " 0 "
+              << ext->name << dec << endl;
+     }
+   }
  
-   if (cfi) {
+   if (symbol_data != NO_CFI) {
      // Write out 'STACK CFI INIT' and 'STACK CFI' records.
 -    vector<StackFrameEntry *>::const_iterator frame_it;
 +    StackFrameEntrySet::const_iterator frame_it;
      for (frame_it = stack_frame_entries_.begin();
           frame_it != stack_frame_entries_.end(); ++frame_it) {
        StackFrameEntry *entry = *frame_it;
+       stream << "STACK CFI INIT " << hex
+              << (entry->address - load_address_) << " "
+              << entry->size << " " << dec;
+       if (!stream.good()
+           || !WriteRuleMap(entry->initial_rules, stream))
 diff --git a/src/common/module.h b/src/common/module.h
 --- a/src/common/module.h
 +++ b/src/common/module.h
-@@ -168,6 +168,13 @@
+@@ -164,16 +164,23 @@
+ 
+   struct ExternCompare {
+     bool operator() (const Extern *lhs,
+                      const Extern *rhs) const {
+       return lhs->address < rhs->address;
      }
    };
  
 +  struct StackFrameEntryCompare {
 +    bool operator() (const StackFrameEntry* lhs,
 +                     const StackFrameEntry* rhs) const {
 +      return lhs->address < rhs->address;
 +    }
 +  };
 +
    // Create a new module with the given name, operating system,
    // architecture, and ID string.
    Module(const string &name, const string &os, const string &architecture,
-@@ -227,6 +234,10 @@
+          const string &id);
+   ~Module();
+ 
+   // Set the module's load address to LOAD_ADDRESS; addresses given
+   // for functions and lines will be written to the Breakpad symbol
+@@ -223,37 +230,49 @@
+ 
+   // Insert pointers to the functions added to this module at I in
+   // VEC. The pointed-to Functions are still owned by this module.
+   // (Since this is effectively a copy of the function list, this is
+   // mostly useful for testing; other uses should probably get a more
    // appropriate interface.)
    void GetFunctions(vector<Function *> *vec, vector<Function *>::iterator i);
  
 +  // If this module has a function at ADDRESS, return a pointer to it.
 +  // Otherwise, return NULL.
 +  Function* FindFunctionByAddress(Address address);
 +
    // Insert pointers to the externs added to this module at I in
    // VEC. The pointed-to Externs are still owned by this module.
    // (Since this is effectively a copy of the extern list, this is
-@@ -234,6 +245,10 @@
+   // mostly useful for testing; other uses should probably get a more
    // appropriate interface.)
    void GetExterns(vector<Extern *> *vec, vector<Extern *>::iterator i);
  
 +  // If this module has an extern whose base address is less than ADDRESS,
 +  // return a pointer to it. Otherwise, return NULL.
 +  Extern* FindExternByAddress(Address address);
 +
    // Clear VEC and fill it with pointers to the Files added to this
    // module, sorted by name. The pointed-to Files are still owned by
    // this module. (Since this is effectively a copy of the file list,
-@@ -248,6 +263,10 @@
+   // this is mostly useful for testing; other uses should probably get
+   // a more appropriate interface.)
+   void GetFiles(vector<File *> *vec);
+ 
+   // Clear VEC and fill it with pointers to the StackFrameEntry
+   // objects that have been added to this module. (Since this is
+   // effectively a copy of the stack frame entry list, this is mostly
+   // useful for testing; other uses should probably get
    // a more appropriate interface.)
    void GetStackFrameEntries(vector<StackFrameEntry *> *vec);
  
 +  // If this module has a StackFrameEntry whose address range covers
 +  // ADDRESS, return it. Otherwise return NULL.
 +  StackFrameEntry* FindStackFrameEntryByAddress(Address address);
 +
    // Find those files in this module that are actually referred to by
    // functions' line number data, and assign them source id numbers.
    // Set the source id numbers for all other files --- unused by the
-@@ -301,6 +320,9 @@
+   // source line data --- to -1.  We do this before writing out the
+   // symbol file, at which point we omit any unused files.
+   void AssignSourceIds();
+ 
+   // Call AssignSourceIds, and write this module to STREAM in the
+@@ -299,25 +318,28 @@
+   typedef map<const string *, File *, CompareStringPtrs> FileByNameMap;
+ 
+   // A set containing Function structures, sorted by address.
+   typedef set<Function *, FunctionCompare> FunctionSet;
+ 
    // A set containing Extern structures, sorted by address.
    typedef set<Extern *, ExternCompare> ExternSet;
  
 +  // A set containing StackFrameEntry structures, sorted by address.
 +  typedef set<StackFrameEntry*, StackFrameEntryCompare> StackFrameEntrySet;
 +
    // The module owns all the files and functions that have been added
    // to it; destroying the module frees the Files and Functions these
    // point to.
-@@ -309,7 +331,7 @@
+   FileByNameMap files_;    // This module's source files.
+   FunctionSet functions_;  // This module's functions.
  
    // The module owns all the call frame info entries that have been
    // added to it.
 -  vector<StackFrameEntry *> stack_frame_entries_;
 +  StackFrameEntrySet stack_frame_entries_;
  
    // The module owns all the externs that have been added to it;
    // destroying the module frees the Externs these point to.
+   ExternSet externs_;
+ };
+ 
+ }  // namespace google_breakpad
+ 
 diff --git a/src/common/module_unittest.cc b/src/common/module_unittest.cc
 --- a/src/common/module_unittest.cc
 +++ b/src/common/module_unittest.cc
-@@ -334,11 +334,6 @@
-   m.Write(s, true);
+@@ -329,63 +329,63 @@
+   entry3->rule_changes[0x36682fad3763ffffULL][".cfa"] =
+     "I think I know";
+   m.AddStackFrameEntry(entry3);
+ 
+   // Check that Write writes STACK CFI records properly.
+   m.Write(s, ALL_SYMBOL_DATA);
    string contents = s.str();
    EXPECT_STREQ("MODULE os-name architecture id-string name with spaces\n"
 -               "STACK CFI INIT ddb5f41285aa7757 1486493370dc5073 \n"
 -               "STACK CFI INIT 8064f3af5e067e38 de2a5ee55509407"
 -               " .cfa: I think that I shall never see"
 -               " cannoli: a tree whose hungry mouth is prest"
 -               " stromboli: a poem lovely as a tree\n"
                 "STACK CFI INIT 5e8d0db0a7075c6c 1c7edb12a7aea229"
                 " .cfa: Whose woods are these\n"
                 "STACK CFI 36682fad3763ffff"
-@@ -346,7 +341,12 @@
+                " .cfa: I think I know"
                 " stromboli: his house is in\n"
                 "STACK CFI 47ceb0f63c269d7f"
                 " calzone: the village though"
 -               " cannoli: he will not see me stopping here\n",
 +               " cannoli: he will not see me stopping here\n"
 +               "STACK CFI INIT 8064f3af5e067e38 de2a5ee55509407"
 +               " .cfa: I think that I shall never see"
 +               " cannoli: a tree whose hungry mouth is prest"
 +               " stromboli: a poem lovely as a tree\n"
 +               "STACK CFI INIT ddb5f41285aa7757 1486493370dc5073 \n",
                 contents.c_str());
  
    // Check that GetStackFrameEntries works.
-@@ -354,10 +354,18 @@
+   vector<Module::StackFrameEntry *> entries;
    m.GetStackFrameEntries(&entries);
    ASSERT_EQ(3U, entries.size());
    // Check first entry.
 -  EXPECT_EQ(0xddb5f41285aa7757ULL, entries[0]->address);
 -  EXPECT_EQ(0x1486493370dc5073ULL, entries[0]->size);
 -  ASSERT_EQ(0U, entries[0]->initial_rules.size());
 -  ASSERT_EQ(0U, entries[0]->rule_changes.size());
 +  EXPECT_EQ(0x5e8d0db0a7075c6cULL, entries[0]->address);
@@ -239,17 +331,21 @@ diff --git a/src/common/module_unittest.
 +  entry1_changes[0x36682fad3763ffffULL]["stromboli"] = "his house is in";
 +  entry1_changes[0x47ceb0f63c269d7fULL]["calzone"] = "the village though";
 +  entry1_changes[0x47ceb0f63c269d7fULL]["cannoli"] =
 +    "he will not see me stopping here";
 +  EXPECT_THAT(entries[0]->rule_changes, ContainerEq(entry1_changes));
    // Check second entry.
    EXPECT_EQ(0x8064f3af5e067e38ULL, entries[1]->address);
    EXPECT_EQ(0x0de2a5ee55509407ULL, entries[1]->size);
-@@ -369,18 +377,10 @@
+   ASSERT_EQ(3U, entries[1]->initial_rules.size());
+   Module::RuleMap entry2_initial;
+   entry2_initial[".cfa"] = "I think that I shall never see";
+   entry2_initial["stromboli"] = "a poem lovely as a tree";
+   entry2_initial["cannoli"] = "a tree whose hungry mouth is prest";
    EXPECT_THAT(entries[1]->initial_rules, ContainerEq(entry2_initial));
    ASSERT_EQ(0U, entries[1]->rule_changes.size());
    // Check third entry.
 -  EXPECT_EQ(0x5e8d0db0a7075c6cULL, entries[2]->address);
 -  EXPECT_EQ(0x1c7edb12a7aea229ULL, entries[2]->size);
 -  Module::RuleMap entry3_initial;
 -  entry3_initial[".cfa"] = "Whose woods are these";
 -  EXPECT_THAT(entries[2]->initial_rules, ContainerEq(entry3_initial));
@@ -262,17 +358,27 @@ diff --git a/src/common/module_unittest.
 -  EXPECT_THAT(entries[2]->rule_changes, ContainerEq(entry3_changes));
 +  EXPECT_EQ(0xddb5f41285aa7757ULL, entries[2]->address);
 +  EXPECT_EQ(0x1486493370dc5073ULL, entries[2]->size);
 +  ASSERT_EQ(0U, entries[2]->initial_rules.size());
 +  ASSERT_EQ(0U, entries[2]->rule_changes.size());
  }
  
  TEST(Construct, UniqueFiles) {
-@@ -488,3 +488,150 @@
+   Module m(MODULE_NAME, MODULE_OS, MODULE_ARCH, MODULE_ID);
+   Module::File *file1 = m.FindFile("foo");
+   Module::File *file2 = m.FindFile(string("bar"));
+   Module::File *file3 = m.FindFile(string("foo"));
+   Module::File *file4 = m.FindFile("bar");
+@@ -483,8 +483,155 @@
+   m.Write(s, ALL_SYMBOL_DATA);
+   string contents = s.str();
+ 
+   EXPECT_STREQ("MODULE " MODULE_OS " " MODULE_ARCH " "
+                MODULE_ID " " MODULE_NAME "\n"
                 "PUBLIC ffff 0 _xyz\n",
                 contents.c_str());
  }
 +
 +TEST(Lookup, Function) {
 +  Module m(MODULE_NAME, MODULE_OS, MODULE_ARCH, MODULE_ID);
 +
 +  Module::Function *function1 = new(Module::Function);
deleted file mode 100644
--- a/toolkit/crashreporter/breakpad-patches/00-stdint.patch
+++ /dev/null
@@ -1,12909 +0,0 @@
-Use stdint types everywhere
-
-diff --git a/src/client/linux/crash_generation/crash_generation_server.cc b/src/client/linux/crash_generation/crash_generation_server.cc
---- a/src/client/linux/crash_generation/crash_generation_server.cc
-+++ b/src/client/linux/crash_generation/crash_generation_server.cc
-@@ -85,17 +85,17 @@
-     return false;
-   }
- 
-   if (0 != memcmp(kSocketLinkPrefix, buf, sizeof(kSocketLinkPrefix) - 1)) {
-     return false;
-   }
- 
-   char* endptr;
--  const u_int64_t inode_ul =
-+  const uint64_t inode_ul =
-       strtoull(buf + sizeof(kSocketLinkPrefix) - 1, &endptr, 10);
-   if (*endptr != ']')
-     return false;
- 
-   if (inode_ul == ULLONG_MAX) {
-     return false;
-   }
- 
-diff --git a/src/client/linux/handler/exception_handler.cc b/src/client/linux/handler/exception_handler.cc
---- a/src/client/linux/handler/exception_handler.cc
-+++ b/src/client/linux/handler/exception_handler.cc
-@@ -592,17 +592,17 @@
- #else
- #error "This code has not been ported to your platform yet."
- #endif
- 
-   return GenerateDump(&context);
- }
- 
- void ExceptionHandler::AddMappingInfo(const string& name,
--                                      const u_int8_t identifier[sizeof(MDGUID)],
-+                                      const uint8_t identifier[sizeof(MDGUID)],
-                                       uintptr_t start_address,
-                                       size_t mapping_size,
-                                       size_t file_offset) {
-   MappingInfo info;
-   info.start_addr = start_address;
-   info.size = mapping_size;
-   info.offset = file_offset;
-   strncpy(info.name, name.c_str(), sizeof(info.name) - 1);
-diff --git a/src/client/linux/handler/exception_handler.h b/src/client/linux/handler/exception_handler.h
---- a/src/client/linux/handler/exception_handler.h
-+++ b/src/client/linux/handler/exception_handler.h
-@@ -200,17 +200,17 @@
-   bool IsOutOfProcess() const {
-       return crash_generation_client_.get() != NULL;
-   }
- 
-   // Add information about a memory mapping. This can be used if
-   // a custom library loader is used that maps things in a way
-   // that the linux dumper can't handle by reading the maps file.
-   void AddMappingInfo(const string& name,
--                      const u_int8_t identifier[sizeof(MDGUID)],
-+                      const uint8_t identifier[sizeof(MDGUID)],
-                       uintptr_t start_address,
-                       size_t mapping_size,
-                       size_t file_offset);
- 
-   // Register a block of memory of length bytes starting at address ptr
-   // to be copied to the minidump when a crash happens.
-   void RegisterAppMemory(void* ptr, size_t length);
- 
-diff --git a/src/client/linux/handler/exception_handler_unittest.cc b/src/client/linux/handler/exception_handler_unittest.cc
---- a/src/client/linux/handler/exception_handler_unittest.cc
-+++ b/src/client/linux/handler/exception_handler_unittest.cc
-@@ -418,17 +418,17 @@
- // to the dump as a MinidumpMemoryRegion.
- TEST(ExceptionHandlerTest, InstructionPointerMemory) {
-   AutoTempDir temp_dir;
-   int fds[2];
-   ASSERT_NE(pipe(fds), -1);
- 
-   // These are defined here so the parent can use them to check the
-   // data from the minidump afterwards.
--  const u_int32_t kMemorySize = 256;  // bytes
-+  const uint32_t kMemorySize = 256;  // bytes
-   const int kOffset = kMemorySize / 2;
-   // This crashes with SIGILL on x86/x86-64/arm.
-   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
- 
-   const pid_t child = fork();
-   if (child == 0) {
-     close(fds[0]);
-     ExceptionHandler handler(MinidumpDescriptor(temp_dir.path()), NULL,
-@@ -478,29 +478,29 @@
-   MinidumpMemoryList* memory_list = minidump.GetMemoryList();
-   ASSERT_TRUE(exception);
-   ASSERT_TRUE(memory_list);
-   ASSERT_LT(0U, memory_list->region_count());
- 
-   MinidumpContext* context = exception->GetContext();
-   ASSERT_TRUE(context);
- 
--  u_int64_t instruction_pointer;
-+  uint64_t instruction_pointer;
-   ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
- 
-   MinidumpMemoryRegion* region =
-       memory_list->GetMemoryRegionForAddress(instruction_pointer);
-   ASSERT_TRUE(region);
- 
-   EXPECT_EQ(kMemorySize, region->GetSize());
--  const u_int8_t* bytes = region->GetMemory();
-+  const uint8_t* bytes = region->GetMemory();
-   ASSERT_TRUE(bytes);
- 
--  u_int8_t prefix_bytes[kOffset];
--  u_int8_t suffix_bytes[kMemorySize - kOffset - sizeof(instructions)];
-+  uint8_t prefix_bytes[kOffset];
-+  uint8_t suffix_bytes[kMemorySize - kOffset - sizeof(instructions)];
-   memset(prefix_bytes, 0, sizeof(prefix_bytes));
-   memset(suffix_bytes, 0, sizeof(suffix_bytes));
-   EXPECT_TRUE(memcmp(bytes, prefix_bytes, sizeof(prefix_bytes)) == 0);
-   EXPECT_TRUE(memcmp(bytes + kOffset, instructions, sizeof(instructions)) == 0);
-   EXPECT_TRUE(memcmp(bytes + kOffset + sizeof(instructions),
-                      suffix_bytes, sizeof(suffix_bytes)) == 0);
- 
-   unlink(minidump_path.c_str());
-@@ -510,17 +510,17 @@
- // bounded correctly on the low end.
- TEST(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
-   AutoTempDir temp_dir;
-   int fds[2];
-   ASSERT_NE(pipe(fds), -1);
- 
-   // These are defined here so the parent can use them to check the
-   // data from the minidump afterwards.
--  const u_int32_t kMemorySize = 256;  // bytes
-+  const uint32_t kMemorySize = 256;  // bytes
-   const int kOffset = 0;
-   // This crashes with SIGILL on x86/x86-64/arm.
-   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
- 
-   const pid_t child = fork();
-   if (child == 0) {
-     close(fds[0]);
-     ExceptionHandler handler(MinidumpDescriptor(temp_dir.path()), NULL,
-@@ -570,28 +570,28 @@
-   MinidumpMemoryList* memory_list = minidump.GetMemoryList();
-   ASSERT_TRUE(exception);
-   ASSERT_TRUE(memory_list);
-   ASSERT_LT(0U, memory_list->region_count());
- 
-   MinidumpContext* context = exception->GetContext();
-   ASSERT_TRUE(context);
- 
--  u_int64_t instruction_pointer;
-+  uint64_t instruction_pointer;
-   ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
- 
-   MinidumpMemoryRegion* region =
-       memory_list->GetMemoryRegionForAddress(instruction_pointer);
-   ASSERT_TRUE(region);
- 
-   EXPECT_EQ(kMemorySize / 2, region->GetSize());
--  const u_int8_t* bytes = region->GetMemory();
-+  const uint8_t* bytes = region->GetMemory();
-   ASSERT_TRUE(bytes);
- 
--  u_int8_t suffix_bytes[kMemorySize / 2 - sizeof(instructions)];
-+  uint8_t suffix_bytes[kMemorySize / 2 - sizeof(instructions)];
-   memset(suffix_bytes, 0, sizeof(suffix_bytes));
-   EXPECT_TRUE(memcmp(bytes + kOffset, instructions, sizeof(instructions)) == 0);
-   EXPECT_TRUE(memcmp(bytes + kOffset + sizeof(instructions),
-                      suffix_bytes, sizeof(suffix_bytes)) == 0);
-   unlink(minidump_path.c_str());
- }
- 
- // Test that the memory region around the instruction pointer is
-@@ -601,17 +601,17 @@
-   int fds[2];
-   ASSERT_NE(pipe(fds), -1);
- 
-   // These are defined here so the parent can use them to check the
-   // data from the minidump afterwards.
-   // Use 4k here because the OS will hand out a single page even
-   // if a smaller size is requested, and this test wants to
-   // test the upper bound of the memory range.
--  const u_int32_t kMemorySize = 4096;  // bytes
-+  const uint32_t kMemorySize = 4096;  // bytes
-   // This crashes with SIGILL on x86/x86-64/arm.
-   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
-   const int kOffset = kMemorySize - sizeof(instructions);
- 
-   const pid_t child = fork();
-   if (child == 0) {
-     close(fds[0]);
-     ExceptionHandler handler(MinidumpDescriptor(temp_dir.path()), NULL,
-@@ -660,29 +660,29 @@
-   MinidumpMemoryList* memory_list = minidump.GetMemoryList();
-   ASSERT_TRUE(exception);
-   ASSERT_TRUE(memory_list);
-   ASSERT_LT(0U, memory_list->region_count());
- 
-   MinidumpContext* context = exception->GetContext();
-   ASSERT_TRUE(context);
- 
--  u_int64_t instruction_pointer;
-+  uint64_t instruction_pointer;
-   ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
- 
-   MinidumpMemoryRegion* region =
-       memory_list->GetMemoryRegionForAddress(instruction_pointer);
-   ASSERT_TRUE(region);
- 
-   const size_t kPrefixSize = 128;  // bytes
-   EXPECT_EQ(kPrefixSize + sizeof(instructions), region->GetSize());
--  const u_int8_t* bytes = region->GetMemory();
-+  const uint8_t* bytes = region->GetMemory();
-   ASSERT_TRUE(bytes);
- 
--  u_int8_t prefix_bytes[kPrefixSize];
-+  uint8_t prefix_bytes[kPrefixSize];
-   memset(prefix_bytes, 0, sizeof(prefix_bytes));
-   EXPECT_TRUE(memcmp(bytes, prefix_bytes, sizeof(prefix_bytes)) == 0);
-   EXPECT_TRUE(memcmp(bytes + kPrefixSize,
-                      instructions, sizeof(instructions)) == 0);
- 
-   unlink(minidump_path.c_str());
- }
- 
-@@ -737,19 +737,19 @@
-   unlink(minidump_path.c_str());
- }
- #endif // !ADDRESS_SANITIZER
- 
- // Test that anonymous memory maps can be annotated with names and IDs.
- TEST(ExceptionHandlerTest, ModuleInfo) {
-   // These are defined here so the parent can use them to check the
-   // data from the minidump afterwards.
--  const u_int32_t kMemorySize = sysconf(_SC_PAGESIZE);
-+  const uint32_t kMemorySize = sysconf(_SC_PAGESIZE);
-   const char* kMemoryName = "a fake module";
--  const u_int8_t kModuleGUID[sizeof(MDGUID)] = {
-+  const uint8_t kModuleGUID[sizeof(MDGUID)] = {
-     0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
-     0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
-   };
-   char module_identifier_buffer[kGUIDStringSize];
-   FileID::ConvertIdentifierToString(kModuleGUID,
-                                     module_identifier_buffer,
-                                     sizeof(module_identifier_buffer));
-   string module_identifier(module_identifier_buffer);
-@@ -993,25 +993,25 @@
-   unlink(minidump_2.path());
- 
-   // 2 distinct files should be produced.
-   ASSERT_STRNE(minidump_1_path.c_str(), minidump_2_path.c_str());
- }
- 
- // Test that an additional memory region can be added to the minidump.
- TEST(ExceptionHandlerTest, AdditionalMemory) {
--  const u_int32_t kMemorySize = sysconf(_SC_PAGESIZE);
-+  const uint32_t kMemorySize = sysconf(_SC_PAGESIZE);
- 
-   // Get some heap memory.
--  u_int8_t* memory = new u_int8_t[kMemorySize];
-+  uint8_t* memory = new uint8_t[kMemorySize];
-   const uintptr_t kMemoryAddress = reinterpret_cast<uintptr_t>(memory);
-   ASSERT_TRUE(memory);
- 
-   // Stick some data into the memory so the contents can be verified.
--  for (u_int32_t i = 0; i < kMemorySize; ++i) {
-+  for (uint32_t i = 0; i < kMemorySize; ++i) {
-     memory[i] = i % 255;
-   }
- 
-   AutoTempDir temp_dir;
-   ExceptionHandler handler(
-       MinidumpDescriptor(temp_dir.path()), NULL, NULL, NULL, true, -1);
- 
-   // Add the memory region to the list of memory to be included.
-@@ -1037,20 +1037,20 @@
-   EXPECT_EQ(0, memcmp(region->GetMemory(), memory, kMemorySize));
- 
-   delete[] memory;
- }
- 
- // Test that a memory region that was previously registered
- // can be unregistered.
- TEST(ExceptionHandlerTest, AdditionalMemoryRemove) {
--  const u_int32_t kMemorySize = sysconf(_SC_PAGESIZE);
-+  const uint32_t kMemorySize = sysconf(_SC_PAGESIZE);
- 
-   // Get some heap memory.
--  u_int8_t* memory = new u_int8_t[kMemorySize];
-+  uint8_t* memory = new uint8_t[kMemorySize];
-   const uintptr_t kMemoryAddress = reinterpret_cast<uintptr_t>(memory);
-   ASSERT_TRUE(memory);
- 
-   AutoTempDir temp_dir;
-   ExceptionHandler handler(
-       MinidumpDescriptor(temp_dir.path()), NULL, NULL, NULL, true, -1);
- 
-   // Add the memory region to the list of memory to be included.
-@@ -1104,17 +1104,17 @@
-                                             temp_dir.path(), SimpleCallback,
-                                             (void*)&minidump_filename));
- 
-   Minidump minidump(minidump_filename);
-   ASSERT_TRUE(minidump.Read());
-   // Check that the crashing thread is the main thread of |child|
-   MinidumpException* exception = minidump.GetException();
-   ASSERT_TRUE(exception);
--  u_int32_t thread_id;
-+  uint32_t thread_id;
-   ASSERT_TRUE(exception->GetThreadID(&thread_id));
-   EXPECT_EQ(child, static_cast<int32_t>(thread_id));
- 
-   const MDRawExceptionStream* raw = exception->exception();
-   ASSERT_TRUE(raw);
-   EXPECT_EQ(MD_EXCEPTION_CODE_LIN_DUMP_REQUESTED,
-             raw->exception_record.exception_code);
- 
-diff --git a/src/client/linux/minidump_writer/minidump_writer.cc b/src/client/linux/minidump_writer/minidump_writer.cc
---- a/src/client/linux/minidump_writer/minidump_writer.cc
-+++ b/src/client/linux/minidump_writer/minidump_writer.cc
-@@ -328,17 +328,17 @@
-   out->context_flags = MD_CONTEXT_ARM_FULL;
- 
-   for (int i = 0; i < MD_CONTEXT_ARM_GPR_COUNT; ++i)
-     out->iregs[i] = info.regs.uregs[i];
-   // No CPSR register in ThreadInfo(it's not accessible via ptrace)
-   out->cpsr = 0;
- #if !defined(__ANDROID__)
-   out->float_save.fpscr = info.fpregs.fpsr |
--    (static_cast<u_int64_t>(info.fpregs.fpcr) << 32);
-+    (static_cast<uint64_t>(info.fpregs.fpcr) << 32);
-   // TODO: sort this out, actually collect floating point registers
-   my_memset(&out->float_save.regs, 0, sizeof(out->float_save.regs));
-   my_memset(&out->float_save.extra, 0, sizeof(out->float_save.extra));
- #endif
- }
- 
- void CPUFillFromUContext(MDRawContextARM* out, const ucontext* uc,
-                          const struct _libc_fpstate* fpregs) {
-@@ -530,28 +530,28 @@
-   }
- 
-   // Check if the top of the stack is part of a system call that has been
-   // redirected by the seccomp sandbox. If so, try to pop the stack frames
-   // all the way back to the point where the interception happened.
-   void PopSeccompStackFrame(RawContextCPU* cpu, const MDRawThread& thread,
-                             uint8_t* stack_copy) {
- #if defined(__x86_64)
--    u_int64_t bp = cpu->rbp;
--    u_int64_t top = thread.stack.start_of_memory_range;
-+    uint64_t bp = cpu->rbp;
-+    uint64_t top = thread.stack.start_of_memory_range;
-     for (int i = 4; i--; ) {
-       if (bp < top ||
-           bp + sizeof(bp) > thread.stack.start_of_memory_range +
-           thread.stack.memory.data_size ||
-           bp & 1) {
-         break;
-       }
-       uint64_t old_top = top;
-       top = bp;
--      u_int8_t* bp_addr = stack_copy + bp - thread.stack.start_of_memory_range;
-+      uint8_t* bp_addr = stack_copy + bp - thread.stack.start_of_memory_range;
-       my_memcpy(&bp, bp_addr, sizeof(bp));
-       if (bp == 0xDEADBEEFDEADBEEFull) {
-         struct {
-           uint64_t r15;
-           uint64_t r14;
-           uint64_t r13;
-           uint64_t r12;
-           uint64_t r11;
-@@ -593,28 +593,28 @@
-         cpu->r13 = seccomp_stackframe.r13;
-         cpu->r14 = seccomp_stackframe.r14;
-         cpu->r15 = seccomp_stackframe.r15;
-         cpu->rip = seccomp_stackframe.fakeret;
-         return;
-       }
-     }
- #elif defined(__i386)
--    u_int32_t bp = cpu->ebp;
--    u_int32_t top = thread.stack.start_of_memory_range;
-+    uint32_t bp = cpu->ebp;
-+    uint32_t top = thread.stack.start_of_memory_range;
-     for (int i = 4; i--; ) {
-       if (bp < top ||
-           bp + sizeof(bp) > thread.stack.start_of_memory_range +
-           thread.stack.memory.data_size ||
-           bp & 1) {
-         break;
-       }
-       uint32_t old_top = top;
-       top = bp;
--      u_int8_t* bp_addr = stack_copy + bp - thread.stack.start_of_memory_range;
-+      uint8_t* bp_addr = stack_copy + bp - thread.stack.start_of_memory_range;
-       my_memcpy(&bp, bp_addr, sizeof(bp));
-       if (bp == 0xDEADBEEFu) {
-         struct {
-           uint32_t edi;
-           uint32_t esi;
-           uint32_t edx;
-           uint32_t ecx;
-           uint32_t ebx;
-@@ -716,17 +716,17 @@
-           ucontext_ &&
-           !dumper_->IsPostMortem()) {
-         uint8_t* stack_copy;
-         if (!FillThreadStack(&thread, GetStackPointer(), -1, &stack_copy))
-           return false;
- 
-         // Copy 256 bytes around crashing instruction pointer to minidump.
-         const size_t kIPMemorySize = 256;
--        u_int64_t ip = GetInstructionPointer();
-+        uint64_t ip = GetInstructionPointer();
-         // Bound it to the upper and lower bounds of the memory map
-         // it's contained within. If it's not in mapped memory,
-         // don't bother trying to write it.
-         bool ip_is_mapped = false;
-         MDMemoryDescriptor ip_memory_d;
-         for (unsigned j = 0; j < dumper_->mappings().size(); ++j) {
-           const MappingInfo& mapping = *dumper_->mappings()[j];
-           if (ip >= mapping.start_addr &&
-@@ -916,17 +916,17 @@
- 
-   // Fill the MDRawModule |mod| with information about the provided
-   // |mapping|. If |identifier| is non-NULL, use it instead of calculating
-   // a file ID from the mapping.
-   bool FillRawModule(const MappingInfo& mapping,
-                      bool member,
-                      unsigned int mapping_id,
-                      MDRawModule& mod,
--                     const u_int8_t* identifier) {
-+                     const uint8_t* identifier) {
-     my_memset(&mod, 0, MD_MODULE_SIZE);
- 
-     mod.base_of_image = mapping.start_addr;
-     mod.size_of_image = mapping.size;
-     const size_t filepath_len = my_strlen(mapping.name);
- 
-     // Figure out file name from path
-     const char* filename_ptr = mapping.name + filepath_len - 1;
-diff --git a/src/client/linux/minidump_writer/minidump_writer.h b/src/client/linux/minidump_writer/minidump_writer.h
---- a/src/client/linux/minidump_writer/minidump_writer.h
-+++ b/src/client/linux/minidump_writer/minidump_writer.h
-@@ -41,17 +41,17 @@
- #include "google_breakpad/common/minidump_format.h"
- 
- namespace google_breakpad {
- 
- class ExceptionHandler;
- 
- struct MappingEntry {
-   MappingInfo first;
--  u_int8_t second[sizeof(MDGUID)];
-+  uint8_t second[sizeof(MDGUID)];
- };
- 
- // A list of <MappingInfo, GUID>
- typedef std::list<MappingEntry> MappingList;
- 
- // These entries store a list of memory regions that the client wants included
- // in the minidump.
- struct AppMemory {
-diff --git a/src/client/linux/minidump_writer/minidump_writer_unittest.cc b/src/client/linux/minidump_writer/minidump_writer_unittest.cc
---- a/src/client/linux/minidump_writer/minidump_writer_unittest.cc
-+++ b/src/client/linux/minidump_writer/minidump_writer_unittest.cc
-@@ -126,19 +126,19 @@
- // Test that mapping info can be specified when writing a minidump,
- // and that it ends up in the module list of the minidump.
- TEST(MinidumpWriterTest, MappingInfo) {
-   int fds[2];
-   ASSERT_NE(-1, pipe(fds));
- 
-   // These are defined here so the parent can use them to check the
-   // data from the minidump afterwards.
--  const u_int32_t memory_size = sysconf(_SC_PAGESIZE);
-+  const uint32_t memory_size = sysconf(_SC_PAGESIZE);
-   const char* kMemoryName = "a fake module";
--  const u_int8_t kModuleGUID[sizeof(MDGUID)] = {
-+  const uint8_t kModuleGUID[sizeof(MDGUID)] = {
-     0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
-     0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
-   };
-   char module_identifier_buffer[kGUIDStringSize];
-   FileID::ConvertIdentifierToString(kModuleGUID,
-                                     module_identifier_buffer,
-                                     sizeof(module_identifier_buffer));
-   string module_identifier(module_identifier_buffer);
-@@ -208,17 +208,17 @@
-     module_list->GetModuleForAddress(kMemoryAddress);
-   ASSERT_TRUE(module);
- 
-   EXPECT_EQ(kMemoryAddress, module->base_address());
-   EXPECT_EQ(memory_size, module->size());
-   EXPECT_EQ(kMemoryName, module->code_file());
-   EXPECT_EQ(module_identifier, module->debug_identifier());
- 
--  u_int32_t len;
-+  uint32_t len;
-   // These streams are expected to be there
-   EXPECT_TRUE(minidump.SeekToStreamType(MD_THREAD_LIST_STREAM, &len));
-   EXPECT_TRUE(minidump.SeekToStreamType(MD_MEMORY_LIST_STREAM, &len));
-   EXPECT_TRUE(minidump.SeekToStreamType(MD_EXCEPTION_STREAM, &len));
-   EXPECT_TRUE(minidump.SeekToStreamType(MD_SYSTEM_INFO_STREAM, &len));
-   EXPECT_TRUE(minidump.SeekToStreamType(MD_LINUX_CPU_INFO, &len));
-   EXPECT_TRUE(minidump.SeekToStreamType(MD_LINUX_PROC_STATUS, &len));
-   EXPECT_TRUE(minidump.SeekToStreamType(MD_LINUX_CMD_LINE, &len));
-@@ -236,17 +236,17 @@
- TEST(MinidumpWriterTest, MappingInfoContained) {
-   int fds[2];
-   ASSERT_NE(-1, pipe(fds));
- 
-   // These are defined here so the parent can use them to check the
-   // data from the minidump afterwards.
-   const int32_t memory_size = sysconf(_SC_PAGESIZE);
-   const char* kMemoryName = "a fake module";
--  const u_int8_t kModuleGUID[sizeof(MDGUID)] = {
-+  const uint8_t kModuleGUID[sizeof(MDGUID)] = {
-     0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
-     0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
-   };
-   char module_identifier_buffer[kGUIDStringSize];
-   FileID::ConvertIdentifierToString(kModuleGUID,
-                                     module_identifier_buffer,
-                                     sizeof(module_identifier_buffer));
-   string module_identifier(module_identifier_buffer);
-@@ -430,25 +430,25 @@
- 
- // Test that an additional memory region can be added to the minidump.
- TEST(MinidumpWriterTest, AdditionalMemory) {
-   int fds[2];
-   ASSERT_NE(-1, pipe(fds));
- 
-   // These are defined here so the parent can use them to check the
-   // data from the minidump afterwards.
--  const u_int32_t kMemorySize = sysconf(_SC_PAGESIZE);
-+  const uint32_t kMemorySize = sysconf(_SC_PAGESIZE);
- 
-   // Get some heap memory.
--  u_int8_t* memory = new u_int8_t[kMemorySize];
-+  uint8_t* memory = new uint8_t[kMemorySize];
-   const uintptr_t kMemoryAddress = reinterpret_cast<uintptr_t>(memory);
-   ASSERT_TRUE(memory);
- 
-   // Stick some data into the memory so the contents can be verified.
--  for (u_int32_t i = 0; i < kMemorySize; ++i) {
-+  for (uint32_t i = 0; i < kMemorySize; ++i) {
-     memory[i] = i % 255;
-   }
- 
-   const pid_t child = fork();
-   if (child == 0) {
-     close(fds[1]);
-     char b;
-     HANDLE_EINTR(read(fds[0], &b, sizeof(b)));
-diff --git a/src/client/mac/handler/minidump_generator.cc b/src/client/mac/handler/minidump_generator.cc
---- a/src/client/mac/handler/minidump_generator.cc
-+++ b/src/client/mac/handler/minidump_generator.cc
-@@ -405,17 +405,17 @@
-     case CPU_TYPE_X86_64:
-       return WriteContextX86_64(state, register_location);
- #endif
-     default:
-       return false;
-   }
- }
- 
--u_int64_t MinidumpGenerator::CurrentPCForStack(
-+uint64_t MinidumpGenerator::CurrentPCForStack(
-     breakpad_thread_state_data_t state) {
-   switch (cpu_type_) {
- #ifdef HAS_ARM_SUPPORT
-     case CPU_TYPE_ARM:
-       return CurrentPCForStackARM(state);
- #endif
- #ifdef HAS_PPC_SUPPORT
-     case CPU_TYPE_POWERPC:
-@@ -439,17 +439,17 @@
- bool MinidumpGenerator::WriteStackARM(breakpad_thread_state_data_t state,
-                                       MDMemoryDescriptor *stack_location) {
-   arm_thread_state_t *machine_state =
-       reinterpret_cast<arm_thread_state_t *>(state);
-   mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, sp);
-   return WriteStackFromStartAddress(start_addr, stack_location);
- }
- 
--u_int64_t
-+uint64_t
- MinidumpGenerator::CurrentPCForStackARM(breakpad_thread_state_data_t state) {
-   arm_thread_state_t *machine_state =
-       reinterpret_cast<arm_thread_state_t *>(state);
- 
-   return REGISTER_FROM_THREADSTATE(machine_state, pc);
- }
- 
- bool MinidumpGenerator::WriteContextARM(breakpad_thread_state_data_t state,
-@@ -505,25 +505,25 @@
- bool MinidumpGenerator::WriteStackPPC64(breakpad_thread_state_data_t state,
-                                         MDMemoryDescriptor *stack_location) {
-   ppc_thread_state64_t *machine_state =
-       reinterpret_cast<ppc_thread_state64_t *>(state);
-   mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, r1);
-   return WriteStackFromStartAddress(start_addr, stack_location);
- }
- 
--u_int64_t
-+uint64_t
- MinidumpGenerator::CurrentPCForStackPPC(breakpad_thread_state_data_t state) {
-   ppc_thread_state_t *machine_state =
-       reinterpret_cast<ppc_thread_state_t *>(state);
- 
-   return REGISTER_FROM_THREADSTATE(machine_state, srr0);
- }
- 
--u_int64_t
-+uint64_t
- MinidumpGenerator::CurrentPCForStackPPC64(breakpad_thread_state_data_t state) {
-   ppc_thread_state64_t *machine_state =
-       reinterpret_cast<ppc_thread_state64_t *>(state);
- 
-   return REGISTER_FROM_THREADSTATE(machine_state, srr0);
- }
- 
- bool MinidumpGenerator::WriteContextPPC(breakpad_thread_state_data_t state,
-@@ -667,25 +667,25 @@
-                                          MDMemoryDescriptor *stack_location) {
-   x86_thread_state64_t *machine_state =
-       reinterpret_cast<x86_thread_state64_t *>(state);
- 
-   mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, rsp);
-   return WriteStackFromStartAddress(start_addr, stack_location);
- }
- 
--u_int64_t
-+uint64_t
- MinidumpGenerator::CurrentPCForStackX86(breakpad_thread_state_data_t state) {
-   i386_thread_state_t *machine_state =
-       reinterpret_cast<i386_thread_state_t *>(state);
- 
-   return REGISTER_FROM_THREADSTATE(machine_state, eip);
- }
- 
--u_int64_t
-+uint64_t
- MinidumpGenerator::CurrentPCForStackX86_64(breakpad_thread_state_data_t state) {
-   x86_thread_state64_t *machine_state =
-       reinterpret_cast<x86_thread_state64_t *>(state);
- 
-   return REGISTER_FROM_THREADSTATE(machine_state, rip);
- }
- 
- bool MinidumpGenerator::WriteContextX86(breakpad_thread_state_data_t state,
-@@ -759,17 +759,17 @@
-   AddReg(r13);
-   AddReg(r14);
-   AddReg(r15);
-   AddReg(rip);
-   // according to AMD's software developer guide, bits above 18 are
-   // not used in the flags register.  Since the minidump format
-   // specifies 32 bits for the flags register, we can truncate safely
-   // with no loss.
--  context_ptr->eflags = static_cast<u_int32_t>(REGISTER_FROM_THREADSTATE(machine_state, rflags));
-+  context_ptr->eflags = static_cast<uint32_t>(REGISTER_FROM_THREADSTATE(machine_state, rflags));
-   AddReg(cs);
-   AddReg(fs);
-   AddReg(gs);
- #undef AddReg
- 
-   return true;
- }
- #endif
-@@ -894,17 +894,17 @@
-   bool have_ip_memory = false;
-   MDMemoryDescriptor ip_memory_d;
-   if (exception_thread_ && exception_type_) {
-     breakpad_thread_state_data_t state;
-     mach_msg_type_number_t stateCount
-       = static_cast<mach_msg_type_number_t>(sizeof(state));
- 
-     if (GetThreadState(exception_thread_, state, &stateCount)) {
--      u_int64_t ip = CurrentPCForStack(state);
-+      uint64_t ip = CurrentPCForStack(state);
-       // Bound it to the upper and lower bounds of the region
-       // it's contained within. If it's not in a known memory region,
-       // don't bother trying to write it.
-       mach_vm_address_t addr = static_cast<vm_address_t>(ip);
-       mach_vm_size_t size;
-       natural_t nesting_level = 0;
-       vm_region_submap_info_64 info;
-       mach_msg_type_number_t info_count = VM_REGION_SUBMAP_INFO_COUNT_64;
-@@ -1157,17 +1157,17 @@
- 
-     MDLocationDescriptor string_location;
- 
-     string name = image->GetFilePath();
-     if (!writer_.WriteString(name.c_str(), 0, &string_location))
-       return false;
- 
-     module->base_of_image = image->GetVMAddr() + image->GetVMAddrSlide();
--    module->size_of_image = static_cast<u_int32_t>(image->GetVMSize());
-+    module->size_of_image = static_cast<uint32_t>(image->GetVMSize());
-     module->module_name_rva = string_location.rva;
- 
-     // We'll skip the executable module, because they don't have
-     // LC_ID_DYLIB load commands, and the crash processing server gets
-     // version information from the Plist file, anyway.
-     if (index != static_cast<uint32_t>(FindExecutableModule())) {
-       module->version_info.signature = MD_VSFIXEDFILEINFO_SIGNATURE;
-       module->version_info.struct_version |= MD_VSFIXEDFILEINFO_VERSION;
-@@ -1223,17 +1223,17 @@
- 
-         if (!strcmp(seg->segname, "__TEXT")) {
-           MDLocationDescriptor string_location;
- 
-           if (!writer_.WriteString(name, 0, &string_location))
-             return false;
- 
-           module->base_of_image = seg->vmaddr + slide;
--          module->size_of_image = static_cast<u_int32_t>(seg->vmsize);
-+          module->size_of_image = static_cast<uint32_t>(seg->vmsize);
-           module->module_name_rva = string_location.rva;
- 
-           bool in_memory = false;
- #if TARGET_OS_IPHONE
-           in_memory = true;
- #endif
-           if (!WriteCVRecord(module, cpu_type, name, in_memory))
-             return false;
-@@ -1282,17 +1282,17 @@
-   // Increment past the slash
-   if (module_name)
-     ++module_name;
-   else
-     module_name = "<Unknown>";
- 
-   size_t module_name_length = strlen(module_name);
- 
--  if (!cv.AllocateObjectAndArray(module_name_length + 1, sizeof(u_int8_t)))
-+  if (!cv.AllocateObjectAndArray(module_name_length + 1, sizeof(uint8_t)))
-     return false;
- 
-   if (!cv.CopyIndexAfterObject(0, module_name, module_name_length))
-     return false;
- 
-   module->cv_record = cv.location();
-   MDCVInfoPDB70 *cv_ptr = cv.get();
-   cv_ptr->cv_signature = MD_CVINFOPDB70_SIGNATURE;
-@@ -1383,53 +1383,53 @@
- 
-   if (!info.Allocate())
-     return false;
- 
-   misc_info_stream->stream_type = MD_MISC_INFO_STREAM;
-   misc_info_stream->location = info.location();
- 
-   MDRawMiscInfo *info_ptr = info.get();
--  info_ptr->size_of_info = static_cast<u_int32_t>(sizeof(MDRawMiscInfo));
-+  info_ptr->size_of_info = static_cast<uint32_t>(sizeof(MDRawMiscInfo));
-   info_ptr->flags1 = MD_MISCINFO_FLAGS1_PROCESS_ID |
-     MD_MISCINFO_FLAGS1_PROCESS_TIMES |
-     MD_MISCINFO_FLAGS1_PROCESSOR_POWER_INFO;
- 
-   // Process ID
-   info_ptr->process_id = getpid();
- 
-   // Times
-   struct rusage usage;
-   if (getrusage(RUSAGE_SELF, &usage) != -1) {
-     // Omit the fractional time since the MDRawMiscInfo only wants seconds
-     info_ptr->process_user_time =
--        static_cast<u_int32_t>(usage.ru_utime.tv_sec);
-+        static_cast<uint32_t>(usage.ru_utime.tv_sec);
-     info_ptr->process_kernel_time =
--        static_cast<u_int32_t>(usage.ru_stime.tv_sec);
-+        static_cast<uint32_t>(usage.ru_stime.tv_sec);
-   }
-   int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID,
-                  static_cast<int>(info_ptr->process_id) };
--  u_int mibsize = static_cast<u_int>(sizeof(mib) / sizeof(mib[0]));
-+  uint mibsize = static_cast<uint>(sizeof(mib) / sizeof(mib[0]));
-   struct kinfo_proc proc;
-   size_t size = sizeof(proc);
-   if (sysctl(mib, mibsize, &proc, &size, NULL, 0) == 0) {
-     info_ptr->process_create_time =
--        static_cast<u_int32_t>(proc.kp_proc.p_starttime.tv_sec);
-+        static_cast<uint32_t>(proc.kp_proc.p_starttime.tv_sec);
-   }
- 
-   // Speed
-   uint64_t speed;
-   const uint64_t kOneMillion = 1000 * 1000;
-   size = sizeof(speed);
-   sysctlbyname("hw.cpufrequency_max", &speed, &size, NULL, 0);
--  info_ptr->processor_max_mhz = static_cast<u_int32_t>(speed / kOneMillion);
--  info_ptr->processor_mhz_limit = static_cast<u_int32_t>(speed / kOneMillion);
-+  info_ptr->processor_max_mhz = static_cast<uint32_t>(speed / kOneMillion);
-+  info_ptr->processor_mhz_limit = static_cast<uint32_t>(speed / kOneMillion);
-   size = sizeof(speed);
-   sysctlbyname("hw.cpufrequency", &speed, &size, NULL, 0);
--  info_ptr->processor_current_mhz = static_cast<u_int32_t>(speed / kOneMillion);
-+  info_ptr->processor_current_mhz = static_cast<uint32_t>(speed / kOneMillion);
- 
-   return true;
- }
- 
- bool MinidumpGenerator::WriteBreakpadInfoStream(
-     MDRawDirectory *breakpad_info_stream) {
-   TypedMDRVA<MDRawBreakpadInfo> info(&writer_);
- 
-diff --git a/src/client/mac/handler/minidump_generator.h b/src/client/mac/handler/minidump_generator.h
---- a/src/client/mac/handler/minidump_generator.h
-+++ b/src/client/mac/handler/minidump_generator.h
-@@ -125,17 +125,17 @@
-   bool WriteThreadListStream(MDRawDirectory *thread_list_stream);
-   bool WriteMemoryListStream(MDRawDirectory *memory_list_stream);
-   bool WriteSystemInfoStream(MDRawDirectory *system_info_stream);
-   bool WriteModuleListStream(MDRawDirectory *module_list_stream);
-   bool WriteMiscInfoStream(MDRawDirectory *misc_info_stream);
-   bool WriteBreakpadInfoStream(MDRawDirectory *breakpad_info_stream);
- 
-   // Helpers
--  u_int64_t CurrentPCForStack(breakpad_thread_state_data_t state);
-+  uint64_t CurrentPCForStack(breakpad_thread_state_data_t state);
-   bool GetThreadState(thread_act_t target_thread, thread_state_t state,
-                       mach_msg_type_number_t *count);
-   bool WriteStackFromStartAddress(mach_vm_address_t start_addr,
-                                   MDMemoryDescriptor *stack_location);
-   bool WriteStack(breakpad_thread_state_data_t state,
-                   MDMemoryDescriptor *stack_location);
-   bool WriteContext(breakpad_thread_state_data_t state,
-                     MDLocationDescriptor *register_location);
-@@ -146,41 +146,41 @@
-   int  FindExecutableModule();
- 
-   // Per-CPU implementations of these methods
- #ifdef HAS_ARM_SUPPORT
-   bool WriteStackARM(breakpad_thread_state_data_t state,
-                      MDMemoryDescriptor *stack_location);
-   bool WriteContextARM(breakpad_thread_state_data_t state,
-                        MDLocationDescriptor *register_location);
--  u_int64_t CurrentPCForStackARM(breakpad_thread_state_data_t state);
-+  uint64_t CurrentPCForStackARM(breakpad_thread_state_data_t state);
- #endif
- #ifdef HAS_PPC_SUPPORT
-   bool WriteStackPPC(breakpad_thread_state_data_t state,
-                      MDMemoryDescriptor *stack_location);
-   bool WriteContextPPC(breakpad_thread_state_data_t state,
-                        MDLocationDescriptor *register_location);
--  u_int64_t CurrentPCForStackPPC(breakpad_thread_state_data_t state);
-+  uint64_t CurrentPCForStackPPC(breakpad_thread_state_data_t state);
-   bool WriteStackPPC64(breakpad_thread_state_data_t state,
-                        MDMemoryDescriptor *stack_location);
-   bool WriteContextPPC64(breakpad_thread_state_data_t state,
-                        MDLocationDescriptor *register_location);
--  u_int64_t CurrentPCForStackPPC64(breakpad_thread_state_data_t state);
-+  uint64_t CurrentPCForStackPPC64(breakpad_thread_state_data_t state);
- #endif
- #ifdef HAS_X86_SUPPORT
-   bool WriteStackX86(breakpad_thread_state_data_t state,
-                        MDMemoryDescriptor *stack_location);
-   bool WriteContextX86(breakpad_thread_state_data_t state,
-                        MDLocationDescriptor *register_location);
--  u_int64_t CurrentPCForStackX86(breakpad_thread_state_data_t state);
-+  uint64_t CurrentPCForStackX86(breakpad_thread_state_data_t state);
-   bool WriteStackX86_64(breakpad_thread_state_data_t state,
-                         MDMemoryDescriptor *stack_location);
-   bool WriteContextX86_64(breakpad_thread_state_data_t state,
-                           MDLocationDescriptor *register_location);
--  u_int64_t CurrentPCForStackX86_64(breakpad_thread_state_data_t state);
-+  uint64_t CurrentPCForStackX86_64(breakpad_thread_state_data_t state);
- #endif
- 
-   // disallow copy ctor and operator=
-   explicit MinidumpGenerator(const MinidumpGenerator &);
-   void operator=(const MinidumpGenerator &);
- 
-  protected:
-   // Use this writer to put the data to disk
-diff --git a/src/client/mac/tests/crash_generation_server_test.cc b/src/client/mac/tests/crash_generation_server_test.cc
---- a/src/client/mac/tests/crash_generation_server_test.cc
-+++ b/src/client/mac/tests/crash_generation_server_test.cc
-@@ -313,17 +313,17 @@
- 
- const MDCPUArchitecture kExpectedArchitecture =
- #if defined(__x86_64__)
-   MD_CPU_ARCHITECTURE_X86
- #elif defined(__i386__)
-   MD_CPU_ARCHITECTURE_AMD64
- #endif
-   ;
--const u_int32_t kExpectedContext =
-+const uint32_t kExpectedContext =
- #if defined(__i386__)
-   MD_CONTEXT_AMD64
- #elif defined(__x86_64__)
-   MD_CONTEXT_X86
- #endif
-   ;
- 
-   // Read the minidump, sanity check some data.
-diff --git a/src/client/mac/tests/exception_handler_test.cc b/src/client/mac/tests/exception_handler_test.cc
---- a/src/client/mac/tests/exception_handler_test.cc
-+++ b/src/client/mac/tests/exception_handler_test.cc
-@@ -272,17 +272,17 @@
- // to the dump as a MinidumpMemoryRegion.
- TEST_F(ExceptionHandlerTest, InstructionPointerMemory) {
-   // Give the child process a pipe to report back on.
-   int fds[2];
-   ASSERT_EQ(0, pipe(fds));
- 
-   // These are defined here so the parent can use them to check the
-   // data from the minidump afterwards.
--  const u_int32_t kMemorySize = 256;  // bytes
-+  const uint32_t kMemorySize = 256;  // bytes
-   const int kOffset = kMemorySize / 2;
-   // This crashes with SIGILL on x86/x86-64/arm.
-   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
- 
-   pid_t pid = fork();
-   if (pid == 0) {
-     close(fds[0]);
-     ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
-@@ -341,29 +341,29 @@
-   MinidumpMemoryList* memory_list = minidump.GetMemoryList();
-   ASSERT_TRUE(exception);
-   ASSERT_TRUE(memory_list);
-   ASSERT_NE((unsigned int)0, memory_list->region_count());
- 
-   MinidumpContext* context = exception->GetContext();
-   ASSERT_TRUE(context);
- 
--  u_int64_t instruction_pointer;
-+  uint64_t instruction_pointer;
-   ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
- 
-   MinidumpMemoryRegion* region =
-     memory_list->GetMemoryRegionForAddress(instruction_pointer);
-   EXPECT_TRUE(region);
- 
-   EXPECT_EQ(kMemorySize, region->GetSize());
--  const u_int8_t* bytes = region->GetMemory();
-+  const uint8_t* bytes = region->GetMemory();
-   ASSERT_TRUE(bytes);
- 
--  u_int8_t prefix_bytes[kOffset];
--  u_int8_t suffix_bytes[kMemorySize - kOffset - sizeof(instructions)];
-+  uint8_t prefix_bytes[kOffset];
-+  uint8_t suffix_bytes[kMemorySize - kOffset - sizeof(instructions)];
-   memset(prefix_bytes, 0, sizeof(prefix_bytes));
-   memset(suffix_bytes, 0, sizeof(suffix_bytes));
-   EXPECT_TRUE(memcmp(bytes, prefix_bytes, sizeof(prefix_bytes)) == 0);
-   EXPECT_TRUE(memcmp(bytes + kOffset, instructions, sizeof(instructions)) == 0);
-   EXPECT_TRUE(memcmp(bytes + kOffset + sizeof(instructions),
-                      suffix_bytes, sizeof(suffix_bytes)) == 0);
- }
- 
-@@ -371,17 +371,17 @@
- // bounded correctly on the low end.
- TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
-   // Give the child process a pipe to report back on.
-   int fds[2];
-   ASSERT_EQ(0, pipe(fds));
- 
-   // These are defined here so the parent can use them to check the
-   // data from the minidump afterwards.
--  const u_int32_t kMemorySize = 256;  // bytes
-+  const uint32_t kMemorySize = 256;  // bytes
-   const int kOffset = 0;
-   // This crashes with SIGILL on x86/x86-64/arm.
-   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
- 
-   pid_t pid = fork();
-   if (pid == 0) {
-     close(fds[0]);
-     ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
-@@ -440,28 +440,28 @@
-   MinidumpMemoryList* memory_list = minidump.GetMemoryList();
-   ASSERT_TRUE(exception);
-   ASSERT_TRUE(memory_list);
-   ASSERT_NE((unsigned int)0, memory_list->region_count());
- 
-   MinidumpContext* context = exception->GetContext();
-   ASSERT_TRUE(context);
- 
--  u_int64_t instruction_pointer;
-+  uint64_t instruction_pointer;
-   ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
- 
-   MinidumpMemoryRegion* region =
-     memory_list->GetMemoryRegionForAddress(instruction_pointer);
-   EXPECT_TRUE(region);
- 
-   EXPECT_EQ(kMemorySize / 2, region->GetSize());
--  const u_int8_t* bytes = region->GetMemory();
-+  const uint8_t* bytes = region->GetMemory();
-   ASSERT_TRUE(bytes);
- 
--  u_int8_t suffix_bytes[kMemorySize / 2 - sizeof(instructions)];
-+  uint8_t suffix_bytes[kMemorySize / 2 - sizeof(instructions)];
-   memset(suffix_bytes, 0, sizeof(suffix_bytes));
-   EXPECT_TRUE(memcmp(bytes + kOffset, instructions, sizeof(instructions)) == 0);
-   EXPECT_TRUE(memcmp(bytes + kOffset + sizeof(instructions),
-                      suffix_bytes, sizeof(suffix_bytes)) == 0);
- }
- 
- // Test that the memory region around the instruction pointer is
- // bounded correctly on the high end.
-@@ -470,17 +470,17 @@
-   int fds[2];
-   ASSERT_EQ(0, pipe(fds));
- 
-   // These are defined here so the parent can use them to check the
-   // data from the minidump afterwards.
-   // Use 4k here because the OS will hand out a single page even
-   // if a smaller size is requested, and this test wants to
-   // test the upper bound of the memory range.
--  const u_int32_t kMemorySize = 4096;  // bytes
-+  const uint32_t kMemorySize = 4096;  // bytes
-   // This crashes with SIGILL on x86/x86-64/arm.
-   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
-   const int kOffset = kMemorySize - sizeof(instructions);
- 
-   pid_t pid = fork();
-   if (pid == 0) {
-     close(fds[0]);
-     ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
-@@ -539,29 +539,29 @@
-   MinidumpMemoryList* memory_list = minidump.GetMemoryList();
-   ASSERT_TRUE(exception);
-   ASSERT_TRUE(memory_list);
-   ASSERT_NE((unsigned int)0, memory_list->region_count());
- 
-   MinidumpContext* context = exception->GetContext();
-   ASSERT_TRUE(context);
- 
--  u_int64_t instruction_pointer;
-+  uint64_t instruction_pointer;
-   ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
- 
-   MinidumpMemoryRegion* region =
-     memory_list->GetMemoryRegionForAddress(instruction_pointer);
-   EXPECT_TRUE(region);
- 
-   const size_t kPrefixSize = 128;  // bytes
-   EXPECT_EQ(kPrefixSize + sizeof(instructions), region->GetSize());
--  const u_int8_t* bytes = region->GetMemory();
-+  const uint8_t* bytes = region->GetMemory();
-   ASSERT_TRUE(bytes);
- 
--  u_int8_t prefix_bytes[kPrefixSize];
-+  uint8_t prefix_bytes[kPrefixSize];
-   memset(prefix_bytes, 0, sizeof(prefix_bytes));
-   EXPECT_TRUE(memcmp(bytes, prefix_bytes, sizeof(prefix_bytes)) == 0);
-   EXPECT_TRUE(memcmp(bytes + kPrefixSize,
-                      instructions, sizeof(instructions)) == 0);
- }
- 
- // Ensure that an extra memory block doesn't get added when the
- // instruction pointer is not in mapped memory.
-diff --git a/src/client/mac/tests/minidump_generator_test.cc b/src/client/mac/tests/minidump_generator_test.cc
---- a/src/client/mac/tests/minidump_generator_test.cc
-+++ b/src/client/mac/tests/minidump_generator_test.cc
-@@ -275,17 +275,17 @@
- 
- const MDCPUArchitecture kExpectedArchitecture =
- #if defined(__x86_64__)
-   MD_CPU_ARCHITECTURE_X86
- #elif defined(__i386__)
-   MD_CPU_ARCHITECTURE_AMD64
- #endif
-   ;
--const u_int32_t kExpectedContext =
-+const uint32_t kExpectedContext =
- #if defined(__i386__)
-   MD_CONTEXT_AMD64
- #elif defined(__x86_64__)
-   MD_CONTEXT_X86
- #endif
-   ;
- 
-   // Read the minidump, sanity check some data.
-diff --git a/src/client/mac/tests/spawn_child_process.h b/src/client/mac/tests/spawn_child_process.h
---- a/src/client/mac/tests/spawn_child_process.h
-+++ b/src/client/mac/tests/spawn_child_process.h
-@@ -60,17 +60,17 @@
-   MD_CPU_ARCHITECTURE_AMD64
- #elif defined(__ppc__) || defined(__ppc64__)
-   MD_CPU_ARCHITECTURE_PPC
- #else
- #error "This file has not been ported to this CPU architecture."
- #endif
-   ;
- 
--const u_int32_t kNativeContext =
-+const uint32_t kNativeContext =
- #if defined(__i386__)
-   MD_CONTEXT_X86
- #elif defined(__x86_64__)
-   MD_CONTEXT_AMD64
- #elif defined(__ppc__) || defined(__ppc64__)
-   MD_CONTEXT_PPC
- #else
- #error "This file has not been ported to this CPU architecture."
-diff --git a/src/client/minidump_file_writer.cc b/src/client/minidump_file_writer.cc
---- a/src/client/minidump_file_writer.cc
-+++ b/src/client/minidump_file_writer.cc
-@@ -94,65 +94,65 @@
- 
-   return result;
- }
- 
- bool MinidumpFileWriter::CopyStringToMDString(const wchar_t *str,
-                                               unsigned int length,
-                                               TypedMDRVA<MDString> *mdstring) {
-   bool result = true;
--  if (sizeof(wchar_t) == sizeof(u_int16_t)) {
-+  if (sizeof(wchar_t) == sizeof(uint16_t)) {
-     // Shortcut if wchar_t is the same size as MDString's buffer
-     result = mdstring->Copy(str, mdstring->get()->length);
-   } else {
--    u_int16_t out[2];
-+    uint16_t out[2];
-     int out_idx = 0;
- 
-     // Copy the string character by character
-     while (length && result) {
-       UTF32ToUTF16Char(*str, out);
-       if (!out[0])
-         return false;
- 
-       // Process one character at a time
-       --length;
-       ++str;
- 
-       // Append the one or two UTF-16 characters.  The first one will be non-
-       // zero, but the second one may be zero, depending on the conversion from
-       // UTF-32.
-       int out_count = out[1] ? 2 : 1;
--      size_t out_size = sizeof(u_int16_t) * out_count;
-+      size_t out_size = sizeof(uint16_t) * out_count;
-       result = mdstring->CopyIndexAfterObject(out_idx, out, out_size);
-       out_idx += out_count;
-     }
-   }
-   return result;
- }
- 
- bool MinidumpFileWriter::CopyStringToMDString(const char *str,
-                                               unsigned int length,
-                                               TypedMDRVA<MDString> *mdstring) {
-   bool result = true;
--  u_int16_t out[2];
-+  uint16_t out[2];
-   int out_idx = 0;
- 
-   // Copy the string character by character
-   while (length && result) {
-     int conversion_count = UTF8ToUTF16Char(str, length, out);
-     if (!conversion_count)
-       return false;
- 
-     // Move the pointer along based on the nubmer of converted characters
-     length -= conversion_count;
-     str += conversion_count;
- 
-     // Append the one or two UTF-16 characters
-     int out_count = out[1] ? 2 : 1;
--    size_t out_size = sizeof(u_int16_t) * out_count;
-+    size_t out_size = sizeof(uint16_t) * out_count;
-     result = mdstring->CopyIndexAfterObject(out_idx, out, out_size);
-     out_idx += out_count;
-   }
-   return result;
- }
- 
- template <typename CharType>
- bool MinidumpFileWriter::WriteStringCore(const CharType *str,
-@@ -165,27 +165,27 @@
-   unsigned int mdstring_length = 0;
-   if (!length)
-     length = INT_MAX;
-   for (; mdstring_length < length && str[mdstring_length]; ++mdstring_length)
-     ;
- 
-   // Allocate the string buffer
-   TypedMDRVA<MDString> mdstring(this);
--  if (!mdstring.AllocateObjectAndArray(mdstring_length + 1, sizeof(u_int16_t)))
-+  if (!mdstring.AllocateObjectAndArray(mdstring_length + 1, sizeof(uint16_t)))
-     return false;
- 
-   // Set length excluding the NULL and copy the string
-   mdstring.get()->length =
--      static_cast<u_int32_t>(mdstring_length * sizeof(u_int16_t));
-+      static_cast<uint32_t>(mdstring_length * sizeof(uint16_t));
-   bool result = CopyStringToMDString(str, mdstring_length, &mdstring);
- 
-   // NULL terminate
-   if (result) {
--    u_int16_t ch = 0;
-+    uint16_t ch = 0;
-     result = mdstring.CopyIndexAfterObject(mdstring_length, &ch, sizeof(ch));
- 
-     if (result)
-       *location = mdstring.location();
-   }
- 
-   return result;
- }
-@@ -206,17 +206,17 @@
-   assert(output);
-   UntypedMDRVA mem(this);
- 
-   if (!mem.Allocate(size))
-     return false;
-   if (!mem.Copy(src, mem.size()))
-     return false;
- 
--  output->start_of_memory_range = reinterpret_cast<u_int64_t>(src);
-+  output->start_of_memory_range = reinterpret_cast<uint64_t>(src);
-   output->memory = mem.location();
- 
-   return true;
- }
- 
- MDRVA MinidumpFileWriter::Allocate(size_t size) {
-   assert(size);
-   assert(file_ != -1);
-diff --git a/src/client/minidump_file_writer.h b/src/client/minidump_file_writer.h
---- a/src/client/minidump_file_writer.h
-+++ b/src/client/minidump_file_writer.h
-@@ -167,17 +167,17 @@
-   // Returns the current position or kInvalidMDRVA if allocation failed
-   inline MDRVA position() const { return position_; }
- 
-   // Number of bytes allocated
-   inline size_t size() const { return size_; }
- 
-   // Return size and position
-   inline MDLocationDescriptor location() const {
--    MDLocationDescriptor location = { static_cast<u_int32_t>(size_),
-+    MDLocationDescriptor location = { static_cast<uint32_t>(size_),
-                                       position_ };
-     return location;
-   }
- 
-   // Copy |size| bytes starting at |src| into the minidump at |position|
-   // Return true on success, or false on failure
-   bool Copy(MDRVA position, const void *src, size_t size);
- 
-diff --git a/src/client/solaris/handler/minidump_generator.cc b/src/client/solaris/handler/minidump_generator.cc
---- a/src/client/solaris/handler/minidump_generator.cc
-+++ b/src/client/solaris/handler/minidump_generator.cc
-@@ -450,17 +450,17 @@
-                    char *realname) {
-   TypedMDRVA<MDCVInfoPDB70> cv(minidump_writer);
- 
-   char path[PATH_MAX];
-   const char *module_name = module_path ? module_path : "<Unknown>";
-   snprintf(path, sizeof(path), "/proc/self/object/%s", module_name);
- 
-   size_t module_name_length = strlen(realname);
--  if (!cv.AllocateObjectAndArray(module_name_length + 1, sizeof(u_int8_t)))
-+  if (!cv.AllocateObjectAndArray(module_name_length + 1, sizeof(uint8_t)))
-     return false;
-   if (!cv.CopyIndexAfterObject(0, realname, module_name_length))
-     return false;
- 
-   module->cv_record = cv.location();
-   MDCVInfoPDB70 *cv_ptr = cv.get();
-   memset(cv_ptr, 0, sizeof(MDCVInfoPDB70));
-   cv_ptr->cv_signature = MD_CVINFOPDB70_SIGNATURE;
-@@ -517,17 +517,17 @@
- 
-   if ((realname = strrchr(buf, '/')) == NULL)
-     return false;
-   realname++;
- 
-   if (!callback_context->minidump_writer->WriteString(realname, 0, &loc))
-     return false;
- 
--  module.base_of_image = (u_int64_t)module_info.start_addr;
-+  module.base_of_image = (uint64_t)module_info.start_addr;
-   module.size_of_image = module_info.size;
-   module.module_name_rva = loc.rva;
- 
-   if (!WriteCVRecord(callback_context->minidump_writer, &module,
-                      module_info.name, realname))
-     return false;
- 
-   callback_context->list->CopyIndexAfterObject(
-diff --git a/src/client/windows/crash_generation/minidump_generator.h b/src/client/windows/crash_generation/minidump_generator.h
-old mode 100644
-new mode 100755
---- a/src/client/windows/crash_generation/minidump_generator.h
-+++ b/src/client/windows/crash_generation/minidump_generator.h
-@@ -27,16 +27,17 @@
- // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- 
- #ifndef CLIENT_WINDOWS_CRASH_GENERATION_MINIDUMP_GENERATOR_H_
- #define CLIENT_WINDOWS_CRASH_GENERATION_MINIDUMP_GENERATOR_H_
- 
- #include <windows.h>
- #include <dbghelp.h>
-+#include <rpc.h>
- #include <list>
- #include "google_breakpad/common/minidump_format.h"
- 
- namespace google_breakpad {
- 
- // Abstraction for various objects and operations needed to generate
- // minidump on Windows. This abstraction is useful to hide all the gory
- // details for minidump generation and provide a clean interface to
-diff --git a/src/client/windows/unittests/exception_handler_death_test.cc b/src/client/windows/unittests/exception_handler_death_test.cc
---- a/src/client/windows/unittests/exception_handler_death_test.cc
-+++ b/src/client/windows/unittests/exception_handler_death_test.cc
-@@ -260,17 +260,17 @@
-       new google_breakpad::ExceptionHandler(
-           temp_path_, NULL, NULL, NULL,
-           google_breakpad::ExceptionHandler::HANDLER_ALL);
- 
-   // Disable GTest SEH handler
-   testing::DisableExceptionHandlerInScope disable_exception_handler;
- 
-   // Get some executable memory.
--  const u_int32_t kMemorySize = 256;  // bytes
-+  const uint32_t kMemorySize = 256;  // bytes
-   const int kOffset = kMemorySize / 2;
-   // This crashes with SIGILL on x86/x86-64/arm.
-   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
-   char* memory = reinterpret_cast<char*>(VirtualAlloc(NULL,
-                                                       kMemorySize,
-                                                       MEM_COMMIT | MEM_RESERVE,
-                                                       PAGE_EXECUTE_READWRITE));
-   ASSERT_TRUE(memory);
-@@ -309,29 +309,29 @@
-     MinidumpMemoryList* memory_list = minidump.GetMemoryList();
-     ASSERT_TRUE(exception);
-     ASSERT_TRUE(memory_list);
-     ASSERT_LT((unsigned)0, memory_list->region_count());
- 
-     MinidumpContext* context = exception->GetContext();
-     ASSERT_TRUE(context);
- 
--    u_int64_t instruction_pointer;
-+    uint64_t instruction_pointer;
-     ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
- 
-     MinidumpMemoryRegion* region =
-         memory_list->GetMemoryRegionForAddress(instruction_pointer);
-     ASSERT_TRUE(region);
- 
-     EXPECT_EQ(kMemorySize, region->GetSize());
--    const u_int8_t* bytes = region->GetMemory();
-+    const uint8_t* bytes = region->GetMemory();
-     ASSERT_TRUE(bytes);
- 
--    u_int8_t prefix_bytes[kOffset];
--    u_int8_t suffix_bytes[kMemorySize - kOffset - sizeof(instructions)];
-+    uint8_t prefix_bytes[kOffset];
-+    uint8_t suffix_bytes[kMemorySize - kOffset - sizeof(instructions)];
-     memset(prefix_bytes, 0, sizeof(prefix_bytes));
-     memset(suffix_bytes, 0, sizeof(suffix_bytes));
-     EXPECT_TRUE(memcmp(bytes, prefix_bytes, sizeof(prefix_bytes)) == 0);
-     EXPECT_TRUE(memcmp(bytes + kOffset, instructions,
-                        sizeof(instructions)) == 0);
-     EXPECT_TRUE(memcmp(bytes + kOffset + sizeof(instructions),
-                        suffix_bytes, sizeof(suffix_bytes)) == 0);
-   }
-@@ -347,17 +347,17 @@
-           google_breakpad::ExceptionHandler::HANDLER_ALL);
- 
-   // Disable GTest SEH handler
-   testing::DisableExceptionHandlerInScope disable_exception_handler;
- 
-   SYSTEM_INFO sSysInfo;         // Useful information about the system
-   GetSystemInfo(&sSysInfo);     // Initialize the structure.
- 
--  const u_int32_t kMemorySize = 256;  // bytes
-+  const uint32_t kMemorySize = 256;  // bytes
-   const DWORD kPageSize = sSysInfo.dwPageSize;
-   const int kOffset = 0;
-   // This crashes with SIGILL on x86/x86-64/arm.
-   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
-   // Get some executable memory. Specifically, reserve two pages,
-   // but only commit the second.
-   char* all_memory = reinterpret_cast<char*>(VirtualAlloc(NULL,
-                                                           kPageSize * 2,
-@@ -402,28 +402,28 @@
-     MinidumpMemoryList* memory_list = minidump.GetMemoryList();
-     ASSERT_TRUE(exception);
-     ASSERT_TRUE(memory_list);
-     ASSERT_LT((unsigned)0, memory_list->region_count());
- 
-     MinidumpContext* context = exception->GetContext();
-     ASSERT_TRUE(context);
- 
--    u_int64_t instruction_pointer;
-+    uint64_t instruction_pointer;
-     ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
- 
-     MinidumpMemoryRegion* region =
-         memory_list->GetMemoryRegionForAddress(instruction_pointer);
-     ASSERT_TRUE(region);
- 
-     EXPECT_EQ(kMemorySize / 2, region->GetSize());
--    const u_int8_t* bytes = region->GetMemory();
-+    const uint8_t* bytes = region->GetMemory();
-     ASSERT_TRUE(bytes);
- 
--    u_int8_t suffix_bytes[kMemorySize / 2 - sizeof(instructions)];
-+    uint8_t suffix_bytes[kMemorySize / 2 - sizeof(instructions)];
-     memset(suffix_bytes, 0, sizeof(suffix_bytes));
-     EXPECT_TRUE(memcmp(bytes + kOffset,
-                        instructions, sizeof(instructions)) == 0);
-     EXPECT_TRUE(memcmp(bytes + kOffset + sizeof(instructions),
-                        suffix_bytes, sizeof(suffix_bytes)) == 0);
-   }
- 
-   DeleteFileW(minidump_filename_wide.c_str());
-@@ -487,29 +487,29 @@
-     MinidumpMemoryList* memory_list = minidump.GetMemoryList();
-     ASSERT_TRUE(exception);
-     ASSERT_TRUE(memory_list);
-     ASSERT_LT((unsigned)0, memory_list->region_count());
- 
-     MinidumpContext* context = exception->GetContext();
-     ASSERT_TRUE(context);
- 
--    u_int64_t instruction_pointer;
-+    uint64_t instruction_pointer;
-     ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
- 
-     MinidumpMemoryRegion* region =
-         memory_list->GetMemoryRegionForAddress(instruction_pointer);
-     ASSERT_TRUE(region);
- 
-     const size_t kPrefixSize = 128;  // bytes
-     EXPECT_EQ(kPrefixSize + sizeof(instructions), region->GetSize());
--    const u_int8_t* bytes = region->GetMemory();
-+    const uint8_t* bytes = region->GetMemory();
-     ASSERT_TRUE(bytes);
- 
--    u_int8_t prefix_bytes[kPrefixSize];
-+    uint8_t prefix_bytes[kPrefixSize];
-     memset(prefix_bytes, 0, sizeof(prefix_bytes));
-     EXPECT_TRUE(memcmp(bytes, prefix_bytes, sizeof(prefix_bytes)) == 0);
-     EXPECT_TRUE(memcmp(bytes + kPrefixSize,
-                        instructions, sizeof(instructions)) == 0);
-   }
- 
-   DeleteFileW(minidump_filename_wide.c_str());
- }
-diff --git a/src/client/windows/unittests/exception_handler_test.cc b/src/client/windows/unittests/exception_handler_test.cc
---- a/src/client/windows/unittests/exception_handler_test.cc
-+++ b/src/client/windows/unittests/exception_handler_test.cc
-@@ -392,25 +392,25 @@
-   ASSERT_TRUE(minidump.Read());
-   //TODO(ted): more comprehensive tests...
- }
- 
- // Test that an additional memory region can be included in the minidump.
- TEST_F(ExceptionHandlerTest, AdditionalMemory) {
-   SYSTEM_INFO si;
-   GetSystemInfo(&si);
--  const u_int32_t kMemorySize = si.dwPageSize;
-+  const uint32_t kMemorySize = si.dwPageSize;
- 
-   // Get some heap memory.
--  u_int8_t* memory = new u_int8_t[kMemorySize];
-+  uint8_t* memory = new uint8_t[kMemorySize];
-   const uintptr_t kMemoryAddress = reinterpret_cast<uintptr_t>(memory);
-   ASSERT_TRUE(memory);
- 
-   // Stick some data into the memory so the contents can be verified.
--  for (u_int32_t i = 0; i < kMemorySize; ++i) {
-+  for (uint32_t i = 0; i < kMemorySize; ++i) {
-     memory[i] = i % 255;
-   }
- 
-   ExceptionHandler handler(temp_path_,
-                            NULL,
-                            DumpCallback,
-                            NULL,
-                            ExceptionHandler::HANDLER_ALL);
-@@ -446,25 +446,25 @@
-   delete[] memory;
- }
- 
- // Test that a memory region that was previously registered
- // can be unregistered.
- TEST_F(ExceptionHandlerTest, AdditionalMemoryRemove) {
-   SYSTEM_INFO si;
-   GetSystemInfo(&si);
--  const u_int32_t kMemorySize = si.dwPageSize;
-+  const uint32_t kMemorySize = si.dwPageSize;
- 
-   // Get some heap memory.
--  u_int8_t* memory = new u_int8_t[kMemorySize];
-+  uint8_t* memory = new uint8_t[kMemorySize];
-   const uintptr_t kMemoryAddress = reinterpret_cast<uintptr_t>(memory);
-   ASSERT_TRUE(memory);
- 
-   // Stick some data into the memory so the contents can be verified.
--  for (u_int32_t i = 0; i < kMemorySize; ++i) {
-+  for (uint32_t i = 0; i < kMemorySize; ++i) {
-     memory[i] = i % 255;
-   }
- 
-   ExceptionHandler handler(temp_path_,
-                            NULL,
-                            DumpCallback,
-                            NULL,
-                            ExceptionHandler::HANDLER_ALL);
-diff --git a/src/common/dwarf/cfi_assembler.cc b/src/common/dwarf/cfi_assembler.cc
---- a/src/common/dwarf/cfi_assembler.cc
-+++ b/src/common/dwarf/cfi_assembler.cc
-@@ -36,20 +36,20 @@
- 
- #include <assert.h>
- #include <stdlib.h>
- 
- namespace google_breakpad {
- 
- using dwarf2reader::DwarfPointerEncoding;
-   
--CFISection &CFISection::CIEHeader(u_int64_t code_alignment_factor,
-+CFISection &CFISection::CIEHeader(uint64_t code_alignment_factor,
-                                   int data_alignment_factor,
-                                   unsigned return_address_register,
--                                  u_int8_t version,
-+                                  uint8_t version,
-                                   const string &augmentation,
-                                   bool dwarf64) {
-   assert(!entry_length_);
-   entry_length_ = new PendingLength();
-   in_fde_ = false;
- 
-   if (dwarf64) {
-     D32(kDwarf64InitialLengthMarker);
-@@ -68,18 +68,18 @@
-   if (version == 1)
-     D8(return_address_register);
-   else
-     ULEB128(return_address_register);
-   return *this;
- }
- 
- CFISection &CFISection::FDEHeader(Label cie_pointer,
--                                  u_int64_t initial_location,
--                                  u_int64_t address_range,
-+                                  uint64_t initial_location,
-+                                  uint64_t address_range,
-                                   bool dwarf64) {
-   assert(!entry_length_);
-   entry_length_ = new PendingLength();
-   in_fde_ = true;
-   fde_start_address_ = initial_location;
- 
-   if (dwarf64) {
-     D32(0xffffffff);
-@@ -112,31 +112,31 @@
-   Align(address_size_, dwarf2reader::DW_CFA_nop);
-   entry_length_->length = Here() - entry_length_->start;
-   delete entry_length_;
-   entry_length_ = NULL;
-   in_fde_ = false;
-   return *this;
- }
- 
--CFISection &CFISection::EncodedPointer(u_int64_t address,
-+CFISection &CFISection::EncodedPointer(uint64_t address,
-                                        DwarfPointerEncoding encoding,
-                                        const EncodedPointerBases &bases) {
-   // Omitted data is extremely easy to emit.
-   if (encoding == dwarf2reader::DW_EH_PE_omit)
-     return *this;
- 
-   // If (encoding & dwarf2reader::DW_EH_PE_indirect) != 0, then we assume
-   // that ADDRESS is the address at which the pointer is stored --- in
-   // other words, that bit has no effect on how we write the pointer.
-   encoding = DwarfPointerEncoding(encoding & ~dwarf2reader::DW_EH_PE_indirect);
- 
-   // Find the base address to which this pointer is relative. The upper
-   // nybble of the encoding specifies this.
--  u_int64_t base;
-+  uint64_t base;
-   switch (encoding & 0xf0) {
-     case dwarf2reader::DW_EH_PE_absptr:  base = 0;                  break;
-     case dwarf2reader::DW_EH_PE_pcrel:   base = bases.cfi + Size(); break;
-     case dwarf2reader::DW_EH_PE_textrel: base = bases.text;         break;
-     case dwarf2reader::DW_EH_PE_datarel: base = bases.data;         break;
-     case dwarf2reader::DW_EH_PE_funcrel: base = fde_start_address_; break;
-     case dwarf2reader::DW_EH_PE_aligned: base = 0;                  break;
-     default: abort();
-@@ -184,15 +184,15 @@
- 
-     default:
-       abort();
-   }
- 
-   return *this;
- };
- 
--const u_int32_t CFISection::kDwarf64InitialLengthMarker;
--const u_int32_t CFISection::kDwarf32CIEIdentifier;
--const u_int64_t CFISection::kDwarf64CIEIdentifier;
--const u_int32_t CFISection::kEHFrame32CIEIdentifier;
--const u_int64_t CFISection::kEHFrame64CIEIdentifier;
-+const uint32_t CFISection::kDwarf64InitialLengthMarker;
-+const uint32_t CFISection::kDwarf32CIEIdentifier;
-+const uint64_t CFISection::kDwarf64CIEIdentifier;
-+const uint32_t CFISection::kEHFrame32CIEIdentifier;
-+const uint64_t CFISection::kEHFrame64CIEIdentifier;
- 
- } // namespace google_breakpad
-diff --git a/src/common/dwarf/cfi_assembler.h b/src/common/dwarf/cfi_assembler.h
---- a/src/common/dwarf/cfi_assembler.h
-+++ b/src/common/dwarf/cfi_assembler.h
-@@ -75,24 +75,24 @@
-   // addresses it should use; you can establish a default for all encoded
-   // pointers appended to this section with SetEncodedPointerBases.
-   struct EncodedPointerBases {
-     EncodedPointerBases() : cfi(), text(), data() { }
- 
-     // The starting address of this CFI section in memory, for
-     // DW_EH_PE_pcrel. DW_EH_PE_pcrel pointers may only be used in data
-     // that has is loaded into the program's address space.
--    u_int64_t cfi;
-+    uint64_t cfi;
- 
-     // The starting address of this file's .text section, for DW_EH_PE_textrel.
--    u_int64_t text;
-+    uint64_t text;
- 
-     // The starting address of this file's .got or .eh_frame_hdr section,
-     // for DW_EH_PE_datarel.
--    u_int64_t data;
-+    uint64_t data;
-   };
- 
-   // Create a CFISection whose endianness is ENDIANNESS, and where
-   // machine addresses are ADDRESS_SIZE bytes long. If EH_FRAME is
-   // true, use the .eh_frame format, as described by the Linux
-   // Standards Base Core Specification, instead of the DWARF CFI
-   // format.
-   CFISection(Endianness endianness, size_t address_size,
-@@ -128,36 +128,36 @@
-   // given values. If dwarf64 is true, use the 64-bit DWARF initial
-   // length format for the CIE's initial length. Return a reference to
-   // this section. You should call FinishEntry after writing the last
-   // instruction for the CIE.
-   //
-   // Before calling this function, you will typically want to use Mark
-   // or Here to make a label to pass to FDEHeader that refers to this
-   // CIE's position in the section.
--  CFISection &CIEHeader(u_int64_t code_alignment_factor,
-+  CFISection &CIEHeader(uint64_t code_alignment_factor,
-                         int data_alignment_factor,
-                         unsigned return_address_register,
--                        u_int8_t version = 3,
-+                        uint8_t version = 3,
-                         const string &augmentation = "",
-                         bool dwarf64 = false);
- 
-   // Append a Frame Description Entry header to this section with the
-   // given values. If dwarf64 is true, use the 64-bit DWARF initial
-   // length format for the CIE's initial length. Return a reference to
-   // this section. You should call FinishEntry after writing the last
-   // instruction for the CIE.
-   //
-   // This function doesn't support entries that are longer than
-   // 0xffffff00 bytes. (The "initial length" is always a 32-bit
-   // value.) Nor does it support .debug_frame sections longer than
-   // 0xffffff00 bytes.
-   CFISection &FDEHeader(Label cie_pointer,
--                        u_int64_t initial_location,
--                        u_int64_t address_range,
-+                        uint64_t initial_location,
-+                        uint64_t address_range,
-                         bool dwarf64 = false);
- 
-   // Note the current position as the end of the last CIE or FDE we
-   // started, after padding with DW_CFA_nops for alignment. This
-   // defines the label representing the entry's length, cited in the
-   // entry's header. Return a reference to this section.
-   CFISection &FinishEntry();
- 
-@@ -166,17 +166,17 @@
-   CFISection &Block(const string &block) {
-     ULEB128(block.size());
-     Append(block);
-     return *this;
-   }
- 
-   // Append ADDRESS to this section, in the appropriate size and
-   // endianness. Return a reference to this section.
--  CFISection &Address(u_int64_t address) {
-+  CFISection &Address(uint64_t address) {
-     Section::Append(endianness(), address_size_, address);
-     return *this;
-   }
-   CFISection &Address(Label address) {
-     Section::Append(endianness(), address_size_, address);
-     return *this;
-   }
- 
-@@ -184,58 +184,58 @@
-   // defaults to this section's default encoding, established by
-   // SetPointerEncoding. BASES defaults to this section's bases, set by
-   // SetEncodedPointerBases. If the DW_EH_PE_indirect bit is set in the
-   // encoding, assume that ADDRESS is where the true address is stored.
-   // Return a reference to this section.
-   // 
-   // (C++ doesn't let me use default arguments here, because I want to
-   // refer to members of *this in the default argument expression.)
--  CFISection &EncodedPointer(u_int64_t address) {
-+  CFISection &EncodedPointer(uint64_t address) {
-     return EncodedPointer(address, pointer_encoding_, encoded_pointer_bases_);
-   }
--  CFISection &EncodedPointer(u_int64_t address, DwarfPointerEncoding encoding) {
-+  CFISection &EncodedPointer(uint64_t address, DwarfPointerEncoding encoding) {
-     return EncodedPointer(address, encoding, encoded_pointer_bases_);
-   }
--  CFISection &EncodedPointer(u_int64_t address, DwarfPointerEncoding encoding,
-+  CFISection &EncodedPointer(uint64_t address, DwarfPointerEncoding encoding,
-                              const EncodedPointerBases &bases);
- 
-   // Restate some member functions, to keep chaining working nicely.
-   CFISection &Mark(Label *label)   { Section::Mark(label); return *this; }
--  CFISection &D8(u_int8_t v)       { Section::D8(v);       return *this; }
--  CFISection &D16(u_int16_t v)     { Section::D16(v);      return *this; }
-+  CFISection &D8(uint8_t v)       { Section::D8(v);       return *this; }
-+  CFISection &D16(uint16_t v)     { Section::D16(v);      return *this; }
-   CFISection &D16(Label v)         { Section::D16(v);      return *this; }
--  CFISection &D32(u_int32_t v)     { Section::D32(v);      return *this; }
-+  CFISection &D32(uint32_t v)     { Section::D32(v);      return *this; }
-   CFISection &D32(const Label &v)  { Section::D32(v);      return *this; }
--  CFISection &D64(u_int64_t v)     { Section::D64(v);      return *this; }
-+  CFISection &D64(uint64_t v)     { Section::D64(v);      return *this; }
-   CFISection &D64(const Label &v)  { Section::D64(v);      return *this; }
-   CFISection &LEB128(long long v)  { Section::LEB128(v);   return *this; }
--  CFISection &ULEB128(u_int64_t v) { Section::ULEB128(v);  return *this; }
-+  CFISection &ULEB128(uint64_t v) { Section::ULEB128(v);  return *this; }
- 
-  private:
-   // A length value that we've appended to the section, but is not yet
-   // known. LENGTH is the appended value; START is a label referring
-   // to the start of the data whose length was cited.
-   struct PendingLength {
-     Label length;
-     Label start;
-   };
- 
-   // Constants used in CFI/.eh_frame data:
- 
-   // If the first four bytes of an "initial length" are this constant, then
-   // the data uses the 64-bit DWARF format, and the length itself is the
-   // subsequent eight bytes.
--  static const u_int32_t kDwarf64InitialLengthMarker = 0xffffffffU;
-+  static const uint32_t kDwarf64InitialLengthMarker = 0xffffffffU;
- 
-   // The CIE identifier for 32- and 64-bit DWARF CFI and .eh_frame data.
--  static const u_int32_t kDwarf32CIEIdentifier = ~(u_int32_t)0;
--  static const u_int64_t kDwarf64CIEIdentifier = ~(u_int64_t)0;
--  static const u_int32_t kEHFrame32CIEIdentifier = 0;
--  static const u_int64_t kEHFrame64CIEIdentifier = 0;
-+  static const uint32_t kDwarf32CIEIdentifier = ~(uint32_t)0;
-+  static const uint64_t kDwarf64CIEIdentifier = ~(uint64_t)0;
-+  static const uint32_t kEHFrame32CIEIdentifier = 0;
-+  static const uint64_t kEHFrame64CIEIdentifier = 0;
- 
-   // The size of a machine address for the data in this section.
-   size_t address_size_;
- 
-   // If true, we are generating a Linux .eh_frame section, instead of
-   // a standard DWARF .debug_frame section.
-   bool eh_frame_;
- 
-@@ -256,14 +256,14 @@
-   PendingLength *entry_length_;
- 
-   // True if we are currently emitting an FDE --- that is, we have
-   // called FDEHeader but have not yet called FinishEntry.
-   bool in_fde_;
- 
-   // If in_fde_ is true, this is its starting address. We use this for
-   // emitting DW_EH_PE_funcrel pointers.
--  u_int64_t fde_start_address_;
-+  uint64_t fde_start_address_;
- };
- 
- }  // namespace google_breakpad
- 
- #endif  // PROCESSOR_CFI_ASSEMBLER_H_
-diff --git a/src/common/dwarf/dwarf2reader_cfi_unittest.cc b/src/common/dwarf/dwarf2reader_cfi_unittest.cc
---- a/src/common/dwarf/dwarf2reader_cfi_unittest.cc
-+++ b/src/common/dwarf/dwarf2reader_cfi_unittest.cc
-@@ -2321,24 +2321,24 @@
- using google_breakpad::test_assembler::Section;
- 
- struct ELFSectionHeader {
-   ELFSectionHeader(unsigned int set_type)
-       : type(set_type), flags(0), address(0), link(0), info(0),
-         alignment(1), entry_size(0) { }
-   Label name;
-   unsigned int type;
--  u_int64_t flags;
--  u_int64_t address;
-+  uint64_t flags;
-+  uint64_t address;
-   Label file_offset;
-   Label file_size;
-   unsigned int link;
-   unsigned int info;
--  u_int64_t alignment;
--  u_int64_t entry_size;
-+  uint64_t alignment;
-+  uint64_t entry_size;
- };
- 
- void AppendSectionHeader(CFISection *table, const ELFSectionHeader &header) {
-   (*table)
-       .D32(header.name)                   // name, index in string tbl
-       .D32(header.type)                   // type
-       .Address(header.flags)              // flags
-       .Address(header.address)            // address in memory
-diff --git a/src/common/dwarf/dwarf2reader_die_unittest.cc b/src/common/dwarf/dwarf2reader_die_unittest.cc
---- a/src/common/dwarf/dwarf2reader_die_unittest.cc
-+++ b/src/common/dwarf/dwarf2reader_die_unittest.cc
-@@ -284,17 +284,17 @@
- 
- struct DwarfForms: public DwarfFormsFixture,
-                    public TestWithParam<DwarfHeaderParams> { };
- 
- TEST_P(DwarfForms, addr) {
-   StartSingleAttributeDIE(GetParam(), dwarf2reader::DW_TAG_compile_unit,
-                           dwarf2reader::DW_AT_low_pc,
-                           dwarf2reader::DW_FORM_addr);
--  u_int64_t value;
-+  uint64_t value;
-   if (GetParam().address_size == 4) {
-     value = 0xc8e9ffcc;
-     info.D32(value);
-   } else {
-     value = 0xe942517fc2768564ULL;
-     info.D64(value);
-   }
-   info.Finish();
-@@ -367,17 +367,17 @@
- 
-   ParseCompilationUnit(GetParam());
- }
- 
- TEST_P(DwarfForms, sec_offset) {
-   StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x1d971689,
-                           (DwarfAttribute) 0xa060bfd1,
-                           dwarf2reader::DW_FORM_sec_offset);
--  u_int64_t value;
-+  uint64_t value;
-   if (GetParam().format_size == 4) {
-     value = 0xacc9c388;
-     info.D32(value);
-   } else {
-     value = 0xcffe5696ffe3ed0aULL;
-     info.D64(value);
-   }
-   info.Finish();
-diff --git a/src/common/dwarf/dwarf2reader_test_common.h b/src/common/dwarf/dwarf2reader_test_common.h
---- a/src/common/dwarf/dwarf2reader_test_common.h
-+++ b/src/common/dwarf/dwarf2reader_test_common.h
-@@ -92,17 +92,17 @@
-   }
- 
-  private:
-   // The DWARF format size for this compilation unit.
-   size_t format_size_;
- 
-   // The offset of the point in the compilation unit header immediately
-   // after the initial length field.
--  u_int64_t post_length_offset_;
-+  uint64_t post_length_offset_;
- 
-   // The length of the compilation unit, not including the initial length field.
-   Label length_;
- };
- 
- // A subclass of test_assembler::Section specialized for constructing DWARF
- // abbreviation tables.
- class TestAbbrevTable: public google_breakpad::test_assembler::Section {
-diff --git a/src/common/linux/guid_creator.cc b/src/common/linux/guid_creator.cc
---- a/src/common/linux/guid_creator.cc
-+++ b/src/common/linux/guid_creator.cc
-@@ -41,35 +41,35 @@
- //
- // This class is used to generate random GUID.
- // Currently use random number to generate a GUID since Linux has
- // no native GUID generator. This should be OK since we don't expect
- // crash to happen very offen.
- //
- class GUIDGenerator {
-  public:
--  static u_int32_t BytesToUInt32(const u_int8_t bytes[]) {
--    return ((u_int32_t) bytes[0]
--            | ((u_int32_t) bytes[1] << 8)
--            | ((u_int32_t) bytes[2] << 16)
--            | ((u_int32_t) bytes[3] << 24));
-+  static uint32_t BytesToUInt32(const uint8_t bytes[]) {
-+    return ((uint32_t) bytes[0]
-+            | ((uint32_t) bytes[1] << 8)
-+            | ((uint32_t) bytes[2] << 16)
-+            | ((uint32_t) bytes[3] << 24));
-   }
- 
--  static void UInt32ToBytes(u_int8_t bytes[], u_int32_t n) {
-+  static void UInt32ToBytes(uint8_t bytes[], uint32_t n) {
-     bytes[0] = n & 0xff;
-     bytes[1] = (n >> 8) & 0xff;
-     bytes[2] = (n >> 16) & 0xff;
-     bytes[3] = (n >> 24) & 0xff;
-   }
- 
-   static bool CreateGUID(GUID *guid) {
-     InitOnce();
-     guid->data1 = random();
--    guid->data2 = (u_int16_t)(random());
--    guid->data3 = (u_int16_t)(random());
-+    guid->data2 = (uint16_t)(random());
-+    guid->data3 = (uint16_t)(random());
-     UInt32ToBytes(&guid->data4[0], random());
-     UInt32ToBytes(&guid->data4[4], random());
-     return true;
-   }
- 
-  private:
-   static void InitOnce() {
-     pthread_once(&once_control, &InitOnceImpl);
-diff --git a/src/common/linux/memory_mapped_file.cc b/src/common/linux/memory_mapped_file.cc
---- a/src/common/linux/memory_mapped_file.cc
-+++ b/src/common/linux/memory_mapped_file.cc
-@@ -92,14 +92,14 @@
-   }
- 
-   content_.Set(data, st.st_size);
-   return true;
- }
- 
- void MemoryMappedFile::Unmap() {
-   if (content_.data()) {
--    sys_munmap(const_cast<u_int8_t*>(content_.data()), content_.length());
-+    sys_munmap(const_cast<uint8_t*>(content_.data()), content_.length());
-     content_.Set(NULL, 0);
-   }
- }
- 
- }  // namespace google_breakpad
-diff --git a/src/common/mac/MachIPC.h b/src/common/mac/MachIPC.h
---- a/src/common/mac/MachIPC.h
-+++ b/src/common/mac/MachIPC.h
-@@ -159,21 +159,21 @@
- //
- //  A MachMessage object is used by ReceivePort::WaitForMessage
- //  and MachPortSender::SendMessage
- //
- class MachMessage {
-  public:
- 
-   // The receiver of the message can retrieve the raw data this way
--  u_int8_t *GetData() {
-+  uint8_t *GetData() {
-     return GetDataLength() > 0 ? GetDataPacket()->data : NULL;
-   }
- 
--  u_int32_t GetDataLength() {
-+  uint32_t GetDataLength() {
-     return EndianU32_LtoN(GetDataPacket()->data_length);
-   }
- 
-   // The message ID may be used as a code identifying the type of message
-   void SetMessageID(int32_t message_id) {
-     GetDataPacket()->id = EndianU32_NtoL(message_id);
-   }
- 
-@@ -205,30 +205,30 @@
- 
-   friend class ReceivePort;
-   friend class MachPortSender;
- 
-   // Represents raw data in our message
-   struct MessageDataPacket {
-     int32_t      id;          // little-endian
-     int32_t      data_length; // little-endian
--    u_int8_t     data[1];     // actual size limited by sizeof(MachMessage)
-+    uint8_t     data[1];     // actual size limited by sizeof(MachMessage)
-   };
- 
-   MessageDataPacket* GetDataPacket();
- 
-   void SetDescriptorCount(int n);
-   void SetDescriptor(int n, const MachMsgPortDescriptor &desc);
- 
-   // Returns total message size setting msgh_size in the header to this value
-   mach_msg_size_t CalculateSize();
- 
-   mach_msg_header_t  head;
-   mach_msg_body_t    body;
--  u_int8_t           padding[1024]; // descriptors and data may be embedded here
-+  uint8_t           padding[1024]; // descriptors and data may be embedded here
- };
- 
- //==============================================================================
- // MachReceiveMessage and MachSendMessage are useful to separate the idea
- // of a mach message being sent and being received, and adds increased type
- // safety:
- //  ReceivePort::WaitForMessage() only accepts a MachReceiveMessage
- //  MachPortSender::SendMessage() only accepts a MachSendMessage
-diff --git a/src/common/memory_range.h b/src/common/memory_range.h
---- a/src/common/memory_range.h
-+++ b/src/common/memory_range.h
-@@ -62,17 +62,17 @@
-   // Resets to an empty range.
-   void Reset() {
-     data_ = NULL;
-     length_ = 0;
-   }
- 
-   // Sets this memory range to point to |data| and its length to |length|.
-   void Set(const void* data, size_t length) {
--    data_ = reinterpret_cast<const u_int8_t*>(data);
-+    data_ = reinterpret_cast<const uint8_t*>(data);
-     // Always set |length_| to zero if |data_| is NULL.
-     length_ = data ? length : 0;
-   }
- 
-   // Returns true if this range covers a subrange of |sub_length| bytes
-   // at |sub_offset| bytes of this memory range, or false otherwise.
-   bool Covers(size_t sub_offset, size_t sub_length) const {
-     // The following checks verify that:
-@@ -122,24 +122,24 @@
-   // Returns a subrange of |sub_length| bytes at |sub_offset| bytes of
-   // this memory range, or an empty range if the subrange is out of bounds.
-   MemoryRange Subrange(size_t sub_offset, size_t sub_length) const {
-     return Covers(sub_offset, sub_length) ?
-         MemoryRange(data_ + sub_offset, sub_length) : MemoryRange();
-   }
- 
-   // Returns a pointer to the beginning of this memory range.
--  const u_int8_t* data() const { return data_; }
-+  const uint8_t* data() const { return data_; }
- 
-   // Returns the length, in bytes, of this memory range.
-   size_t length() const { return length_; }
- 
-  private:
-   // Pointer to the beginning of this memory range.
--  const u_int8_t* data_;
-+  const uint8_t* data_;
- 
-   // Length, in bytes, of this memory range.
-   size_t length_;
- };
- 
- }  // namespace google_breakpad
- 
- #endif  // COMMON_MEMORY_RANGE_H_
-diff --git a/src/common/memory_range_unittest.cc b/src/common/memory_range_unittest.cc
---- a/src/common/memory_range_unittest.cc
-+++ b/src/common/memory_range_unittest.cc
-@@ -32,19 +32,19 @@
- #include "breakpad_googletest_includes.h"
- #include "common/memory_range.h"
- 
- using google_breakpad::MemoryRange;
- using testing::Message;
- 
- namespace {
- 
--const u_int32_t kBuffer[10] = { 0 };
-+const uint32_t kBuffer[10] = { 0 };
- const size_t kBufferSize = sizeof(kBuffer);
--const u_int8_t* kBufferPointer = reinterpret_cast<const u_int8_t*>(kBuffer);
-+const uint8_t* kBufferPointer = reinterpret_cast<const uint8_t*>(kBuffer);
- 
- // Test vectors for verifying Covers, GetData, and Subrange.
- const struct {
-   bool valid;
-   size_t offset;
-   size_t length;
- } kSubranges[] = {
-   { true, 0, 0 },
-diff --git a/src/common/module.h b/src/common/module.h
---- a/src/common/module.h
-+++ b/src/common/module.h
-@@ -55,17 +55,17 @@
- 
- // A Module represents the contents of a module, and supports methods
- // for adding information produced by parsing STABS or DWARF data
- // --- possibly both from the same file --- and then writing out the
- // unified contents as a Breakpad-format symbol file.
- class Module {
-  public:
-   // The type of addresses and sizes in a symbol table.
--  typedef u_int64_t Address;
-+  typedef uint64_t Address;
-   struct File;
-   struct Function;
-   struct Line;
-   struct Extern;
- 
-   // Addresses appearing in File, Function, and Line structures are
-   // absolute, not relative to the the module's load address.  That
-   // is, if the module were loaded at its nominal load address, the
-diff --git a/src/common/solaris/dump_symbols.cc b/src/common/solaris/dump_symbols.cc
---- a/src/common/solaris/dump_symbols.cc
-+++ b/src/common/solaris/dump_symbols.cc
-@@ -151,17 +151,17 @@
- 
- // Strtab section name.
- const char *kStrtabName = ".strtab";
- 
- // Default buffer lenght for demangle.
- const int demangleLen = 20000;
- 
- // Offset to the string table.
--u_int64_t stringOffset = 0;
-+uint64_t stringOffset = 0;
- 
- // Update the offset to the start of the string index of the next
- // object module for every N_ENDM stabs.
- inline void RecalculateOffset(struct slist* cur_list, char *stabstr) {
-   while ((--cur_list)->n_strx == 0) ;
-   stringOffset += cur_list->n_strx;
- 
-   char *temp = stabstr + stringOffset;
-diff --git a/src/common/solaris/guid_creator.cc b/src/common/solaris/guid_creator.cc
---- a/src/common/solaris/guid_creator.cc
-+++ b/src/common/solaris/guid_creator.cc
-@@ -48,20 +48,20 @@
- class GUIDGenerator {
-  public:
-   GUIDGenerator() {
-     srandom(time(NULL));
-   }
- 
-   bool CreateGUID(GUID *guid) const {
-     guid->data1 = random();
--    guid->data2 = (u_int16_t)(random());
--    guid->data3 = (u_int16_t)(random());
--    *reinterpret_cast<u_int32_t*>(&guid->data4[0]) = random();
--    *reinterpret_cast<u_int32_t*>(&guid->data4[4]) = random();
-+    guid->data2 = (uint16_t)(random());
-+    guid->data3 = (uint16_t)(random());
-+    *reinterpret_cast<uint32_t*>(&guid->data4[0]) = random();
-+    *reinterpret_cast<uint32_t*>(&guid->data4[4]) = random();
-     return true;
-   }
- };
- 
- // Guid generator.
- const GUIDGenerator kGuidGenerator;
- 
- bool CreateGUID(GUID *guid) {
-@@ -69,16 +69,16 @@
- };
- 
- // Parse guid to string.
- bool GUIDToString(const GUID *guid, char *buf, int buf_len) {
-   // Should allow more space the the max length of GUID.
-   assert(buf_len > kGUIDStringLength);
-   int num = snprintf(buf, buf_len, kGUIDFormatString,
-                      guid->data1, guid->data2, guid->data3,
--                     *reinterpret_cast<const u_int32_t *>(&(guid->data4[0])),
--                     *reinterpret_cast<const u_int32_t *>(&(guid->data4[4])));
-+                     *reinterpret_cast<const uint32_t *>(&(guid->data4[0])),
-+                     *reinterpret_cast<const uint32_t *>(&(guid->data4[4])));
-   if (num != kGUIDStringLength)
-     return false;
- 
-   buf[num] = '\0';
-   return true;
- }
-diff --git a/src/common/stabs_reader_unittest.cc b/src/common/stabs_reader_unittest.cc
---- a/src/common/stabs_reader_unittest.cc
-+++ b/src/common/stabs_reader_unittest.cc
-@@ -560,17 +560,17 @@
- 
- #if defined(HAVE_MACH_O_NLIST_H)
- // These tests have no meaning on non-Mach-O-based systems, as
- // only Mach-O uses N_SECT to represent public symbols.
- TEST_F(Stabs, OnePublicSymbol) {
-   stabs.set_endianness(kLittleEndian);
-   stabs.set_value_size(4);
- 
--  const u_int32_t kExpectedAddress = 0x9000;
-+  const uint32_t kExpectedAddress = 0x9000;
-   const string kExpectedFunctionName("public_function");
-   stabs
-     .Stab(N_SECT, 1, 0, kExpectedAddress, kExpectedFunctionName);
- 
-   {
-     InSequence s;
-     EXPECT_CALL(mock_handler,
-                 Extern(StrEq(kExpectedFunctionName),
-@@ -579,19 +579,19 @@
-   }
-   ASSERT_TRUE(ApplyHandlerToMockStabsData());
- }
- 
- TEST_F(Stabs, TwoPublicSymbols) {
-   stabs.set_endianness(kLittleEndian);
-   stabs.set_value_size(4);
- 
--  const u_int32_t kExpectedAddress1 = 0xB0B0B0B0;
-+  const uint32_t kExpectedAddress1 = 0xB0B0B0B0;
-   const string kExpectedFunctionName1("public_function");
--  const u_int32_t kExpectedAddress2 = 0xF0F0F0F0;
-+  const uint32_t kExpectedAddress2 = 0xF0F0F0F0;
-   const string kExpectedFunctionName2("something else");
-   stabs
-     .Stab(N_SECT, 1, 0, kExpectedAddress1, kExpectedFunctionName1)
-     .Stab(N_SECT, 1, 0, kExpectedAddress2, kExpectedFunctionName2);
- 
-   {
-     InSequence s;
-     EXPECT_CALL(mock_handler,
-diff --git a/src/common/string_conversion.cc b/src/common/string_conversion.cc
---- a/src/common/string_conversion.cc
-+++ b/src/common/string_conversion.cc
-@@ -33,38 +33,38 @@
- #include "common/scoped_ptr.h"
- #include "common/string_conversion.h"
- #include "common/using_std_string.h"
- 
- namespace google_breakpad {
- 
- using std::vector;
- 
--void UTF8ToUTF16(const char *in, vector<u_int16_t> *out) {
-+void UTF8ToUTF16(const char *in, vector<uint16_t> *out) {
-   size_t source_length = strlen(in);
-   const UTF8 *source_ptr = reinterpret_cast<const UTF8 *>(in);
-   const UTF8 *source_end_ptr = source_ptr + source_length;
-   // Erase the contents and zero fill to the expected size
-   out->clear();
-   out->insert(out->begin(), source_length, 0);
--  u_int16_t *target_ptr = &(*out)[0];
--  u_int16_t *target_end_ptr = target_ptr + out->capacity() * sizeof(u_int16_t);
-+  uint16_t *target_ptr = &(*out)[0];
-+  uint16_t *target_end_ptr = target_ptr + out->capacity() * sizeof(uint16_t);
-   ConversionResult result = ConvertUTF8toUTF16(&source_ptr, source_end_ptr,
-                                                &target_ptr, target_end_ptr,
-                                                strictConversion);
- 
-   // Resize to be the size of the # of converted characters + NULL
-   out->resize(result == conversionOK ? target_ptr - &(*out)[0] + 1: 0);
- }
- 
--int UTF8ToUTF16Char(const char *in, int in_length, u_int16_t out[2]) {
-+int UTF8ToUTF16Char(const char *in, int in_length, uint16_t out[2]) {
-   const UTF8 *source_ptr = reinterpret_cast<const UTF8 *>(in);
-   const UTF8 *source_end_ptr = source_ptr + sizeof(char);
--  u_int16_t *target_ptr = out;
--  u_int16_t *target_end_ptr = target_ptr + 2 * sizeof(u_int16_t);
-+  uint16_t *target_ptr = out;
-+  uint16_t *target_end_ptr = target_ptr + 2 * sizeof(uint16_t);
-   out[0] = out[1] = 0;
- 
-   // Process one character at a time
-   while (1) {
-     ConversionResult result = ConvertUTF8toUTF16(&source_ptr, source_end_ptr,
-                                                  &target_ptr, target_end_ptr,
-                                                  strictConversion);
- 
-@@ -77,62 +77,62 @@
- 
-     if (source_end_ptr > reinterpret_cast<const UTF8 *>(in) + in_length)
-       break;
-   }
- 
-   return 0;
- }
- 
--void UTF32ToUTF16(const wchar_t *in, vector<u_int16_t> *out) {
-+void UTF32ToUTF16(const wchar_t *in, vector<uint16_t> *out) {
-   size_t source_length = wcslen(in);
-   const UTF32 *source_ptr = reinterpret_cast<const UTF32 *>(in);
-   const UTF32 *source_end_ptr = source_ptr + source_length;
-   // Erase the contents and zero fill to the expected size
-   out->clear();
-   out->insert(out->begin(), source_length, 0);
--  u_int16_t *target_ptr = &(*out)[0];
--  u_int16_t *target_end_ptr = target_ptr + out->capacity() * sizeof(u_int16_t);
-+  uint16_t *target_ptr = &(*out)[0];
-+  uint16_t *target_end_ptr = target_ptr + out->capacity() * sizeof(uint16_t);
-   ConversionResult result = ConvertUTF32toUTF16(&source_ptr, source_end_ptr,
-                                                 &target_ptr, target_end_ptr,
-                                                 strictConversion);
- 
-   // Resize to be the size of the # of converted characters + NULL
-   out->resize(result == conversionOK ? target_ptr - &(*out)[0] + 1: 0);
- }
- 
--void UTF32ToUTF16Char(wchar_t in, u_int16_t out[2]) {
-+void UTF32ToUTF16Char(wchar_t in, uint16_t out[2]) {
-   const UTF32 *source_ptr = reinterpret_cast<const UTF32 *>(&in);
-   const UTF32 *source_end_ptr = source_ptr + 1;
--  u_int16_t *target_ptr = out;
--  u_int16_t *target_end_ptr = target_ptr + 2 * sizeof(u_int16_t);
-+  uint16_t *target_ptr = out;
-+  uint16_t *target_end_ptr = target_ptr + 2 * sizeof(uint16_t);
-   out[0] = out[1] = 0;
-   ConversionResult result = ConvertUTF32toUTF16(&source_ptr, source_end_ptr,
-                                                 &target_ptr, target_end_ptr,
-                                                 strictConversion);
- 
-   if (result != conversionOK) {
-     out[0] = out[1] = 0;
-   }
- }
- 
--static inline u_int16_t Swap(u_int16_t value) {
--  return (value >> 8) | static_cast<u_int16_t>(value << 8);
-+static inline uint16_t Swap(uint16_t value) {
-+  return (value >> 8) | static_cast<uint16_t>(value << 8);
- }
- 
--string UTF16ToUTF8(const vector<u_int16_t> &in, bool swap) {
-+string UTF16ToUTF8(const vector<uint16_t> &in, bool swap) {
-   const UTF16 *source_ptr = &in[0];
--  scoped_ptr<u_int16_t> source_buffer;
-+  scoped_ptr<uint16_t> source_buffer;
- 
-   // If we're to swap, we need to make a local copy and swap each byte pair
-   if (swap) {
-     int idx = 0;
--    source_buffer.reset(new u_int16_t[in.size()]);
-+    source_buffer.reset(new uint16_t[in.size()]);
-     UTF16 *source_buffer_ptr = source_buffer.get();
--    for (vector<u_int16_t>::const_iterator it = in.begin();
-+    for (vector<uint16_t>::const_iterator it = in.begin();
-          it != in.end(); ++it, ++idx)
-       source_buffer_ptr[idx] = Swap(*it);
- 
-     source_ptr = source_buffer.get();
-   }
- 
-   // The maximum expansion would be 4x the size of the input string.
-   const UTF16 *source_end_ptr = source_ptr + in.size();
-diff --git a/src/common/string_conversion.h b/src/common/string_conversion.h
---- a/src/common/string_conversion.h
-+++ b/src/common/string_conversion.h
-@@ -39,30 +39,30 @@
- #include "google_breakpad/common/breakpad_types.h"
- 
- namespace google_breakpad {
-   
- using std::vector;
- 
- // Convert |in| to UTF-16 into |out|.  Use platform byte ordering.  If the
- // conversion failed, |out| will be zero length.
--void UTF8ToUTF16(const char *in, vector<u_int16_t> *out);
-+void UTF8ToUTF16(const char *in, vector<uint16_t> *out);
- 
- // Convert at least one character (up to a maximum of |in_length|) from |in|
- // to UTF-16 into |out|.  Return the number of characters consumed from |in|.
- // Any unused characters in |out| will be initialized to 0.  No memory will
- // be allocated by this routine.
--int UTF8ToUTF16Char(const char *in, int in_length, u_int16_t out[2]);
-+int UTF8ToUTF16Char(const char *in, int in_length, uint16_t out[2]);
- 
- // Convert |in| to UTF-16 into |out|.  Use platform byte ordering.  If the
- // conversion failed, |out| will be zero length.
--void UTF32ToUTF16(const wchar_t *in, vector<u_int16_t> *out);
-+void UTF32ToUTF16(const wchar_t *in, vector<uint16_t> *out);
- 
- // Convert |in| to UTF-16 into |out|.  Any unused characters in |out| will be
- // initialized to 0.  No memory will be allocated by this routine.
--void UTF32ToUTF16Char(wchar_t in, u_int16_t out[2]);
-+void UTF32ToUTF16Char(wchar_t in, uint16_t out[2]);
- 
- // Convert |in| to UTF-8.  If |swap| is true, swap bytes before converting.
--string UTF16ToUTF8(const vector<u_int16_t> &in, bool swap);
-+string UTF16ToUTF8(const vector<uint16_t> &in, bool swap);
- 
- }  // namespace google_breakpad
- 
- #endif  // COMMON_STRING_CONVERSION_H__
-diff --git a/src/common/test_assembler.cc b/src/common/test_assembler.cc
---- a/src/common/test_assembler.cc
-+++ b/src/common/test_assembler.cc
-@@ -40,42 +40,42 @@
- #include <iterator>
- 
- namespace google_breakpad {
- namespace test_assembler {
- 
- using std::back_insert_iterator;
- 
- Label::Label() : value_(new Binding()) { }
--Label::Label(u_int64_t value) : value_(new Binding(value)) { }
-+Label::Label(uint64_t value) : value_(new Binding(value)) { }
- Label::Label(const Label &label) {
-   value_ = label.value_;
-   value_->Acquire();
- }
- Label::~Label() {
-   if (value_->Release()) delete value_;
- }
- 
--Label &Label::operator=(u_int64_t value) {
-+Label &Label::operator=(uint64_t value) {
-   value_->Set(NULL, value);
-   return *this;
- }
- 
- Label &Label::operator=(const Label &label) {
-   value_->Set(label.value_, 0);
-   return *this;
- }
- 
--Label Label::operator+(u_int64_t addend) const {
-+Label Label::operator+(uint64_t addend) const {
-   Label l;
-   l.value_->Set(this->value_, addend);
-   return l;
- }
- 
--Label Label::operator-(u_int64_t subtrahend) const {
-+Label Label::operator-(uint64_t subtrahend) const {
-   Label l;
-   l.value_->Set(this->value_, -subtrahend);
-   return l;
- }
- 
- // When NDEBUG is #defined, assert doesn't evaluate its argument. This
- // means you can't simply use assert to check the return value of a
- // function with necessary side effects.
-@@ -84,78 +84,78 @@
- // NDEBUG is #defined; when NDEBUG is not #defined, it further asserts
- // that x is true.
- #ifdef NDEBUG
- #define ALWAYS_EVALUATE_AND_ASSERT(x) x
- #else
- #define ALWAYS_EVALUATE_AND_ASSERT(x) assert(x)
- #endif
- 
--u_int64_t Label::operator-(const Label &label) const {
--  u_int64_t offset;
-+uint64_t Label::operator-(const Label &label) const {
-+  uint64_t offset;
-   ALWAYS_EVALUATE_AND_ASSERT(IsKnownOffsetFrom(label, &offset));
-   return offset;
- }
- 
--u_int64_t Label::Value() const {
--  u_int64_t v = 0;
-+uint64_t Label::Value() const {
-+  uint64_t v = 0;
-   ALWAYS_EVALUATE_AND_ASSERT(IsKnownConstant(&v));
-   return v;
- };
- 
--bool Label::IsKnownConstant(u_int64_t *value_p) const {
-+bool Label::IsKnownConstant(uint64_t *value_p) const {
-   Binding *base;
--  u_int64_t addend;
-+  uint64_t addend;
-   value_->Get(&base, &addend);
-   if (base != NULL) return false;
-   if (value_p) *value_p = addend;
-   return true;
- }
- 
--bool Label::IsKnownOffsetFrom(const Label &label, u_int64_t *offset_p) const
-+bool Label::IsKnownOffsetFrom(const Label &label, uint64_t *offset_p) const
- {
-   Binding *label_base, *this_base;
--  u_int64_t label_addend, this_addend;
-+  uint64_t label_addend, this_addend;
-   label.value_->Get(&label_base, &label_addend);
-   value_->Get(&this_base, &this_addend);
-   // If this and label are related, Get will find their final
-   // common ancestor, regardless of how indirect the relation is. This
-   // comparison also handles the constant vs. constant case.
-   if (this_base != label_base) return false;
-   if (offset_p) *offset_p = this_addend - label_addend;
-   return true;
- }
- 
- Label::Binding::Binding() : base_(this), addend_(), reference_count_(1) { }
- 
--Label::Binding::Binding(u_int64_t addend)
-+Label::Binding::Binding(uint64_t addend)
-     : base_(NULL), addend_(addend), reference_count_(1) { }
- 
- Label::Binding::~Binding() {
-   assert(reference_count_ == 0);
-   if (base_ && base_ != this && base_->Release())
-     delete base_;
- }
- 
--void Label::Binding::Set(Binding *binding, u_int64_t addend) {
-+void Label::Binding::Set(Binding *binding, uint64_t addend) {
-   if (!base_ && !binding) {
-     // We're equating two constants. This could be okay.
-     assert(addend_ == addend);
-   } else if (!base_) {
-     // We are a known constant, but BINDING may not be, so turn the
-     // tables and try to set BINDING's value instead.
-     binding->Set(NULL, addend_ - addend);
-   } else {
-     if (binding) {
-       // Find binding's final value. Since the final value is always either
-       // completely unconstrained or a constant, never a reference to
-       // another variable (otherwise, it wouldn't be final), this
-       // guarantees we won't create cycles here, even for code like this:
-       //   l = m, m = n, n = l;
--      u_int64_t binding_addend;
-+      uint64_t binding_addend;
-       binding->Get(&binding, &binding_addend);
-       addend += binding_addend;
-     }
- 
-     // It seems likely that setting a binding to itself is a bug
-     // (although I can imagine this might turn out to be helpful to
-     // permit).
-     assert(binding != this);
-@@ -178,62 +178,62 @@
-     // complained if BINDING were 'this' or anywhere along our chain,
-     // so we didn't release BINDING.
-     if (binding) binding->Acquire();
-     base_ = binding;
-     addend_ = addend;
-   }
- }
- 
--void Label::Binding::Get(Binding **base, u_int64_t *addend) {
-+void Label::Binding::Get(Binding **base, uint64_t *addend) {
-   if (base_ && base_ != this) {
-     // Recurse to find the end of our reference chain (the root of our
-     // tree), and then rewrite every binding along the chain to refer
-     // to it directly, adjusting addends appropriately. (This is why
-     // this member function isn't this-const.)
-     Binding *final_base;
--    u_int64_t final_addend;
-+    uint64_t final_addend;
-     base_->Get(&final_base, &final_addend);
-     if (final_base) final_base->Acquire();
-     if (base_->Release()) delete base_;
-     base_ = final_base;
-     addend_ += final_addend;
-   }
-   *base = base_;
-   *addend = addend_;
- }
- 
- template<typename Inserter>
- static inline void InsertEndian(test_assembler::Endianness endianness,
--                                size_t size, u_int64_t number, Inserter dest) {
-+                                size_t size, uint64_t number, Inserter dest) {
-   assert(size > 0);
-   if (endianness == kLittleEndian) {
-     for (size_t i = 0; i < size; i++) {
-       *dest++ = (char) (number & 0xff);
-       number >>= 8;
-     }
-   } else {
-     assert(endianness == kBigEndian);
-     // The loop condition is odd, but it's correct for size_t.
-     for (size_t i = size - 1; i < size; i--)
-       *dest++ = (char) ((number >> (i * 8)) & 0xff);
-   }
- }
- 
--Section &Section::Append(Endianness endianness, size_t size, u_int64_t number) {
-+Section &Section::Append(Endianness endianness, size_t size, uint64_t number) {
-   InsertEndian(endianness, size, number,
-                back_insert_iterator<string>(contents_));
-   return *this;
- }
- 
- Section &Section::Append(Endianness endianness, size_t size,
-                          const Label &label) {
-   // If this label's value is known, there's no reason to waste an
-   // entry in references_ on it.
--  u_int64_t value;
-+  uint64_t value;
-   if (label.IsKnownConstant(&value))
-     return Append(endianness, size, value);
- 
-   // This will get caught when the references are resolved, but it's
-   // nicer to find out earlier.
-   assert(endianness != kUnsetEndian);
- 
-   references_.push_back(Reference(contents_.size(), endianness, size, label));
-@@ -241,17 +241,17 @@
-   return *this;
- }
- 
- #define ENDIANNESS_L kLittleEndian
- #define ENDIANNESS_B kBigEndian
- #define ENDIANNESS(e) ENDIANNESS_ ## e
- 
- #define DEFINE_SHORT_APPEND_NUMBER_ENDIAN(e, bits)                      \
--  Section &Section::e ## bits(u_int ## bits ## _t v) {                  \
-+  Section &Section::e ## bits(uint ## bits ## _t v) {                  \
-     InsertEndian(ENDIANNESS(e), bits / 8, v,                            \
-                  back_insert_iterator<string>(contents_));              \
-     return *this;                                                       \
-   }
- 
- #define DEFINE_SHORT_APPEND_LABEL_ENDIAN(e, bits)                       \
-   Section &Section::e ## bits(const Label &v) {                         \
-     return Append(ENDIANNESS(e), bits / 8, v);                          \
-@@ -267,17 +267,17 @@
- DEFINE_SHORT_APPEND_ENDIAN(L, 16);
- DEFINE_SHORT_APPEND_ENDIAN(L, 32);
- DEFINE_SHORT_APPEND_ENDIAN(L, 64);
- DEFINE_SHORT_APPEND_ENDIAN(B, 16);
- DEFINE_SHORT_APPEND_ENDIAN(B, 32);
- DEFINE_SHORT_APPEND_ENDIAN(B, 64);
- 
- #define DEFINE_SHORT_APPEND_NUMBER_DEFAULT(bits)                        \
--  Section &Section::D ## bits(u_int ## bits ## _t v) {                  \
-+  Section &Section::D ## bits(uint ## bits ## _t v) {                  \
-     InsertEndian(endianness_, bits / 8, v,                              \
-                  back_insert_iterator<string>(contents_));              \
-     return *this;                                                       \
-   }
- #define DEFINE_SHORT_APPEND_LABEL_DEFAULT(bits)                         \
-   Section &Section::D ## bits(const Label &v) {                         \
-     return Append(endianness_, bits / 8, v);                            \
-   }
-@@ -307,26 +307,26 @@
-       value = (value >> 7) | ~(((unsigned long long) -1) >> 7);
-     else
-       value = (value >> 7);
-   }
-   contents_ += value & 0x7f;
-   return *this;
- }
- 
--Section &Section::ULEB128(u_int64_t value) {
-+Section &Section::ULEB128(uint64_t value) {
-   while (value > 0x7f) {
-     contents_ += (value & 0x7f) | 0x80;
-     value = (value >> 7);
-   }
-   contents_ += value;
-   return *this;
- }
- 
--Section &Section::Align(size_t alignment, u_int8_t pad_byte) {
-+Section &Section::Align(size_t alignment, uint8_t pad_byte) {
-   // ALIGNMENT must be a power of two.
-   assert(((alignment - 1) & alignment) == 0);
-   size_t new_size = (contents_.size() + alignment - 1) & ~(alignment - 1);
-   contents_.append(new_size - contents_.size(), pad_byte);
-   assert((contents_.size() & (alignment - 1)) == 0);
-   return *this;
- }
- 
-@@ -335,17 +335,17 @@
-   references_.clear();
- }
- 
- bool Section::GetContents(string *contents) {
-   // For each label reference, find the label's value, and patch it into
-   // the section's contents.
-   for (size_t i = 0; i < references_.size(); i++) {
-     Reference &r = references_[i];
--    u_int64_t value;
-+    uint64_t value;
-     if (!r.label.IsKnownConstant(&value)) {
-       fprintf(stderr, "Undefined label #%zu at offset 0x%zx\n", i, r.offset);
-       return false;
-     }
-     assert(r.offset < contents_.size());
-     assert(contents_.size() - r.offset >= r.size);
-     InsertEndian(r.endianness, r.size, value, contents_.begin() + r.offset);
-   }
-diff --git a/src/common/test_assembler.h b/src/common/test_assembler.h
---- a/src/common/test_assembler.h
-+++ b/src/common/test_assembler.h
-@@ -105,62 +105,62 @@
- // Label objects' lifetimes are unconstrained: notice that, in the
- // above example, even though a and b are only related through c, and
- // c goes out of scope, the assignment to a sets b's value as well. In
- // particular, it's not necessary to ensure that a Label lives beyond
- // Sections that refer to it.
- class Label {
-  public:
-   Label();                      // An undefined label.
--  Label(u_int64_t value);       // A label with a fixed value
-+  Label(uint64_t value);       // A label with a fixed value
-   Label(const Label &value);    // A label equal to another.
-   ~Label();
- 
-   // Return this label's value; it must be known.
-   //
-   // Providing this as a cast operator is nifty, but the conversions
-   // happen in unexpected places. In particular, ISO C++ says that
-   // Label + size_t becomes ambigious, because it can't decide whether
--  // to convert the Label to a u_int64_t and then to a size_t, or use
-+  // to convert the Label to a uint64_t and then to a size_t, or use
-   // the overloaded operator that returns a new label, even though the
-   // former could fail if the label is not yet defined and the latter won't.
--  u_int64_t Value() const;
-+  uint64_t Value() const;
- 
--  Label &operator=(u_int64_t value);
-+  Label &operator=(uint64_t value);
-   Label &operator=(const Label &value);
--  Label operator+(u_int64_t addend) const;
--  Label operator-(u_int64_t subtrahend) const;
--  u_int64_t operator-(const Label &subtrahend) const;
-+  Label operator+(uint64_t addend) const;
-+  Label operator-(uint64_t subtrahend) const;
-+  uint64_t operator-(const Label &subtrahend) const;
- 
-   // We could also provide == and != that work on undefined, but
-   // related, labels.
- 
-   // Return true if this label's value is known. If VALUE_P is given,
-   // set *VALUE_P to the known value if returning true.
--  bool IsKnownConstant(u_int64_t *value_p = NULL) const;
-+  bool IsKnownConstant(uint64_t *value_p = NULL) const;
- 
-   // Return true if the offset from LABEL to this label is known. If
-   // OFFSET_P is given, set *OFFSET_P to the offset when returning true.
-   //
-   // You can think of l.KnownOffsetFrom(m, &d) as being like 'd = l-m',
-   // except that it also returns a value indicating whether the
-   // subtraction is possible given what we currently know of l and m.
-   // It can be possible even if we don't know l and m's values. For
-   // example:
-   // 
-   //   Label l, m;
-   //   m = l + 10;
-   //   l.IsKnownConstant();             // false
-   //   m.IsKnownConstant();             // false
--  //   u_int64_t d;                     
-+  //   uint64_t d;                     
-   //   l.IsKnownOffsetFrom(m, &d);      // true, and sets d to -10.
-   //   l-m                              // -10
-   //   m-l                              // 10
-   //   m.Value()                        // error: m's value is not known
--  bool IsKnownOffsetFrom(const Label &label, u_int64_t *offset_p = NULL) const;
-+  bool IsKnownOffsetFrom(const Label &label, uint64_t *offset_p = NULL) const;
- 
-  private:
-   // A label's value, or if that is not yet known, how the value is
-   // related to other labels' values. A binding may be:
-   // - a known constant,
-   // - constrained to be equal to some other binding plus a constant, or
-   // - unconstrained, and free to take on any value.
-   //
-@@ -168,42 +168,42 @@
-   // refer to another, so bindings and labels form trees whose leaves
-   // are labels, whose interior nodes (and roots) are bindings, and
-   // where links point from children to parents. Bindings are
-   // reference counted, allowing labels to be lightweight, copyable,
-   // assignable, placed in containers, and so on.
-   class Binding {
-    public:
-     Binding();
--    Binding(u_int64_t addend);
-+    Binding(uint64_t addend);
-     ~Binding();
- 
-     // Increment our reference count.
-     void Acquire() { reference_count_++; };
-     // Decrement our reference count, and return true if it is zero.
-     bool Release() { return --reference_count_ == 0; }
- 
-     // Set this binding to be equal to BINDING + ADDEND. If BINDING is
-     // NULL, then set this binding to the known constant ADDEND.
-     // Update every binding on this binding's chain to point directly
-     // to BINDING, or to be a constant, with addends adjusted
-     // appropriately.
--    void Set(Binding *binding, u_int64_t value);
-+    void Set(Binding *binding, uint64_t value);
- 
-     // Return what we know about the value of this binding.
-     // - If this binding's value is a known constant, set BASE to
-     //   NULL, and set ADDEND to its value.
-     // - If this binding is not a known constant but related to other
-     //   bindings, set BASE to the binding at the end of the relation
-     //   chain (which will always be unconstrained), and set ADDEND to the
-     //   value to add to that binding's value to get this binding's
-     //   value.
-     // - If this binding is unconstrained, set BASE to this, and leave
-     //   ADDEND unchanged.
--    void Get(Binding **base, u_int64_t *addend);
-+    void Get(Binding **base, uint64_t *addend);
- 
-    private:
-     // There are three cases:
-     //
-     // - A binding representing a known constant value has base_ NULL,
-     //   and addend_ equal to the value.
-     //
-     // - A binding representing a completely unconstrained value has
-@@ -216,29 +216,29 @@
-     //   x = y+c.
-     //
-     // Thus, the bind_ links form a chain terminating in either a
-     // known constant value or a completely unconstrained value. Most
-     // operations on bindings do path compression: they change every
-     // binding on the chain to point directly to the final value,
-     // adjusting addends as appropriate.
-     Binding *base_;
--    u_int64_t addend_;
-+    uint64_t addend_;
- 
-     // The number of Labels and Bindings pointing to this binding.
-     // (When a binding points to itself, indicating a completely
-     // unconstrained binding, that doesn't count as a reference.)
-     int reference_count_;
-   };
- 
-   // This label's value.
-   Binding *value_;
- };
- 
--inline Label operator+(u_int64_t a, const Label &l) { return l + a; }
-+inline Label operator+(uint64_t a, const Label &l) { return l + a; }
- // Note that int-Label isn't defined, as negating a Label is not an
- // operation we support.
- 
- // Conventions for representing larger numbers as sequences of bytes.
- enum Endianness {
-   kBigEndian,        // Big-endian: the most significant byte comes first.
-   kLittleEndian,     // Little-endian: the least significant byte comes first.
-   kUnsetEndian,      // used internally
-@@ -283,36 +283,36 @@
-     endianness_ = endianness;
-   }
- 
-   // Return the default endianness of this section.
-   Endianness endianness() const { return endianness_; }
- 
-   // Append the SIZE bytes at DATA or the contents of STRING to the
-   // end of this section. Return a reference to this section.
--  Section &Append(const u_int8_t *data, size_t size) {
-+  Section &Append(const uint8_t *data, size_t size) {
-     contents_.append(reinterpret_cast<const char *>(data), size);
-     return *this;
-   };
-   Section &Append(const string &data) {
-     contents_.append(data);
-     return *this;
-   };
- 
-   // Append SIZE copies of BYTE to the end of this section. Return a
-   // reference to this section.
--  Section &Append(size_t size, u_int8_t byte) {
-+  Section &Append(size_t size, uint8_t byte) {
-     contents_.append(size, (char) byte);
-     return *this;
-   }
-       
-   // Append NUMBER to this section. ENDIANNESS is the endianness to
-   // use to write the number. SIZE is the length of the number in
-   // bytes. Return a reference to this section.
--  Section &Append(Endianness endianness, size_t size, u_int64_t number);
-+  Section &Append(Endianness endianness, size_t size, uint64_t number);
-   Section &Append(Endianness endianness, size_t size, const Label &label);
- 
-   // Append SECTION to the end of this section. The labels SECTION
-   // refers to need not be defined yet.
-   //
-   // Note that this has no effect on any Labels' values, or on
-   // SECTION. If placing SECTION within 'this' provides new
-   // constraints on existing labels' values, then it's up to the
-@@ -347,22 +347,22 @@
-   //
-   // Since endianness doesn't matter for a single byte, all the
-   // <BITWIDTH>=8 functions are equivalent.
-   //
-   // These can be used to write both signed and unsigned values, as
-   // the compiler will properly sign-extend a signed value before
-   // passing it to the function, at which point the function's
-   // behavior is the same either way.
--  Section &L8(u_int8_t value) { contents_ += value; return *this; }
--  Section &B8(u_int8_t value) { contents_ += value; return *this; }
--  Section &D8(u_int8_t value) { contents_ += value; return *this; }
--  Section &L16(u_int16_t), &L32(u_int32_t), &L64(u_int64_t),
--          &B16(u_int16_t), &B32(u_int32_t), &B64(u_int64_t),
--          &D16(u_int16_t), &D32(u_int32_t), &D64(u_int64_t);
-+  Section &L8(uint8_t value) { contents_ += value; return *this; }
-+  Section &B8(uint8_t value) { contents_ += value; return *this; }
-+  Section &D8(uint8_t value) { contents_ += value; return *this; }
-+  Section &L16(uint16_t), &L32(uint32_t), &L64(uint64_t),
-+          &B16(uint16_t), &B32(uint32_t), &B64(uint64_t),
-+          &D16(uint16_t), &D32(uint32_t), &D64(uint64_t);
-   Section &L8(const Label &label),  &L16(const Label &label),
-           &L32(const Label &label), &L64(const Label &label),
-           &B8(const Label &label),  &B16(const Label &label),
-           &B32(const Label &label), &B64(const Label &label),
-           &D8(const Label &label),  &D16(const Label &label),
-           &D32(const Label &label), &D64(const Label &label);
- 
-   // Append VALUE in a signed LEB128 (Little-Endian Base 128) form.
-@@ -394,23 +394,23 @@
-   //   representation is a single byte whose value is N.
-   // 
-   // - Otherwise, its unsigned LEB128 representation is (N & 0x7f) |
-   //   0x80, followed by the unsigned LEB128 representation of N /
-   //   128, rounded towards negative infinity.
-   //
-   // Note that VALUE cannot be a Label (we would have to implement
-   // relaxation).
--  Section &ULEB128(u_int64_t value);
-+  Section &ULEB128(uint64_t value);
- 
-   // Jump to the next location aligned on an ALIGNMENT-byte boundary,
-   // relative to the start of the section. Fill the gap with PAD_BYTE.
-   // ALIGNMENT must be a power of two. Return a reference to this
-   // section.
--  Section &Align(size_t alignment, u_int8_t pad_byte = 0);
-+  Section &Align(size_t alignment, uint8_t pad_byte = 0);
- 
-   // Clear the contents of this section.
-   void Clear();
- 
-   // Return the current size of the section.
-   size_t Size() const { return contents_.size(); }
- 
-   // Return a label representing the start of the section.
-diff --git a/src/common/test_assembler_unittest.cc b/src/common/test_assembler_unittest.cc
---- a/src/common/test_assembler_unittest.cc
-+++ b/src/common/test_assembler_unittest.cc
-@@ -55,89 +55,89 @@
- 
- TEST(ConstructLabelDeathTest, Undefined) {
-   Label l;
-   ASSERT_DEATH(l.Value(), "IsKnownConstant\\(&v\\)");
- }
- 
- TEST(ConstructLabel, Constant) {
-   Label l(0x060b9f974eaf301eULL);
--  u_int64_t v;
-+  uint64_t v;
-   EXPECT_TRUE(l.IsKnownConstant(&v));
-   EXPECT_EQ(v, 0x060b9f974eaf301eULL);
-   EXPECT_EQ(l.Value(), 0x060b9f974eaf301eULL);
- }
- 
- TEST(ConstructLabel, Copy) {
-   Label l;
-   Label m(l);
--  u_int64_t v;
-+  uint64_t v;
-   EXPECT_TRUE(l.IsKnownOffsetFrom(m, &v));
-   EXPECT_EQ(0U, v);
- }
- 
- // The left-hand-side of a label assignment can be either
- // unconstrained, related, or known. The right-hand-side can be any of
- // those, or an integer.
- TEST(Assignment, UnconstrainedToUnconstrained) {
-   Label l, m;
-   l = m;
-   EXPECT_EQ(0U, l-m);
-   EXPECT_TRUE(l.IsKnownOffsetFrom(m));
--  u_int64_t d;
-+  uint64_t d;
-   EXPECT_TRUE(l.IsKnownOffsetFrom(m, &d));
-   EXPECT_EQ(0U, d);
-   EXPECT_FALSE(l.IsKnownConstant());
- }
- 
- TEST(Assignment, UnconstrainedToRelated) {
-   Label l, m, n;
-   l = n;
-   l = m;
-   EXPECT_EQ(0U, l-m);
-   EXPECT_TRUE(l.IsKnownOffsetFrom(m));
--  u_int64_t d;
-+  uint64_t d;
-   EXPECT_TRUE(l.IsKnownOffsetFrom(m, &d));
-   EXPECT_EQ(0U, d);
-   EXPECT_FALSE(l.IsKnownConstant());
- }
- 
- TEST(Assignment, UnconstrainedToKnown) {
-   Label l, m;
-   l = 0x8fd16e55b20a39c1ULL;
-   l = m;
-   EXPECT_EQ(0U, l-m);
-   EXPECT_TRUE(l.IsKnownOffsetFrom(m));
--  u_int64_t d;
-+  uint64_t d;
-   EXPECT_TRUE(l.IsKnownOffsetFrom(m, &d));
-   EXPECT_EQ(0U, d);
-   EXPECT_TRUE(m.IsKnownConstant());
-   EXPECT_EQ(0x8fd16e55b20a39c1ULL, m.Value());
- }
- 
- TEST(Assignment, RelatedToUnconstrained) {
-   Label l, m, n;
-   m = n;
-   l = m;
-   EXPECT_EQ(0U, l-n);
-   EXPECT_TRUE(l.IsKnownOffsetFrom(n));
--  u_int64_t d;
-+  uint64_t d;
-   EXPECT_TRUE(l.IsKnownOffsetFrom(n, &d));
-   EXPECT_EQ(0U, d);
-   EXPECT_FALSE(l.IsKnownConstant());
- }
- 
- TEST(Assignment, RelatedToRelated) {
-   Label l, m, n, o;
-   l = n;
-   m = o;
-   l = m;
-   EXPECT_EQ(0U, n-o);
-   EXPECT_TRUE(n.IsKnownOffsetFrom(o));
--  u_int64_t d;
-+  uint64_t d;
-   EXPECT_TRUE(n.IsKnownOffsetFrom(o, &d));
-   EXPECT_EQ(0U, d);
-   EXPECT_FALSE(l.IsKnownConstant());
- }
- 
- TEST(Assignment, RelatedToKnown) {
-   Label l, m, n;
-   m = n;
-@@ -229,72 +229,72 @@
-   o = n;
-   ASSERT_DEATH(o = l, "binding != this");
- }
- 
- TEST(Addition, LabelConstant) {
-   Label l, m;
-   m = l + 0x5248d93e8bbe9497ULL;
-   EXPECT_TRUE(m.IsKnownOffsetFrom(l));
--  u_int64_t d;
-+  uint64_t d;
-   EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
-   EXPECT_EQ(0x5248d93e8bbe9497ULL, d);
-   EXPECT_FALSE(m.IsKnownConstant());
- }
- 
- TEST(Addition, ConstantLabel) {
-   Label l, m;
-   m = 0xf51e94e00d6e3c84ULL + l;
-   EXPECT_TRUE(m.IsKnownOffsetFrom(l));
--  u_int64_t d;
-+  uint64_t d;
-   EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
-   EXPECT_EQ(0xf51e94e00d6e3c84ULL, d);
-   EXPECT_FALSE(m.IsKnownConstant());
- }
- 
- TEST(Addition, KnownLabelConstant) {
-   Label l, m;
-   l = 0x16286307042ce0d8ULL;
-   m = l + 0x3fdddd91306719d7ULL;
-   EXPECT_TRUE(m.IsKnownOffsetFrom(l));
--  u_int64_t d;
-+  uint64_t d;
-   EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
-   EXPECT_EQ(0x3fdddd91306719d7ULL, d);
-   EXPECT_TRUE(m.IsKnownConstant());
-   EXPECT_EQ(0x16286307042ce0d8ULL + 0x3fdddd91306719d7ULL, m.Value());
- }
- 
- TEST(Addition, ConstantKnownLabel) {
-   Label l, m;
-   l = 0x50f62d0cdd1031deULL;
-   m = 0x1b13462d8577c538ULL + l;
-   EXPECT_TRUE(m.IsKnownOffsetFrom(l));
--  u_int64_t d;
-+  uint64_t d;
-   EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
-   EXPECT_EQ(0x1b13462d8577c538ULL, d);
-   EXPECT_TRUE(m.IsKnownConstant());
-   EXPECT_EQ(0x50f62d0cdd1031deULL + 0x1b13462d8577c538ULL, m.Value());
- }
- 
- TEST(Subtraction, LabelConstant) {
-   Label l, m;
-   m = l - 0x0620884d21d3138eULL;
-   EXPECT_TRUE(m.IsKnownOffsetFrom(l));
--  u_int64_t d;
-+  uint64_t d;
-   EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
-   EXPECT_EQ(-0x0620884d21d3138eULL, d);
-   EXPECT_FALSE(m.IsKnownConstant());
- }
- 
- TEST(Subtraction, KnownLabelConstant) {
-   Label l, m;
-   l = 0x6237fbaf9ef7929eULL;
-   m = l - 0x317730995d2ab6eeULL;
-   EXPECT_TRUE(m.IsKnownOffsetFrom(l));
--  u_int64_t d;
-+  uint64_t d;
-   EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
-   EXPECT_EQ(-0x317730995d2ab6eeULL, d);
-   EXPECT_TRUE(m.IsKnownConstant());
-   EXPECT_EQ(0x6237fbaf9ef7929eULL - 0x317730995d2ab6eeULL, m.Value());
- }
- 
- TEST(SubtractionDeathTest, LabelLabel) {
-   Label l, m;
-@@ -470,59 +470,59 @@
- 
- TEST(LabelChain, AssignEndRelationBeforeForward) {
-   Label a, b, c, d;
-   Label x;
-   x = d;
-   b = a + 0x1;
-   c = b + 0x10;
-   d = c + 0x100;
--  EXPECT_EQ(-(u_int64_t)0x111U, a-x);
--  EXPECT_EQ(-(u_int64_t)0x110U, b-x);
--  EXPECT_EQ(-(u_int64_t)0x100U, c-x);
--  EXPECT_EQ(-(u_int64_t)0U,     d-x);
-+  EXPECT_EQ(-(uint64_t)0x111U, a-x);
-+  EXPECT_EQ(-(uint64_t)0x110U, b-x);
-+  EXPECT_EQ(-(uint64_t)0x100U, c-x);
-+  EXPECT_EQ(-(uint64_t)0U,     d-x);
- }
- 
- TEST(LabelChain, AssignEndRelationBeforeBackward) {
-   Label a, b, c, d;
-   Label x;
-   x = d;
-   d = c + 0x100;
-   c = b + 0x10;
-   b = a + 0x1;
--  EXPECT_EQ(-(u_int64_t)0x111U, a-x);
--  EXPECT_EQ(-(u_int64_t)0x110U, b-x);
--  EXPECT_EQ(-(u_int64_t)0x100U, c-x);
--  EXPECT_EQ(-(u_int64_t)0U,     d-x);
-+  EXPECT_EQ(-(uint64_t)0x111U, a-x);
-+  EXPECT_EQ(-(uint64_t)0x110U, b-x);
-+  EXPECT_EQ(-(uint64_t)0x100U, c-x);
-+  EXPECT_EQ(-(uint64_t)0U,     d-x);
- }
- 
- TEST(LabelChain, AssignEndRelationAfterForward) {
-   Label a, b, c, d;
-   Label x;
-   b = a + 0x1;
-   c = b + 0x10;
-   d = c + 0x100;
-   x = d;
--  EXPECT_EQ(-(u_int64_t)0x111U, a-x);
--  EXPECT_EQ(-(u_int64_t)0x110U, b-x);
--  EXPECT_EQ(-(u_int64_t)0x100U, c-x);
--  EXPECT_EQ(-(u_int64_t)0x000U, d-x);
-+  EXPECT_EQ(-(uint64_t)0x111U, a-x);
-+  EXPECT_EQ(-(uint64_t)0x110U, b-x);
-+  EXPECT_EQ(-(uint64_t)0x100U, c-x);
-+  EXPECT_EQ(-(uint64_t)0x000U, d-x);
- }
- 
- TEST(LabelChain, AssignEndRelationAfterBackward) {
-   Label a, b, c, d;
-   Label x;
-   d = c + 0x100;
-   c = b + 0x10;
-   b = a + 0x1;
-   x = d;
--  EXPECT_EQ(-(u_int64_t)0x111U, a-x);
--  EXPECT_EQ(-(u_int64_t)0x110U, b-x);
--  EXPECT_EQ(-(u_int64_t)0x100U, c-x);
--  EXPECT_EQ(-(u_int64_t)0x000U, d-x);
-+  EXPECT_EQ(-(uint64_t)0x111U, a-x);
-+  EXPECT_EQ(-(uint64_t)0x110U, b-x);
-+  EXPECT_EQ(-(uint64_t)0x100U, c-x);
-+  EXPECT_EQ(-(uint64_t)0x000U, d-x);
- }
- 
- TEST(LabelChain, AssignEndValueBeforeForward) {
-   Label a, b, c, d;
-   d = 0xa131200190546ac2ULL;
-   b = a + 0x1;
-   c = b + 0x10;
-   d = c + 0x100;
-@@ -618,20 +618,20 @@
- 
- TEST(LabelChain, ConstructEndRelationAfterForward) {
-   Label x;
-   Label a;
-   Label b(a + 0x1);
-   Label c(b + 0x10);
-   Label d(c + 0x100);
-   x = d;
--  EXPECT_EQ(-(u_int64_t)0x111U, a-x);
--  EXPECT_EQ(-(u_int64_t)0x110U, b-x);
--  EXPECT_EQ(-(u_int64_t)0x100U, c-x);
--  EXPECT_EQ(-(u_int64_t)0x000U, d-x);
-+  EXPECT_EQ(-(uint64_t)0x111U, a-x);
-+  EXPECT_EQ(-(uint64_t)0x110U, b-x);
-+  EXPECT_EQ(-(uint64_t)0x100U, c-x);
-+  EXPECT_EQ(-(uint64_t)0x000U, d-x);
- }
- 
- TEST(LabelChain, ConstructEndValueAfterForward) {
-   Label a;
-   Label b(a + 0x1);
-   Label c(b + 0x10);
-   Label d(c + 0x100);
-   d = 0x99b8f51bafd41adaULL;
-@@ -727,38 +727,38 @@
-   Section s(kBigEndian);
- }
- 
- // A fixture class for TestAssembler::Section tests.
- class SectionFixture {
-  public:
-   Section section;
-   string contents;
--  static const u_int8_t data[];
-+  static const uint8_t data[];
-   static const size_t data_size;
- };
- 
--const u_int8_t SectionFixture::data[] = {
-+const uint8_t SectionFixture::data[] = {
-   0x87, 0x4f, 0x43, 0x67, 0x30, 0xd0, 0xd4, 0x0e
- };
- 
- #define I0()
- #define I1(a) { a }
- #define I2(a,b) { a,b }
- #define I3(a,b,c) { a,b,c }
- #define I4(a,b,c,d) { a,b,c,d }
- #define I5(a,b,c,d,e) { a,b,c,d,e }
- #define I6(a,b,c,d,e,f) { a,b,c,d,e,f }
- #define I7(a,b,c,d,e,f,g) { a,b,c,d,e,f,g }
- #define I8(a,b,c,d,e,f,g,h) { a,b,c,d,e,f,g,h }
- #define I9(a,b,c,d,e,f,g,h,i) { a,b,c,d,e,f,g,h,i }
- #define ASSERT_BYTES(s, b)                                              \
-   do                                                                    \
-     {                                                                   \
--      static const u_int8_t expected_bytes[] = b;                       \
-+      static const uint8_t expected_bytes[] = b;                       \
-       ASSERT_EQ(sizeof(expected_bytes), s.size());                      \
-       ASSERT_TRUE(memcmp(s.data(), (const char *) expected_bytes,       \
-                          sizeof(expected_bytes)) == 0);                 \
-     }                                                                   \
-   while(0)
- 
- class Append: public SectionFixture, public Test { };
- 
-@@ -1356,17 +1356,17 @@
-   d = 0x163177f15a0eb4ecULL;
-   e = 0xbd1b0f1d977f2246ULL;
-   f = 0x2b0842eee83c6461ULL;
-   g = 0x92f4b928a4bf875eULL;
-   h = 0x61a199a8f7286ba6ULL;
-   ASSERT_EQ(8 * 18U, section.Size());
-   ASSERT_TRUE(section.GetContents(&contents));
- 
--  static const u_int8_t expected[] = {
-+  static const uint8_t expected[] = {
-     0x35,    0xa6, 0x6b, 0x28, 0xf7, 0xa8, 0x99, 0xa1, 0x61,
-     0x8b,    0x39, 0x44, 0x8f, 0x44, 0x40, 0x65, 0xa5, 0x0e,
-     0xc9, 0x1c,    0x5e, 0x87, 0xbf, 0xa4, 0x28, 0xb9, 0xf4,
-     0xcf, 0x15,    0x4a, 0x72, 0xc5, 0x04, 0x4f, 0x69, 0x29,
-     0x05, 0x86, 0x2f,    0x61, 0x64, 0x3c, 0xe8, 0xee, 0x42,
-     0x8c, 0x3f, 0xfd,    0x7a, 0x18, 0x80, 0xba, 0x11, 0x6f,
-     0x5a, 0x0e, 0xb4, 0xec,    0x46, 0x22, 0x7f, 0x97, 0x1d,
-     0x2f, 0xda, 0x24, 0x72,    0x3f, 0x42, 0x2d, 0xa0, 0x0a,
-diff --git a/src/google_breakpad/common/breakpad_types.h b/src/google_breakpad/common/breakpad_types.h
---- a/src/google_breakpad/common/breakpad_types.h
-+++ b/src/google_breakpad/common/breakpad_types.h
-@@ -26,57 +26,59 @@
-  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
- 
- /* breakpad_types.h: Precise-width types
-  *
-  * (This is C99 source, please don't corrupt it with C++.)
-  *
-- * This file ensures that types u_intN_t are defined for N = 8, 16, 32, and
-+ * This file ensures that types uintN_t are defined for N = 8, 16, 32, and
-  * 64.  Types of precise widths are crucial to the task of writing data
-  * structures on one platform and reading them on another.
-  *
-  * Author: Mark Mentovai */
- 
- #ifndef GOOGLE_BREAKPAD_COMMON_BREAKPAD_TYPES_H__
- #define GOOGLE_BREAKPAD_COMMON_BREAKPAD_TYPES_H__
- 
- #ifndef _WIN32
- 
--#include <sys/types.h>
- #ifndef __STDC_FORMAT_MACROS
- #define __STDC_FORMAT_MACROS
- #endif  /* __STDC_FORMAT_MACROS */
- #include <inttypes.h>
- 
--#if defined(__SUNPRO_CC) || (defined(__GNUC__) && defined(__sun__))
--typedef uint8_t u_int8_t;
--typedef uint16_t u_int16_t;
--typedef uint32_t u_int32_t;
--typedef uint64_t u_int64_t;
--#endif
--
- #else  /* !_WIN32 */
- 
-+#if _MSC_VER >= 1600
-+#include <stdint.h>
-+#elif defined(BREAKPAD_CUSTOM_STDINT_H)
-+/* Visual C++ Pre-2010 did not ship a stdint.h, so allow
-+ * consumers of this library to provide their own because
-+ * there are often subtle type incompatibilities.
-+ */
-+#include BREAKPAD_CUSTOM_STDINT_H
-+#else
- #include <WTypes.h>
- 
--typedef unsigned __int8  u_int8_t;
--typedef unsigned __int16 u_int16_t;
--typedef unsigned __int32 u_int32_t;
--typedef unsigned __int64 u_int64_t;
-+typedef unsigned __int8  uint8_t;
-+typedef unsigned __int16 uint16_t;
-+typedef unsigned __int32 uint32_t;
-+typedef unsigned __int64 uint64_t;
-+#endif
- 
- #endif  /* !_WIN32 */
- 
- typedef struct {
--  u_int64_t high;
--  u_int64_t low;
--} u_int128_t;
-+  uint64_t high;
-+  uint64_t low;
-+} uint128_t;
- 
--typedef u_int64_t breakpad_time_t;
-+typedef uint64_t breakpad_time_t;
- 
- /* Try to get PRIx64 from inttypes.h, but if it's not defined, fall back to
-  * llx, which is the format string for "long long" - this is a 64-bit
-  * integral type on many systems. */
- #ifndef PRIx64
- #define PRIx64 "llx"
- #endif  /* !PRIx64 */
- 
-diff --git a/src/google_breakpad/common/minidump_cpu_amd64.h b/src/google_breakpad/common/minidump_cpu_amd64.h
---- a/src/google_breakpad/common/minidump_cpu_amd64.h
-+++ b/src/google_breakpad/common/minidump_cpu_amd64.h
-@@ -74,134 +74,134 @@
- #define GOOGLE_BREAKPAD_COMMON_MINIDUMP_CPU_AMD64_H__
- 
- 
- /*
-  * AMD64 support, see WINNT.H
-  */
- 
- typedef struct {
--  u_int16_t  control_word;
--  u_int16_t  status_word;
--  u_int8_t   tag_word;
--  u_int8_t   reserved1;
--  u_int16_t  error_opcode;
--  u_int32_t  error_offset;
--  u_int16_t  error_selector;
--  u_int16_t  reserved2;
--  u_int32_t  data_offset;
--  u_int16_t  data_selector;
--  u_int16_t  reserved3;
--  u_int32_t  mx_csr;
--  u_int32_t  mx_csr_mask;
--  u_int128_t float_registers[8];
--  u_int128_t xmm_registers[16];
--  u_int8_t   reserved4[96];
-+  uint16_t  control_word;
-+  uint16_t  status_word;
-+  uint8_t   tag_word;
-+  uint8_t   reserved1;
-+  uint16_t  error_opcode;
-+  uint32_t  error_offset;
-+  uint16_t  error_selector;
-+  uint16_t  reserved2;
-+  uint32_t  data_offset;
-+  uint16_t  data_selector;
-+  uint16_t  reserved3;
-+  uint32_t  mx_csr;
-+  uint32_t  mx_csr_mask;
-+  uint128_t float_registers[8];
-+  uint128_t xmm_registers[16];
-+  uint8_t   reserved4[96];
- } MDXmmSaveArea32AMD64;  /* XMM_SAVE_AREA32 */
- 
- #define MD_CONTEXT_AMD64_VR_COUNT 26
- 
- typedef struct {
-   /*
-    * Register parameter home addresses.
-    */
--  u_int64_t  p1_home;
--  u_int64_t  p2_home;
--  u_int64_t  p3_home;
--  u_int64_t  p4_home;
--  u_int64_t  p5_home;
--  u_int64_t  p6_home;
-+  uint64_t  p1_home;
-+  uint64_t  p2_home;
-+  uint64_t  p3_home;
-+  uint64_t  p4_home;
-+  uint64_t  p5_home;
-+  uint64_t  p6_home;
- 
-   /* The next field determines the layout of the structure, and which parts
-    * of it are populated */
--  u_int32_t  context_flags;
--  u_int32_t  mx_csr;
-+  uint32_t  context_flags;
-+  uint32_t  mx_csr;
- 
-   /* The next register is included with MD_CONTEXT_AMD64_CONTROL */
--  u_int16_t  cs;
-+  uint16_t  cs;
- 
-   /* The next 4 registers are included with MD_CONTEXT_AMD64_SEGMENTS */
--  u_int16_t  ds;
--  u_int16_t  es;
--  u_int16_t  fs;
--  u_int16_t  gs;
-+  uint16_t  ds;
-+  uint16_t  es;
-+  uint16_t  fs;
-+  uint16_t  gs;
- 
-   /* The next 2 registers are included with MD_CONTEXT_AMD64_CONTROL */
--  u_int16_t  ss;
--  u_int32_t  eflags;
-+  uint16_t  ss;
-+  uint32_t  eflags;
-   
-   /* The next 6 registers are included with MD_CONTEXT_AMD64_DEBUG_REGISTERS */
--  u_int64_t  dr0;
--  u_int64_t  dr1;
--  u_int64_t  dr2;
--  u_int64_t  dr3;
--  u_int64_t  dr6;
--  u_int64_t  dr7;
-+  uint64_t  dr0;
-+  uint64_t  dr1;
-+  uint64_t  dr2;
-+  uint64_t  dr3;
-+  uint64_t  dr6;
-+  uint64_t  dr7;
- 
-   /* The next 4 registers are included with MD_CONTEXT_AMD64_INTEGER */
--  u_int64_t  rax;
--  u_int64_t  rcx;
--  u_int64_t  rdx;
--  u_int64_t  rbx;
-+  uint64_t  rax;
-+  uint64_t  rcx;
-+  uint64_t  rdx;
-+  uint64_t  rbx;
- 
-   /* The next register is included with MD_CONTEXT_AMD64_CONTROL */
--  u_int64_t  rsp;
-+  uint64_t  rsp;
- 
-   /* The next 11 registers are included with MD_CONTEXT_AMD64_INTEGER */
--  u_int64_t  rbp;
--  u_int64_t  rsi;
--  u_int64_t  rdi;
--  u_int64_t  r8;
--  u_int64_t  r9;
--  u_int64_t  r10;
--  u_int64_t  r11;
--  u_int64_t  r12;
--  u_int64_t  r13;
--  u_int64_t  r14;
--  u_int64_t  r15;
-+  uint64_t  rbp;
-+  uint64_t  rsi;
-+  uint64_t  rdi;
-+  uint64_t  r8;
-+  uint64_t  r9;
-+  uint64_t  r10;
-+  uint64_t  r11;
-+  uint64_t  r12;
-+  uint64_t  r13;
-+  uint64_t  r14;
-+  uint64_t  r15;
- 
-   /* The next register is included with MD_CONTEXT_AMD64_CONTROL */
--  u_int64_t  rip;
-+  uint64_t  rip;
- 
-   /* The next set of registers are included with
-    * MD_CONTEXT_AMD64_FLOATING_POINT
-    */
-   union {
-     MDXmmSaveArea32AMD64 flt_save;
-     struct {
--      u_int128_t header[2];
--      u_int128_t legacy[8];
--      u_int128_t xmm0;
--      u_int128_t xmm1;
--      u_int128_t xmm2;
--      u_int128_t xmm3;
--      u_int128_t xmm4;
--      u_int128_t xmm5;
--      u_int128_t xmm6;
--      u_int128_t xmm7;
--      u_int128_t xmm8;
--      u_int128_t xmm9;
--      u_int128_t xmm10;
--      u_int128_t xmm11;
--      u_int128_t xmm12;
--      u_int128_t xmm13;
--      u_int128_t xmm14;
--      u_int128_t xmm15;
-+      uint128_t header[2];
-+      uint128_t legacy[8];
-+      uint128_t xmm0;
-+      uint128_t xmm1;
-+      uint128_t xmm2;
-+      uint128_t xmm3;
-+      uint128_t xmm4;
-+      uint128_t xmm5;
-+      uint128_t xmm6;
-+      uint128_t xmm7;
-+      uint128_t xmm8;
-+      uint128_t xmm9;
-+      uint128_t xmm10;
-+      uint128_t xmm11;
-+      uint128_t xmm12;
-+      uint128_t xmm13;
-+      uint128_t xmm14;
-+      uint128_t xmm15;
-     } sse_registers;
-   };
- 
--  u_int128_t vector_register[MD_CONTEXT_AMD64_VR_COUNT];
--  u_int64_t  vector_control;
-+  uint128_t vector_register[MD_CONTEXT_AMD64_VR_COUNT];
-+  uint64_t  vector_control;
- 
-   /* The next 5 registers are included with MD_CONTEXT_AMD64_DEBUG_REGISTERS */
--  u_int64_t debug_control;
--  u_int64_t last_branch_to_rip;
--  u_int64_t last_branch_from_rip;
--  u_int64_t last_exception_to_rip;
--  u_int64_t last_exception_from_rip;
-+  uint64_t debug_control;
-+  uint64_t last_branch_to_rip;
-+  uint64_t last_branch_from_rip;
-+  uint64_t last_exception_to_rip;
-+  uint64_t last_exception_from_rip;
-   
- } MDRawContextAMD64;  /* CONTEXT */
- 
- /* For (MDRawContextAMD64).context_flags.  These values indicate the type of
-  * context stored in the structure.  The high 24 bits identify the CPU, the
-  * low 8 bits identify the type of context saved. */
- #define MD_CONTEXT_AMD64 0x00100000  /* CONTEXT_AMD64 */
- #define MD_CONTEXT_AMD64_CONTROL         (MD_CONTEXT_AMD64 | 0x00000001)
-diff --git a/src/google_breakpad/common/minidump_cpu_arm.h b/src/google_breakpad/common/minidump_cpu_arm.h
---- a/src/google_breakpad/common/minidump_cpu_arm.h
-+++ b/src/google_breakpad/common/minidump_cpu_arm.h
-@@ -72,49 +72,49 @@
- /*
-  * Note that these structures *do not* map directly to the CONTEXT
-  * structure defined in WinNT.h in the Windows Mobile SDK. That structure
-  * does not accomodate VFPv3, and I'm unsure if it was ever used in the
-  * wild anyway, as Windows CE only seems to produce "cedumps" which
-  * are not exactly minidumps.
-  */
- typedef struct {
--  u_int64_t	fpscr;      /* FPU status register */
-+  uint64_t	fpscr;      /* FPU status register */
- 
-   /* 32 64-bit floating point registers, d0 .. d31. */
--  u_int64_t	regs[MD_FLOATINGSAVEAREA_ARM_FPR_COUNT];
-+  uint64_t	regs[MD_FLOATINGSAVEAREA_ARM_FPR_COUNT];
- 
-   /* Miscellaneous control words */
--  u_int32_t     extra[MD_FLOATINGSAVEAREA_ARM_FPEXTRA_COUNT];
-+  uint32_t     extra[MD_FLOATINGSAVEAREA_ARM_FPEXTRA_COUNT];
- } MDFloatingSaveAreaARM;
- 
- #define MD_CONTEXT_ARM_GPR_COUNT 16
- 
- typedef struct {
-   /* The next field determines the layout of the structure, and which parts
-    * of it are populated
-    */
--  u_int32_t	context_flags;
-+  uint32_t	context_flags;
- 
-   /* 16 32-bit integer registers, r0 .. r15
-    * Note the following fixed uses:
-    *   r13 is the stack pointer
-    *   r14 is the link register
-    *   r15 is the program counter
-    */
--  u_int32_t     iregs[MD_CONTEXT_ARM_GPR_COUNT];
-+  uint32_t     iregs[MD_CONTEXT_ARM_GPR_COUNT];
- 
-   /* CPSR (flags, basically): 32 bits:
-         bit 31 - N (negative)
-         bit 30 - Z (zero)
-         bit 29 - C (carry)
-         bit 28 - V (overflow)
-         bit 27 - Q (saturation flag, sticky)
-      All other fields -- ignore */
--  u_int32_t    cpsr;
-+  uint32_t    cpsr;
- 
-   /* The next field is included with MD_CONTEXT_ARM_FLOATING_POINT */
-   MDFloatingSaveAreaARM float_save;
- 
- } MDRawContextARM;
- 
- /* Indices into iregs for registers with a dedicated or conventional 
-  * purpose.
-diff --git a/src/google_breakpad/common/minidump_cpu_ppc.h b/src/google_breakpad/common/minidump_cpu_ppc.h
---- a/src/google_breakpad/common/minidump_cpu_ppc.h
-+++ b/src/google_breakpad/common/minidump_cpu_ppc.h
-@@ -76,34 +76,34 @@
-  */
- 
- #ifndef GOOGLE_BREAKPAD_COMMON_MINIDUMP_CPU_PPC_H__
- #define GOOGLE_BREAKPAD_COMMON_MINIDUMP_CPU_PPC_H__
- 
- #define MD_FLOATINGSAVEAREA_PPC_FPR_COUNT 32
- 
- typedef struct {
--  /* fpregs is a double[32] in mach/ppc/_types.h, but a u_int64_t is used
-+  /* fpregs is a double[32] in mach/ppc/_types.h, but a uint64_t is used
-    * here for precise sizing. */
--  u_int64_t fpregs[MD_FLOATINGSAVEAREA_PPC_FPR_COUNT];
--  u_int32_t fpscr_pad;
--  u_int32_t fpscr;      /* Status/control */
-+  uint64_t fpregs[MD_FLOATINGSAVEAREA_PPC_FPR_COUNT];
-+  uint32_t fpscr_pad;
-+  uint32_t fpscr;      /* Status/control */
- } MDFloatingSaveAreaPPC;  /* Based on ppc_float_state */
- 
- 
- #define MD_VECTORSAVEAREA_PPC_VR_COUNT 32
- 
- typedef struct {
-   /* Vector registers (including vscr) are 128 bits, but mach/ppc/_types.h
-    * exposes them as four 32-bit quantities. */
--  u_int128_t save_vr[MD_VECTORSAVEAREA_PPC_VR_COUNT];
--  u_int128_t save_vscr;  /* Status/control */
--  u_int32_t  save_pad5[4];
--  u_int32_t  save_vrvalid;  /* Identifies which vector registers are saved */
--  u_int32_t  save_pad6[7];
-+  uint128_t save_vr[MD_VECTORSAVEAREA_PPC_VR_COUNT];
-+  uint128_t save_vscr;  /* Status/control */
-+  uint32_t  save_pad5[4];
-+  uint32_t  save_vrvalid;  /* Identifies which vector registers are saved */
-+  uint32_t  save_pad6[7];
- } MDVectorSaveAreaPPC;  /* ppc_vector_state */
- 
- 
- #define MD_CONTEXT_PPC_GPR_COUNT 32
- 
- /* Use the same 32-bit alignment when accessing this structure from 64-bit code
-  * as is used natively in 32-bit code.  #pragma pack is a MSVC extension
-  * supported by gcc. */
-@@ -112,31 +112,31 @@
- #else
- #pragma pack(push, 4)
- #endif
- 
- typedef struct {
-   /* context_flags is not present in ppc_thread_state, but it aids
-    * identification of MDRawContextPPC among other raw context types,
-    * and it guarantees alignment when we get to float_save. */
--  u_int32_t             context_flags;
-+  uint32_t             context_flags;
- 
--  u_int32_t             srr0;    /* Machine status save/restore: stores pc
-+  uint32_t             srr0;    /* Machine status save/restore: stores pc
-                                   * (instruction) */
--  u_int32_t             srr1;    /* Machine status save/restore: stores msr
-+  uint32_t             srr1;    /* Machine status save/restore: stores msr
-                                   * (ps, program/machine state) */
-   /* ppc_thread_state contains 32 fields, r0 .. r31.  Here, an array is
-    * used for brevity. */
--  u_int32_t             gpr[MD_CONTEXT_PPC_GPR_COUNT];
--  u_int32_t             cr;      /* Condition */
--  u_int32_t             xer;     /* Integer (fiXed-point) exception */
--  u_int32_t             lr;      /* Link */
--  u_int32_t             ctr;     /* Count */
--  u_int32_t             mq;      /* Multiply/Quotient (PPC 601, POWER only) */
--  u_int32_t             vrsave;  /* Vector save */
-+  uint32_t             gpr[MD_CONTEXT_PPC_GPR_COUNT];
-+  uint32_t             cr;      /* Condition */
-+  uint32_t             xer;     /* Integer (fiXed-point) exception */
-+  uint32_t             lr;      /* Link */
-+  uint32_t             ctr;     /* Count */
-+  uint32_t             mq;      /* Multiply/Quotient (PPC 601, POWER only) */
-+  uint32_t             vrsave;  /* Vector save */
- 
-   /* float_save and vector_save aren't present in ppc_thread_state, but
-    * are represented in separate structures that still define a thread's
-    * context. */
-   MDFloatingSaveAreaPPC float_save;
-   MDVectorSaveAreaPPC   vector_save;
- } MDRawContextPPC;  /* Based on ppc_thread_state */
- 
-diff --git a/src/google_breakpad/common/minidump_cpu_ppc64.h b/src/google_breakpad/common/minidump_cpu_ppc64.h
---- a/src/google_breakpad/common/minidump_cpu_ppc64.h
-+++ b/src/google_breakpad/common/minidump_cpu_ppc64.h
-@@ -85,30 +85,30 @@
- typedef MDVectorSaveAreaPPC MDVectorSaveAreaPPC64;
- 
- #define MD_CONTEXT_PPC64_GPR_COUNT MD_CONTEXT_PPC_GPR_COUNT
- 
- typedef struct {
-   /* context_flags is not present in ppc_thread_state, but it aids
-    * identification of MDRawContextPPC among other raw context types,
-    * and it guarantees alignment when we get to float_save. */
--  u_int64_t             context_flags;
-+  uint64_t             context_flags;
- 
--  u_int64_t             srr0;    /* Machine status save/restore: stores pc
-+  uint64_t             srr0;    /* Machine status save/restore: stores pc
-                                   * (instruction) */
--  u_int64_t             srr1;    /* Machine status save/restore: stores msr
-+  uint64_t             srr1;    /* Machine status save/restore: stores msr
-                                   * (ps, program/machine state) */
-   /* ppc_thread_state contains 32 fields, r0 .. r31.  Here, an array is
-    * used for brevity. */
--  u_int64_t             gpr[MD_CONTEXT_PPC64_GPR_COUNT];
--  u_int64_t             cr;      /* Condition */
--  u_int64_t             xer;     /* Integer (fiXed-point) exception */
--  u_int64_t             lr;      /* Link */
--  u_int64_t             ctr;     /* Count */
--  u_int64_t             vrsave;  /* Vector save */
-+  uint64_t             gpr[MD_CONTEXT_PPC64_GPR_COUNT];
-+  uint64_t             cr;      /* Condition */
-+  uint64_t             xer;     /* Integer (fiXed-point) exception */
-+  uint64_t             lr;      /* Link */
-+  uint64_t             ctr;     /* Count */
-+  uint64_t             vrsave;  /* Vector save */
- 
-   /* float_save and vector_save aren't present in ppc_thread_state, but
-    * are represented in separate structures that still define a thread's
-    * context. */
-   MDFloatingSaveAreaPPC float_save;
-   MDVectorSaveAreaPPC   vector_save;
- } MDRawContextPPC64;  /* Based on ppc_thread_state */
- 
-diff --git a/src/google_breakpad/common/minidump_cpu_sparc.h b/src/google_breakpad/common/minidump_cpu_sparc.h
---- a/src/google_breakpad/common/minidump_cpu_sparc.h
-+++ b/src/google_breakpad/common/minidump_cpu_sparc.h
-@@ -77,66 +77,66 @@
- #ifndef GOOGLE_BREAKPAD_COMMON_MINIDUMP_CPU_SPARC_H__
- #define GOOGLE_BREAKPAD_COMMON_MINIDUMP_CPU_SPARC_H__
- 
- #define MD_FLOATINGSAVEAREA_SPARC_FPR_COUNT 32
- 
- typedef struct {
- 
-   /* FPU floating point regs */
--  u_int64_t	regs[MD_FLOATINGSAVEAREA_SPARC_FPR_COUNT];
-+  uint64_t	regs[MD_FLOATINGSAVEAREA_SPARC_FPR_COUNT];
- 
--  u_int64_t	filler;
--  u_int64_t	fsr;        /* FPU status register */
-+  uint64_t	filler;
-+  uint64_t	fsr;        /* FPU status register */
- } MDFloatingSaveAreaSPARC;  /* FLOATING_SAVE_AREA */
- 
- #define MD_CONTEXT_SPARC_GPR_COUNT 32
- 
- typedef struct {
-   /* The next field determines the layout of the structure, and which parts
-    * of it are populated
-    */
--  u_int32_t	context_flags;
--  u_int32_t	flag_pad;
-+  uint32_t	context_flags;
-+  uint32_t	flag_pad;
-   /*
-    * General register access (SPARC).
-    * Don't confuse definitions here with definitions in <sys/regset.h>.
-    * Registers are 32 bits for ILP32, 64 bits for LP64.
-    * SPARC V7/V8 is for 32bit, SPARC V9 is for 64bit
-    */
- 
-   /* 32 Integer working registers */
- 
-   /* g_r[0-7]   global registers(g0-g7)
-    * g_r[8-15]  out registers(o0-o7)
-    * g_r[16-23] local registers(l0-l7)
-    * g_r[24-31] in registers(i0-i7)
-    */
--  u_int64_t     g_r[MD_CONTEXT_SPARC_GPR_COUNT];
-+  uint64_t     g_r[MD_CONTEXT_SPARC_GPR_COUNT];
- 
-   /* several control registers */
- 
-   /* Processor State register(PSR) for SPARC V7/V8
-    * Condition Code register (CCR) for SPARC V9
-    */
--  u_int64_t     ccr;
-+  uint64_t     ccr;
- 
--  u_int64_t     pc;     /* Program Counter register (PC) */
--  u_int64_t     npc;    /* Next Program Counter register (nPC) */
--  u_int64_t     y;      /* Y register (Y) */
-+  uint64_t     pc;     /* Program Counter register (PC) */
-+  uint64_t     npc;    /* Next Program Counter register (nPC) */
-+  uint64_t     y;      /* Y register (Y) */
- 
-   /* Address Space Identifier register (ASI) for SPARC V9
-    * WIM for SPARC V7/V8
-    */
--  u_int64_t     asi;
-+  uint64_t     asi;
- 
-   /* Floating-Point Registers State register (FPRS) for SPARC V9
-    * TBR for for SPARC V7/V8
-    */
--  u_int64_t     fprs;
-+  uint64_t     fprs;
- 
-   /* The next field is included with MD_CONTEXT_SPARC_FLOATING_POINT */
-   MDFloatingSaveAreaSPARC float_save;
- 
- } MDRawContextSPARC;  /* CONTEXT_SPARC */
- 
- /* For (MDRawContextSPARC).context_flags.  These values indicate the type of
-  * context stored in the structure.  MD_CONTEXT_SPARC is Breakpad-defined.  Its
-diff --git a/src/google_breakpad/common/minidump_cpu_x86.h b/src/google_breakpad/common/minidump_cpu_x86.h
---- a/src/google_breakpad/common/minidump_cpu_x86.h
-+++ b/src/google_breakpad/common/minidump_cpu_x86.h
-@@ -71,77 +71,77 @@
- 
- #ifndef GOOGLE_BREAKPAD_COMMON_MINIDUMP_CPU_X86_H__
- #define GOOGLE_BREAKPAD_COMMON_MINIDUMP_CPU_X86_H__
- 
- #define MD_FLOATINGSAVEAREA_X86_REGISTERAREA_SIZE 80
-      /* SIZE_OF_80387_REGISTERS */
- 
- typedef struct {
--  u_int32_t control_word;
--  u_int32_t status_word;
--  u_int32_t tag_word;
--  u_int32_t error_offset;
--  u_int32_t error_selector;
--  u_int32_t data_offset;
--  u_int32_t data_selector;
-+  uint32_t control_word;
-+  uint32_t status_word;
-+  uint32_t tag_word;
-+  uint32_t error_offset;
-+  uint32_t error_selector;
-+  uint32_t data_offset;
-+  uint32_t data_selector;
- 
-   /* register_area contains eight 80-bit (x87 "long double") quantities for
-    * floating-point registers %st0 (%mm0) through %st7 (%mm7). */
--  u_int8_t  register_area[MD_FLOATINGSAVEAREA_X86_REGISTERAREA_SIZE];
--  u_int32_t cr0_npx_state;
-+  uint8_t  register_area[MD_FLOATINGSAVEAREA_X86_REGISTERAREA_SIZE];
-+  uint32_t cr0_npx_state;
- } MDFloatingSaveAreaX86;  /* FLOATING_SAVE_AREA */
- 
- 
- #define MD_CONTEXT_X86_EXTENDED_REGISTERS_SIZE 512
-      /* MAXIMUM_SUPPORTED_EXTENSION */
- 
- typedef struct {
-   /* The next field determines the layout of the structure, and which parts
-    * of it are populated */
--  u_int32_t             context_flags;
-+  uint32_t             context_flags;
- 
-   /* The next 6 registers are included with MD_CONTEXT_X86_DEBUG_REGISTERS */
--  u_int32_t             dr0;
--  u_int32_t             dr1;
--  u_int32_t             dr2;
--  u_int32_t             dr3;
--  u_int32_t             dr6;
--  u_int32_t             dr7;
-+  uint32_t             dr0;
-+  uint32_t             dr1;
-+  uint32_t             dr2;
-+  uint32_t             dr3;
-+  uint32_t             dr6;
-+  uint32_t             dr7;
- 
-   /* The next field is included with MD_CONTEXT_X86_FLOATING_POINT */
-   MDFloatingSaveAreaX86 float_save;
- 
-   /* The next 4 registers are included with MD_CONTEXT_X86_SEGMENTS */
--  u_int32_t             gs; 
--  u_int32_t             fs;
--  u_int32_t             es;
--  u_int32_t             ds;
-+  uint32_t             gs; 
-+  uint32_t             fs;
-+  uint32_t             es;
-+  uint32_t             ds;
-   /* The next 6 registers are included with MD_CONTEXT_X86_INTEGER */
--  u_int32_t             edi;
--  u_int32_t             esi;
--  u_int32_t             ebx;
--  u_int32_t             edx;
--  u_int32_t             ecx;
--  u_int32_t             eax;
-+  uint32_t             edi;
-+  uint32_t             esi;
-+  uint32_t             ebx;
-+  uint32_t             edx;
-+  uint32_t             ecx;
-+  uint32_t             eax;
- 
-   /* The next 6 registers are included with MD_CONTEXT_X86_CONTROL */
--  u_int32_t             ebp;
--  u_int32_t             eip;
--  u_int32_t             cs;      /* WinNT.h says "must be sanitized" */
--  u_int32_t             eflags;  /* WinNT.h says "must be sanitized" */
--  u_int32_t             esp;
--  u_int32_t             ss;
-+  uint32_t             ebp;
-+  uint32_t             eip;
-+  uint32_t             cs;      /* WinNT.h says "must be sanitized" */
-+  uint32_t             eflags;  /* WinNT.h says "must be sanitized" */
-+  uint32_t             esp;
-+  uint32_t             ss;
- 
-   /* The next field is included with MD_CONTEXT_X86_EXTENDED_REGISTERS.
-    * It contains vector (MMX/SSE) registers.  It it laid out in the
-    * format used by the fxsave and fsrstor instructions, so it includes
-    * a copy of the x87 floating-point registers as well.  See FXSAVE in
-    * "Intel Architecture Software Developer's Manual, Volume 2." */
--  u_int8_t              extended_registers[
-+  uint8_t              extended_registers[
-                          MD_CONTEXT_X86_EXTENDED_REGISTERS_SIZE];
- } MDRawContextX86;  /* CONTEXT */
- 
- /* For (MDRawContextX86).context_flags.  These values indicate the type of
-  * context stored in the structure.  The high 24 bits identify the CPU, the
-  * low 8 bits identify the type of context saved. */
- #define MD_CONTEXT_X86                    0x00010000
-      /* CONTEXT_i386, CONTEXT_i486: identifies CPU */
-diff --git a/src/google_breakpad/common/minidump_format.h b/src/google_breakpad/common/minidump_format.h
---- a/src/google_breakpad/common/minidump_format.h
-+++ b/src/google_breakpad/common/minidump_format.h
-@@ -74,20 +74,20 @@
- #endif  /* _MSC_VER */
- 
- 
- /*
-  * guiddef.h
-  */
- 
- typedef struct {
--  u_int32_t data1;
--  u_int16_t data2;
--  u_int16_t data3;
--  u_int8_t  data4[8];
-+  uint32_t data1;
-+  uint16_t data2;
-+  uint16_t data3;
-+  uint8_t  data4[8];
- } MDGUID;  /* GUID */
- 
- 
- /*
-  * WinNT.h
-  */
- 
- /* Non-x86 CPU identifiers found in the high 24 bits of
-@@ -105,45 +105,45 @@
-  * http://msdn.microsoft.com/en-us/library/hh134238%28v=vs.85%29.aspx */
- #define MD_CONTEXT_CPU_MASK 0xffffff00
- 
- 
- /* This is a base type for MDRawContextX86 and MDRawContextPPC.  This
-  * structure should never be allocated directly.  The actual structure type
-  * can be determined by examining the context_flags field. */
- typedef struct {
--  u_int32_t context_flags;
-+  uint32_t context_flags;
- } MDRawContextBase;
- 
- #include "minidump_cpu_amd64.h"
- #include "minidump_cpu_arm.h"
- #include "minidump_cpu_ppc.h"
- #include "minidump_cpu_ppc64.h"
- #include "minidump_cpu_sparc.h"
- #include "minidump_cpu_x86.h"
- 
- /*
-  * WinVer.h
-  */
- 
- 
- typedef struct {
--  u_int32_t signature;
--  u_int32_t struct_version;
--  u_int32_t file_version_hi;
--  u_int32_t file_version_lo;
--  u_int32_t product_version_hi;
--  u_int32_t product_version_lo;
--  u_int32_t file_flags_mask;    /* Identifies valid bits in fileFlags */
--  u_int32_t file_flags;
--  u_int32_t file_os;
--  u_int32_t file_type;
--  u_int32_t file_subtype;
--  u_int32_t file_date_hi;
--  u_int32_t file_date_lo;
-+  uint32_t signature;
-+  uint32_t struct_version;
-+  uint32_t file_version_hi;
-+  uint32_t file_version_lo;
-+  uint32_t product_version_hi;
-+  uint32_t product_version_lo;
-+  uint32_t file_flags_mask;    /* Identifies valid bits in fileFlags */
-+  uint32_t file_flags;
-+  uint32_t file_os;
-+  uint32_t file_type;
-+  uint32_t file_subtype;
-+  uint32_t file_date_hi;
-+  uint32_t file_date_lo;
- } MDVSFixedFileInfo;  /* VS_FIXEDFILEINFO */
- 
- /* For (MDVSFixedFileInfo).signature */
- #define MD_VSFIXEDFILEINFO_SIGNATURE 0xfeef04bd
-      /* VS_FFI_SIGNATURE */
- 
- /* For (MDVSFixedFileInfo).version */
- #define MD_VSFIXEDFILEINFO_VERSION 0x00010000
-@@ -226,43 +226,43 @@
- 
- /*
-  * DbgHelp.h
-  */
- 
- 
- /* An MDRVA is an offset into the minidump file.  The beginning of the
-  * MDRawHeader is at offset 0. */
--typedef u_int32_t MDRVA;  /* RVA */
-+typedef uint32_t MDRVA;  /* RVA */
- 
- typedef struct {
--  u_int32_t data_size;
-+  uint32_t data_size;
-   MDRVA     rva;
- } MDLocationDescriptor;  /* MINIDUMP_LOCATION_DESCRIPTOR */
- 
- 
- typedef struct {
-   /* The base address of the memory range on the host that produced the
-    * minidump. */
--  u_int64_t            start_of_memory_range;
-+  uint64_t            start_of_memory_range;
- 
-   MDLocationDescriptor memory;
- } MDMemoryDescriptor;  /* MINIDUMP_MEMORY_DESCRIPTOR */
- 
- 
- typedef struct {
--  u_int32_t signature;
--  u_int32_t version;
--  u_int32_t stream_count;
-+  uint32_t signature;
-+  uint32_t version;
-+  uint32_t stream_count;
-   MDRVA     stream_directory_rva;  /* A |stream_count|-sized array of
-                                     * MDRawDirectory structures. */
--  u_int32_t checksum;              /* Can be 0.  In fact, that's all that's
-+  uint32_t checksum;              /* Can be 0.  In fact, that's all that's
-                                     * been found in minidump files. */
--  u_int32_t time_date_stamp;       /* time_t */
--  u_int64_t flags;
-+  uint32_t time_date_stamp;       /* time_t */
-+  uint64_t flags;
- } MDRawHeader;  /* MINIDUMP_HEADER */
- 
- /* For (MDRawHeader).signature and (MDRawHeader).version.  Note that only the
-  * low 16 bits of (MDRawHeader).version are MD_HEADER_VERSION.  Per the
-  * documentation, the high 16 bits are implementation-specific. */
- #define MD_HEADER_SIGNATURE 0x504d444d /* 'PMDM' */
-      /* MINIDUMP_SIGNATURE */
- #define MD_HEADER_VERSION   0x0000a793 /* 42899 */
-@@ -297,17 +297,17 @@
-   MD_WITH_FULL_AUXILLIARY_STATE        = 0x00008000,
-   MD_WITH_PRIVATE_WRITE_COPY_MEMORY    = 0x00010000,
-   MD_IGNORE_INACCESSIBLE_MEMORY        = 0x00020000,
-   MD_WITH_TOKEN_INFORMATION            = 0x00040000
- } MDType;  /* MINIDUMP_TYPE */
- 
- 
- typedef struct {
--  u_int32_t            stream_type;
-+  uint32_t            stream_type;
-   MDLocationDescriptor location;
- } MDRawDirectory;  /* MINIDUMP_DIRECTORY */
- 
- /* For (MDRawDirectory).stream_type */
- typedef enum {
-   MD_UNUSED_STREAM               =  0,
-   MD_RESERVED_STREAM_0           =  1,
-   MD_RESERVED_STREAM_1           =  2,
-@@ -341,49 +341,49 @@
-   MD_LINUX_ENVIRON               = 0x47670007,  /* /proc/$x/environ   */
-   MD_LINUX_AUXV                  = 0x47670008,  /* /proc/$x/auxv      */
-   MD_LINUX_MAPS                  = 0x47670009,  /* /proc/$x/maps      */
-   MD_LINUX_DSO_DEBUG             = 0x4767000A   /* MDRawDebug         */
- } MDStreamType;  /* MINIDUMP_STREAM_TYPE */
- 
- 
- typedef struct {
--  u_int32_t length;     /* Length of buffer in bytes (not characters),
-+  uint32_t length;     /* Length of buffer in bytes (not characters),
-                          * excluding 0-terminator */
--  u_int16_t buffer[1];  /* UTF-16-encoded, 0-terminated */
-+  uint16_t buffer[1];  /* UTF-16-encoded, 0-terminated */
- } MDString;  /* MINIDUMP_STRING */
- 
- static const size_t MDString_minsize = offsetof(MDString, buffer[0]);
- 
- 
- typedef struct {
--  u_int32_t            thread_id;
--  u_int32_t            suspend_count;
--  u_int32_t            priority_class;
--  u_int32_t            priority;
--  u_int64_t            teb;             /* Thread environment block */
-+  uint32_t            thread_id;
-+  uint32_t            suspend_count;
-+  uint32_t            priority_class;
-+  uint32_t            priority;
-+  uint64_t            teb;             /* Thread environment block */
-   MDMemoryDescriptor   stack;
-   MDLocationDescriptor thread_context;  /* MDRawContext[CPU] */
- } MDRawThread;  /* MINIDUMP_THREAD */
- 
- 
- typedef struct {
--  u_int32_t   number_of_threads;
-+  uint32_t   number_of_threads;
-   MDRawThread threads[1];
- } MDRawThreadList;  /* MINIDUMP_THREAD_LIST */
- 
- static const size_t MDRawThreadList_minsize = offsetof(MDRawThreadList,
-                                                        threads[0]);
- 
- 
- typedef struct {
--  u_int64_t            base_of_image;
--  u_int32_t            size_of_image;
--  u_int32_t            checksum;         /* 0 if unknown */
--  u_int32_t            time_date_stamp;  /* time_t */
-+  uint64_t            base_of_image;
-+  uint32_t            size_of_image;
-+  uint32_t            checksum;         /* 0 if unknown */
-+  uint32_t            time_date_stamp;  /* time_t */
-   MDRVA                module_name_rva;  /* MDString, pathname or filename */
-   MDVSFixedFileInfo    version_info;
- 
-   /* The next field stores a CodeView record and is populated when a module's
-    * debug information resides in a PDB file.  It identifies the PDB file. */
-   MDLocationDescriptor cv_record;
- 
-   /* The next field is populated when a module's debug information resides
-@@ -397,69 +397,69 @@
-    * specifies full alignment of 64-bit quantities in structures (as ppc
-    * does), there will be padding between miscRecord and reserved0.  If
-    * 64-bit quantities can be aligned on 32-bit boundaries (as on x86),
-    * this padding will not exist.  (Note that the structure up to this point
-    * contains 1 64-bit member followed by 21 32-bit members.)
-    * As a workaround, reserved0 and reserved1 are instead defined here as
-    * four 32-bit quantities.  This should be harmless, as there are
-    * currently no known uses for these fields. */
--  u_int32_t            reserved0[2];
--  u_int32_t            reserved1[2];
-+  uint32_t            reserved0[2];
-+  uint32_t            reserved1[2];
- } MDRawModule;  /* MINIDUMP_MODULE */
- 
- /* The inclusion of a 64-bit type in MINIDUMP_MODULE forces the struct to
-  * be tail-padded out to a multiple of 64 bits under some ABIs (such as PPC).
-  * This doesn't occur on systems that don't tail-pad in this manner.  Define
-  * this macro to be the usable size of the MDRawModule struct, and use it in
-  * place of sizeof(MDRawModule). */
- #define MD_MODULE_SIZE 108
- 
- 
- /* (MDRawModule).cv_record can reference MDCVInfoPDB20 or MDCVInfoPDB70.
-  * Ref.: http://www.debuginfo.com/articles/debuginfomatch.html
-  * MDCVInfoPDB70 is the expected structure type with recent toolchains. */
- 
- typedef struct {
--  u_int32_t signature;
--  u_int32_t offset;     /* Offset to debug data (expect 0 in minidump) */
-+  uint32_t signature;
-+  uint32_t offset;     /* Offset to debug data (expect 0 in minidump) */
- } MDCVHeader;
- 
- typedef struct {
-   MDCVHeader cv_header;
--  u_int32_t  signature;         /* time_t debug information created */
--  u_int32_t  age;               /* revision of PDB file */
--  u_int8_t   pdb_file_name[1];  /* Pathname or filename of PDB file */
-+  uint32_t  signature;         /* time_t debug information created */
-+  uint32_t  age;               /* revision of PDB file */
-+  uint8_t   pdb_file_name[1];  /* Pathname or filename of PDB file */
- } MDCVInfoPDB20;
- 
- static const size_t MDCVInfoPDB20_minsize = offsetof(MDCVInfoPDB20,
-                                                      pdb_file_name[0]);
- 
- #define MD_CVINFOPDB20_SIGNATURE 0x3031424e  /* cvHeader.signature = '01BN' */
- 
- typedef struct {
--  u_int32_t cv_signature;
-+  uint32_t cv_signature;
-   MDGUID    signature;         /* GUID, identifies PDB file */
--  u_int32_t age;               /* Identifies incremental changes to PDB file */
--  u_int8_t  pdb_file_name[1];  /* Pathname or filename of PDB file,
-+  uint32_t age;               /* Identifies incremental changes to PDB file */
-+  uint8_t  pdb_file_name[1];  /* Pathname or filename of PDB file,
-                                 * 0-terminated 8-bit character data (UTF-8?) */
- } MDCVInfoPDB70;
- 
- static const size_t MDCVInfoPDB70_minsize = offsetof(MDCVInfoPDB70,
-                                                      pdb_file_name[0]);
- 
- #define MD_CVINFOPDB70_SIGNATURE 0x53445352  /* cvSignature = 'SDSR' */
- 
- typedef struct {
--  u_int32_t data1[2];
--  u_int32_t data2;
--  u_int32_t data3;
--  u_int32_t data4;
--  u_int32_t data5[3];
--  u_int8_t extra[2];
-+  uint32_t data1[2];
-+  uint32_t data2;
-+  uint32_t data3;
-+  uint32_t data4;
-+  uint32_t data5[3];
-+  uint8_t extra[2];
- } MDCVInfoELF;
- 
- /* In addition to the two CodeView record formats above, used for linking
-  * to external pdb files, it is possible for debugging data to be carried
-  * directly in the CodeView record itself.  These signature values will
-  * be found in the first 4 bytes of the CodeView record.  Additional values
-  * not commonly experienced in the wild are given by "Microsoft Symbol and
-  * Type Information", http://www.x86.org/ftp/manuals/tools/sym.pdf, section
-@@ -474,121 +474,121 @@
- 
- #define MD_CVINFOUNKNOWN_SIGNATURE 0xffffffff  /* An unlikely value. */
- 
- /* (MDRawModule).miscRecord can reference MDImageDebugMisc.  The Windows
-  * structure is actually defined in WinNT.h.  This structure is effectively
-  * obsolete with modules built by recent toolchains. */
- 
- typedef struct {
--  u_int32_t data_type;    /* IMAGE_DEBUG_TYPE_*, not defined here because
-+  uint32_t data_type;    /* IMAGE_DEBUG_TYPE_*, not defined here because
-                            * this debug record type is mostly obsolete. */
--  u_int32_t length;       /* Length of entire MDImageDebugMisc structure */
--  u_int8_t  unicode;      /* True if data is multibyte */
--  u_int8_t  reserved[3];
--  u_int8_t  data[1];
-+  uint32_t length;       /* Length of entire MDImageDebugMisc structure */
-+  uint8_t  unicode;      /* True if data is multibyte */
-+  uint8_t  reserved[3];
-+  uint8_t  data[1];
- } MDImageDebugMisc;  /* IMAGE_DEBUG_MISC */
- 
- static const size_t MDImageDebugMisc_minsize = offsetof(MDImageDebugMisc,
-                                                         data[0]);
- 
- 
- typedef struct {
--  u_int32_t   number_of_modules;
-+  uint32_t   number_of_modules;
-   MDRawModule modules[1];
- } MDRawModuleList;  /* MINIDUMP_MODULE_LIST */
- 
- static const size_t MDRawModuleList_minsize = offsetof(MDRawModuleList,
-                                                        modules[0]);
- 
- 
- typedef struct {
--  u_int32_t          number_of_memory_ranges;
-+  uint32_t          number_of_memory_ranges;
-   MDMemoryDescriptor memory_ranges[1];
- } MDRawMemoryList;  /* MINIDUMP_MEMORY_LIST */
- 
- static const size_t MDRawMemoryList_minsize = offsetof(MDRawMemoryList,
-                                                        memory_ranges[0]);
- 
- 
- #define MD_EXCEPTION_MAXIMUM_PARAMETERS 15
- 
- typedef struct {
--  u_int32_t exception_code;     /* Windows: MDExceptionCodeWin,
-+  uint32_t exception_code;     /* Windows: MDExceptionCodeWin,
-                                  * Mac OS X: MDExceptionMac,
-                                  * Linux: MDExceptionCodeLinux. */
--  u_int32_t exception_flags;    /* Windows: 1 if noncontinuable,
-+  uint32_t exception_flags;    /* Windows: 1 if noncontinuable,
-                                    Mac OS X: MDExceptionCodeMac. */
--  u_int64_t exception_record;   /* Address (in the minidump-producing host's
-+  uint64_t exception_record;   /* Address (in the minidump-producing host's
-                                  * memory) of another MDException, for
-                                  * nested exceptions. */
--  u_int64_t exception_address;  /* The address that caused the exception.
-+  uint64_t exception_address;  /* The address that caused the exception.
-                                  * Mac OS X: exception subcode (which is
-                                  *           typically the address). */
--  u_int32_t number_parameters;  /* Number of valid elements in
-+  uint32_t number_parameters;  /* Number of valid elements in
-                                  * exception_information. */
--  u_int32_t __align;
--  u_int64_t exception_information[MD_EXCEPTION_MAXIMUM_PARAMETERS];
-+  uint32_t __align;
-+  uint64_t exception_information[MD_EXCEPTION_MAXIMUM_PARAMETERS];
- } MDException;  /* MINIDUMP_EXCEPTION */
- 
- #include "minidump_exception_win32.h"
- #include "minidump_exception_mac.h"
- #include "minidump_exception_linux.h"
- #include "minidump_exception_solaris.h"
- 
- typedef struct {
--  u_int32_t            thread_id;         /* Thread in which the exception
-+  uint32_t            thread_id;         /* Thread in which the exception
-                                            * occurred.  Corresponds to
-                                            * (MDRawThread).thread_id. */
--  u_int32_t            __align;
-+  uint32_t            __align;
-   MDException          exception_record;
-   MDLocationDescriptor thread_context;    /* MDRawContext[CPU] */
- } MDRawExceptionStream;  /* MINIDUMP_EXCEPTION_STREAM */
- 
- 
- typedef union {
-   struct {
--    u_int32_t vendor_id[3];               /* cpuid 0: ebx, edx, ecx */
--    u_int32_t version_information;        /* cpuid 1: eax */
--    u_int32_t feature_information;        /* cpuid 1: edx */
--    u_int32_t amd_extended_cpu_features;  /* cpuid 0x80000001, ebx */
-+    uint32_t vendor_id[3];               /* cpuid 0: ebx, edx, ecx */
-+    uint32_t version_information;        /* cpuid 1: eax */
-+    uint32_t feature_information;        /* cpuid 1: edx */
-+    uint32_t amd_extended_cpu_features;  /* cpuid 0x80000001, ebx */
-   } x86_cpu_info;
-   struct {
--    u_int64_t processor_features[2];
-+    uint64_t processor_features[2];
-   } other_cpu_info;
- } MDCPUInformation;  /* CPU_INFORMATION */
- 
- 
- typedef struct {
-   /* The next 3 fields and numberOfProcessors are from the SYSTEM_INFO
-    * structure as returned by GetSystemInfo */
--  u_int16_t        processor_architecture;
--  u_int16_t        processor_level;         /* x86: 5 = 586, 6 = 686, ... */
--  u_int16_t        processor_revision;      /* x86: 0xMMSS, where MM=model,
-+  uint16_t        processor_architecture;
-+  uint16_t        processor_level;         /* x86: 5 = 586, 6 = 686, ... */
-+  uint16_t        processor_revision;      /* x86: 0xMMSS, where MM=model,
-                                              *      SS=stepping */
- 
--  u_int8_t         number_of_processors;
--  u_int8_t         product_type;            /* Windows: VER_NT_* from WinNT.h */
-+  uint8_t         number_of_processors;
-+  uint8_t         product_type;            /* Windows: VER_NT_* from WinNT.h */
- 
-   /* The next 5 fields are from the OSVERSIONINFO structure as returned
-    * by GetVersionEx */
--  u_int32_t        major_version;
--  u_int32_t        minor_version;
--  u_int32_t        build_number;
--  u_int32_t        platform_id;
-+  uint32_t        major_version;
-+  uint32_t        minor_version;
-+  uint32_t        build_number;
-+  uint32_t        platform_id;
-   MDRVA            csd_version_rva;  /* MDString further identifying the
-                                       * host OS.
-                                       * Windows: name of the installed OS
-                                       *          service pack.
-                                       * Mac OS X: the Apple OS build number
-                                       *           (sw_vers -buildVersion).
-                                       * Linux: uname -srvmo */
- 
--  u_int16_t        suite_mask;       /* Windows: VER_SUITE_* from WinNT.h */
--  u_int16_t        reserved2;
-+  uint16_t        suite_mask;       /* Windows: VER_SUITE_* from WinNT.h */
-+  uint16_t        reserved2;
- 
-   MDCPUInformation cpu;
- } MDRawSystemInfo;  /* MINIDUMP_SYSTEM_INFO */
- 
- /* For (MDRawSystemInfo).processor_architecture: */
- typedef enum {
-   MD_CPU_ARCHITECTURE_X86       =  0,  /* PROCESSOR_ARCHITECTURE_INTEL */
-   MD_CPU_ARCHITECTURE_MIPS      =  1,  /* PROCESSOR_ARCHITECTURE_MIPS */
-@@ -622,39 +622,39 @@
-   MD_OS_IOS           = 0x8102,  /* iOS */
-   MD_OS_LINUX         = 0x8201,  /* Linux */
-   MD_OS_SOLARIS       = 0x8202,  /* Solaris */
-   MD_OS_ANDROID       = 0x8203   /* Android */
- } MDOSPlatform;
- 
- 
- typedef struct {
--  u_int32_t size_of_info;  /* Length of entire MDRawMiscInfo structure. */
--  u_int32_t flags1;
-+  uint32_t size_of_info;  /* Length of entire MDRawMiscInfo structure. */
-+  uint32_t flags1;
- 
-   /* The next field is only valid if flags1 contains
-    * MD_MISCINFO_FLAGS1_PROCESS_ID. */
--  u_int32_t process_id;
-+  uint32_t process_id;
- 
-   /* The next 3 fields are only valid if flags1 contains
-    * MD_MISCINFO_FLAGS1_PROCESS_TIMES. */
--  u_int32_t process_create_time;  /* time_t process started */
--  u_int32_t process_user_time;    /* seconds of user CPU time */
--  u_int32_t process_kernel_time;  /* seconds of kernel CPU time */
-+  uint32_t process_create_time;  /* time_t process started */
-+  uint32_t process_user_time;    /* seconds of user CPU time */
-+  uint32_t process_kernel_time;  /* seconds of kernel CPU time */
- 
-   /* The following fields are not present in MINIDUMP_MISC_INFO but are
-    * in MINIDUMP_MISC_INFO_2.  When this struct is populated, these values
-    * may not be set.  Use flags1 or sizeOfInfo to determine whether these
-    * values are present.  These are only valid when flags1 contains
-    * MD_MISCINFO_FLAGS1_PROCESSOR_POWER_INFO. */
--  u_int32_t processor_max_mhz;
--  u_int32_t processor_current_mhz;
--  u_int32_t processor_mhz_limit;
--  u_int32_t processor_max_idle_state;
--  u_int32_t processor_current_idle_state;
-+  uint32_t processor_max_mhz;
-+  uint32_t processor_current_mhz;
-+  uint32_t processor_mhz_limit;
-+  uint32_t processor_max_idle_state;
-+  uint32_t processor_current_idle_state;
- } MDRawMiscInfo;  /* MINIDUMP_MISC_INFO, MINIDUMP_MISC_INFO2 */
- 
- #define MD_MISCINFO_SIZE 24
- #define MD_MISCINFO2_SIZE 44
- 
- /* For (MDRawMiscInfo).flags1.  These values indicate which fields in the
-  * MDRawMiscInfoStructure are valid. */
- typedef enum {
-@@ -672,34 +672,34 @@
-  * represent the variable-length data to including explicit
-  * "size of header", "size of entry" and "number of entries" fields
-  * in the header, presumably to allow backwards-compatibly-extending
-  * the structures in the future. The actual list entries follow the
-  * header data directly in this case.
-  */
- 
- typedef struct {
--  u_int32_t size_of_header;    /* sizeof(MDRawMemoryInfoList) */
--  u_int32_t size_of_entry;     /* sizeof(MDRawMemoryInfo) */
--  u_int64_t number_of_entries;
-+  uint32_t size_of_header;    /* sizeof(MDRawMemoryInfoList) */
-+  uint32_t size_of_entry;     /* sizeof(MDRawMemoryInfo) */
-+  uint64_t number_of_entries;
- } MDRawMemoryInfoList;  /* MINIDUMP_MEMORY_INFO_LIST */
- 
- typedef struct {
--  u_int64_t base_address;           /* Base address of a region of pages */
--  u_int64_t allocation_base;        /* Base address of a range of pages
-+  uint64_t base_address;           /* Base address of a region of pages */
-+  uint64_t allocation_base;        /* Base address of a range of pages
-                                      * within this region. */
--  u_int32_t allocation_protection;  /* Memory protection when this region
-+  uint32_t allocation_protection;  /* Memory protection when this region
-                                      * was originally allocated:
-                                      * MDMemoryProtection */
--  u_int32_t __alignment1;
--  u_int64_t region_size;
--  u_int32_t state;                  /* MDMemoryState */
--  u_int32_t protection;             /* MDMemoryProtection */
--  u_int32_t type;                   /* MDMemoryType */
--  u_int32_t __alignment2;
-+  uint32_t __alignment1;
-+  uint64_t region_size;
-+  uint32_t state;                  /* MDMemoryState */
-+  uint32_t protection;             /* MDMemoryProtection */
-+  uint32_t type;                   /* MDMemoryType */
-+  uint32_t __alignment2;
- } MDRawMemoryInfo;  /* MINIDUMP_MEMORY_INFO */
- 
- /* For (MDRawMemoryInfo).state */
- typedef enum {
-   MD_MEMORY_STATE_COMMIT   = 0x1000,  /* physical storage has been allocated */
-   MD_MEMORY_STATE_RESERVE  = 0x2000,  /* reserved, but no physical storage */
-   MD_MEMORY_STATE_FREE     = 0x10000  /* available to be allocated */
- } MDMemoryState;
-@@ -716,55 +716,55 @@
-   MD_MEMORY_PROTECT_EXECUTE_WRITECOPY = 0x80,  /* PAGE_EXECUTE_WRITECOPY */
-   /* These options can be combined with the previous flags. */
-   MD_MEMORY_PROTECT_GUARD             = 0x100,  /* PAGE_GUARD */
-   MD_MEMORY_PROTECT_NOCACHE           = 0x200,  /* PAGE_NOCACHE */
-   MD_MEMORY_PROTECT_WRITECOMBINE      = 0x400,  /* PAGE_WRITECOMBINE */
- } MDMemoryProtection;
- 
- /* Used to mask the mutually exclusive options from the combinable flags. */
--const u_int32_t MD_MEMORY_PROTECTION_ACCESS_MASK = 0xFF;
-+const uint32_t MD_MEMORY_PROTECTION_ACCESS_MASK = 0xFF;
- 
- /* For (MDRawMemoryInfo).type */
- typedef enum {
-   MD_MEMORY_TYPE_PRIVATE = 0x20000,   /* not shared by other processes */
-   MD_MEMORY_TYPE_MAPPED  = 0x40000,   /* mapped into the view of a section */
-   MD_MEMORY_TYPE_IMAGE   = 0x1000000  /* mapped into the view of an image */
- } MDMemoryType;
- 
- /*
-  * Breakpad extension types
-  */
- 
- 
- typedef struct {
-   /* validity is a bitmask with values from MDBreakpadInfoValidity, indicating
-    * which of the other fields in the structure are valid. */
--  u_int32_t validity;
-+  uint32_t validity;
- 
-   /* Thread ID of the handler thread.  dump_thread_id should correspond to
-    * the thread_id of an MDRawThread in the minidump's MDRawThreadList if
-    * a dedicated thread in that list was used to produce the minidump.  If
-    * the MDRawThreadList does not contain a dedicated thread used to produce
-    * the minidump, this field should be set to 0 and the validity field
-    * must not contain MD_BREAKPAD_INFO_VALID_DUMP_THREAD_ID. */
--  u_int32_t dump_thread_id;
-+  uint32_t dump_thread_id;
- 
-   /* Thread ID of the thread that requested the minidump be produced.  As
-    * with dump_thread_id, requesting_thread_id should correspond to the
-    * thread_id of an MDRawThread in the minidump's MDRawThreadList.  For
-    * minidumps produced as a result of an exception, requesting_thread_id
-    * will be the same as the MDRawExceptionStream's thread_id field.  For
-    * minidumps produced "manually" at the program's request,
-    * requesting_thread_id will indicate which thread caused the dump to be
-    * written.  If the minidump was produced at the request of something
-    * other than a thread in the MDRawThreadList, this field should be set
-    * to 0 and the validity field must not contain
-    * MD_BREAKPAD_INFO_VALID_REQUESTING_THREAD_ID. */
--  u_int32_t requesting_thread_id;
-+  uint32_t requesting_thread_id;
- } MDRawBreakpadInfo;
- 
- /* For (MDRawBreakpadInfo).validity: */
- typedef enum {
-   /* When set, the dump_thread_id field is valid. */
-   MD_BREAKPAD_INFO_VALID_DUMP_THREAD_ID       = 1 << 0,
- 
-   /* When set, the requesting_thread_id field is valid. */
-@@ -772,21 +772,21 @@
- } MDBreakpadInfoValidity;
- 
- typedef struct {
-   /* expression, function, and file are 0-terminated UTF-16 strings.  They
-    * may be truncated if necessary, but should always be 0-terminated when
-    * written to a file.
-    * Fixed-length strings are used because MiniDumpWriteDump doesn't offer
-    * a way for user streams to point to arbitrary RVAs for strings. */
--  u_int16_t expression[128];  /* Assertion that failed... */
--  u_int16_t function[128];    /* ...within this function... */
--  u_int16_t file[128];        /* ...in this file... */
--  u_int32_t line;             /* ...at this line. */
--  u_int32_t type;
-+  uint16_t expression[128];  /* Assertion that failed... */
-+  uint16_t function[128];    /* ...within this function... */
-+  uint16_t file[128];        /* ...in this file... */
-+  uint32_t line;             /* ...at this line. */
-+  uint32_t type;
- } MDRawAssertionInfo;
- 
- /* For (MDRawAssertionInfo).type: */
- typedef enum {
-   MD_ASSERTION_INFO_TYPE_UNKNOWN = 0,
- 
-   /* Used for assertions that would be raised by the MSVC CRT but are
-    * directed to an invalid parameter handler instead. */
-@@ -801,19 +801,19 @@
-  * which is necessary for converting minidumps to usable coredumps. */
- typedef struct {
-   void*     addr;
-   MDRVA     name;
-   void*     ld;
- } MDRawLinkMap;
- 
- typedef struct {
--  u_int32_t version;
-+  uint32_t version;
-   MDRVA     map;
--  u_int32_t dso_count;
-+  uint32_t dso_count;
-   void*     brk;
-   void*     ldbase;
-   void*     dynamic;
- } MDRawDebug;
- 
- #if defined(_MSC_VER)
- #pragma warning(pop)
- #endif  /* _MSC_VER */
-diff --git a/src/google_breakpad/processor/code_module.h b/src/google_breakpad/processor/code_module.h
---- a/src/google_breakpad/processor/code_module.h
-+++ b/src/google_breakpad/processor/code_module.h
-@@ -42,21 +42,21 @@
- 
- namespace google_breakpad {
- 
- class CodeModule {
-  public:
-   virtual ~CodeModule() {}
- 
-   // The base address of this code module as it was loaded by the process.
--  // (u_int64_t)-1 on error.
--  virtual u_int64_t base_address() const = 0;
-+  // (uint64_t)-1 on error.
-+  virtual uint64_t base_address() const = 0;
- 
-   // The size of the code module.  0 on error.
--  virtual u_int64_t size() const = 0;
-+  virtual uint64_t size() const = 0;
- 
-   // The path or file name that the code module was loaded from.  Empty on
-   // error.
-   virtual string code_file() const = 0;
- 
-   // An identifying string used to discriminate between multiple versions and
-   // builds of the same code module.  This may contain a uuid, timestamp,
-   // version number, or any combination of this or other information, in an
-diff --git a/src/google_breakpad/processor/code_modules.h b/src/google_breakpad/processor/code_modules.h
---- a/src/google_breakpad/processor/code_modules.h
-+++ b/src/google_breakpad/processor/code_modules.h
-@@ -48,17 +48,17 @@
-   // The number of contained CodeModule objects.
-   virtual unsigned int module_count() const = 0;
- 
-   // Random access to modules.  Returns the module whose code is present
-   // at the address indicated by |address|.  If no module is present at this
-   // address, returns NULL.  Ownership of the returned CodeModule is retained
-   // by the CodeModules object; pointers returned by this method are valid for
-   // comparison with pointers returned by the other Get methods.
--  virtual const CodeModule* GetModuleForAddress(u_int64_t address) const = 0;
-+  virtual const CodeModule* GetModuleForAddress(uint64_t address) const = 0;
- 
-   // Returns the module corresponding to the main executable.  If there is
-   // no main executable, returns NULL.  Ownership of the returned CodeModule
-   // is retained by the CodeModules object; pointers returned by this method
-   // are valid for comparison with pointers returned by the other Get
-   // methods.
-   virtual const CodeModule* GetMainModule() const = 0;
- 
-diff --git a/src/google_breakpad/processor/exploitability.h b/src/google_breakpad/processor/exploitability.h
---- a/src/google_breakpad/processor/exploitability.h
-+++ b/src/google_breakpad/processor/exploitability.h
-@@ -49,17 +49,17 @@
- class Exploitability {
-  public:
-   virtual ~Exploitability() {}
- 
-   static Exploitability *ExploitabilityForPlatform(Minidump *dump,
-                                                    ProcessState *process_state);
- 
-   ExploitabilityRating CheckExploitability();
--  bool AddressIsAscii(u_int64_t);
-+  bool AddressIsAscii(uint64_t);
- 
-  protected:
-   Exploitability(Minidump *dump,
-                  ProcessState *process_state);
- 
-   Minidump *dump_;
-   ProcessState *process_state_;
-   SystemInfo *system_info_;
-diff --git a/src/google_breakpad/processor/memory_region.h b/src/google_breakpad/processor/memory_region.h
---- a/src/google_breakpad/processor/memory_region.h
-+++ b/src/google_breakpad/processor/memory_region.h
-@@ -45,32 +45,32 @@
- namespace google_breakpad {
- 
- 
- class MemoryRegion {
-  public:
-   virtual ~MemoryRegion() {}
- 
-   // The base address of this memory region.
--  virtual u_int64_t GetBase() const = 0;
-+  virtual uint64_t GetBase() const = 0;
- 
-   // The size of this memory region.
--  virtual u_int32_t GetSize() const = 0;
-+  virtual uint32_t GetSize() const = 0;
- 
-   // Access to data of various sizes within the memory region.  address
-   // is a pointer to read, and it must lie within the memory region as
-   // defined by its base address and size.  The location pointed to by
-   // value is set to the value at address.  Byte-swapping is performed
-   // if necessary so that the value is appropriate for the running
-   // program.  Returns true on success.  Fails and returns false if address
-   // is out of the region's bounds (after considering the width of value),
-   // or for other types of errors.
--  virtual bool GetMemoryAtAddress(u_int64_t address, u_int8_t*  value) const =0;
--  virtual bool GetMemoryAtAddress(u_int64_t address, u_int16_t* value) const =0;
--  virtual bool GetMemoryAtAddress(u_int64_t address, u_int32_t* value) const =0;
--  virtual bool GetMemoryAtAddress(u_int64_t address, u_int64_t* value) const =0;
-+  virtual bool GetMemoryAtAddress(uint64_t address, uint8_t*  value) const =0;
-+  virtual bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const =0;
-+  virtual bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const =0;
-+  virtual bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const =0;
- };
- 
- 
- }  // namespace google_breakpad
- 
- 
- #endif  // GOOGLE_BREAKPAD_PROCESSOR_MEMORY_REGION_H__
-diff --git a/src/google_breakpad/processor/minidump.h b/src/google_breakpad/processor/minidump.h
---- a/src/google_breakpad/processor/minidump.h
-+++ b/src/google_breakpad/processor/minidump.h
-@@ -149,17 +149,17 @@
-  private:
-   // Populate (and validate) the MinidumpStream.  minidump_ is expected
-   // to be positioned at the beginning of the stream, so that the next
-   // read from the minidump will be at the beginning of the stream.
-   // expected_size should be set to the stream's length as contained in
-   // the MDRawDirectory record or other identifying record.  A class
-   // that implements MinidumpStream can compare expected_size to a
-   // known size as an integrity check.
--  virtual bool Read(u_int32_t expected_size) = 0;
-+  virtual bool Read(uint32_t expected_size) = 0;
- };
- 
- 
- // MinidumpContext carries a CPU-specific MDRawContext structure, which
- // contains CPU context such as register states.  Each thread has its
- // own context, and the exception record, if present, also has its own
- // context.  Note that if the exception record is present, the context it
- // refers to is probably what the user wants to use for the exception
-@@ -171,21 +171,21 @@
- class MinidumpContext : public MinidumpStream {
-  public:
-   virtual ~MinidumpContext();
- 
-   // Returns an MD_CONTEXT_* value such as MD_CONTEXT_X86 or MD_CONTEXT_PPC
-   // identifying the CPU type that the context was collected from.  The
-   // returned value will identify the CPU only, and will have any other
-   // MD_CONTEXT_* bits masked out.  Returns 0 on failure.
--  u_int32_t GetContextCPU() const;
-+  uint32_t GetContextCPU() const;
- 
-   // A convenience method to get the instruction pointer out of the
-   // MDRawContext, since it varies per-CPU architecture.
--  bool GetInstructionPointer(u_int64_t* ip) const;
-+  bool GetInstructionPointer(uint64_t* ip) const;
- 
-   // Returns raw CPU-specific context data for the named CPU type.  If the
-   // context data does not match the CPU type or does not exist, returns
-   // NULL.
-   const MDRawContextAMD64* GetContextAMD64() const;
-   const MDRawContextARM*   GetContextARM() const;
-   const MDRawContextPPC*   GetContextPPC() const;
-   const MDRawContextSPARC* GetContextSPARC() const;
-@@ -205,100 +205,100 @@
-     MDRawContextAMD64* amd64;
-     // on Solaris SPARC, sparc is defined as a numeric constant,
-     // so variables can NOT be named as sparc
-     MDRawContextSPARC* ctx_sparc;
-     MDRawContextARM*   arm;
-   } context_;
- 
-   // Store this separately because of the weirdo AMD64 context
--  u_int32_t context_flags_;
-+  uint32_t context_flags_;
- 
-  private:
-   friend class MinidumpThread;
-   friend class MinidumpException;
- 
--  bool Read(u_int32_t expected_size);
-+  bool Read(uint32_t expected_size);
- 
-   // Free the CPU-specific context structure.
-   void FreeContext();
- 
-   // If the minidump contains a SYSTEM_INFO_STREAM, makes sure that the
-   // system info stream gives an appropriate CPU type matching the context
-   // CPU type in context_cpu_type.  Returns false if the CPU type does not
-   // match.  Returns true if the CPU type matches or if the minidump does
-   // not contain a system info stream.
--  bool CheckAgainstSystemInfo(u_int32_t context_cpu_type);
-+  bool CheckAgainstSystemInfo(uint32_t context_cpu_type);
- };
- 
- 
- // MinidumpMemoryRegion does not wrap any MDRaw structure, and only contains
- // a reference to an MDMemoryDescriptor.  This object is intended to wrap
- // portions of a minidump file that contain memory dumps.  In normal
- // minidumps, each MinidumpThread owns a MinidumpMemoryRegion corresponding
- // to the thread's stack memory.  MinidumpMemoryList also gives access to
- // memory regions in its list as MinidumpMemoryRegions.  This class
- // adheres to MemoryRegion so that it may be used as a data provider to
- // the Stackwalker family of classes.
- class MinidumpMemoryRegion : public MinidumpObject,
-                              public MemoryRegion {
-  public:
-   virtual ~MinidumpMemoryRegion();
- 
--  static void set_max_bytes(u_int32_t max_bytes) { max_bytes_ = max_bytes; }
--  static u_int32_t max_bytes() { return max_bytes_; }
-+  static void set_max_bytes(uint32_t max_bytes) { max_bytes_ = max_bytes; }
-+  static uint32_t max_bytes() { return max_bytes_; }
- 
-   // Returns a pointer to the base of the memory region.  Returns the
-   // cached value if available, otherwise, reads the minidump file and
-   // caches the memory region.
--  const u_int8_t* GetMemory() const;
-+  const uint8_t* GetMemory() const;
- 
-   // The address of the base of the memory region.
--  u_int64_t GetBase() const;
-+  uint64_t GetBase() const;
- 
-   // The size, in bytes, of the memory region.
--  u_int32_t GetSize() const;
-+  uint32_t GetSize() const;
- 
-   // Frees the cached memory region, if cached.
-   void FreeMemory();
- 
-   // Obtains the value of memory at the pointer specified by address.
--  bool GetMemoryAtAddress(u_int64_t address, u_int8_t*  value) const;
--  bool GetMemoryAtAddress(u_int64_t address, u_int16_t* value) const;
--  bool GetMemoryAtAddress(u_int64_t address, u_int32_t* value) const;
--  bool GetMemoryAtAddress(u_int64_t address, u_int64_t* value) const;
-+  bool GetMemoryAtAddress(uint64_t address, uint8_t*  value) const;
-+  bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const;
-+  bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const;
-+  bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const;
- 
-   // Print a human-readable representation of the object to stdout.
-   void Print();
- 
-  protected:
-   explicit MinidumpMemoryRegion(Minidump* minidump);
- 
-  private:
-   friend class MinidumpThread;
-   friend class MinidumpMemoryList;
- 
-   // Identify the base address and size of the memory region, and the
-   // location it may be found in the minidump file.
-   void SetDescriptor(MDMemoryDescriptor* descriptor);
- 
-   // Implementation for GetMemoryAtAddress
--  template<typename T> bool GetMemoryAtAddressInternal(u_int64_t address,
-+  template<typename T> bool GetMemoryAtAddressInternal(uint64_t address,
-                                                        T*        value) const;
- 
-   // The largest memory region that will be read from a minidump.  The
-   // default is 1MB.
--  static u_int32_t max_bytes_;
-+  static uint32_t max_bytes_;
- 
-   // Base address and size of the memory region, and its position in the
-   // minidump file.
-   MDMemoryDescriptor* descriptor_;
- 
-   // Cached memory.
--  mutable vector<u_int8_t>* memory_;
-+  mutable vector<uint8_t>* memory_;
- };
- 
- 
- // MinidumpThread contains information about a thread of execution,
- // including a snapshot of the thread's stack and CPU context.  For
- // the thread that caused an exception, the context carried by
- // MinidumpException is probably desired instead of the CPU context
- // provided here.
-@@ -314,17 +314,17 @@
-   virtual MinidumpMemoryRegion* GetMemory();
-   // GetContext may return NULL even if the MinidumpThread is valid.
-   virtual MinidumpContext* GetContext();
- 
-   // The thread ID is used to determine if a thread is the exception thread,
-   // so a special getter is provided to retrieve this data from the
-   // MDRawThread structure.  Returns false if the thread ID cannot be
-   // determined.
--  virtual bool GetThreadID(u_int32_t *thread_id) const;
-+  virtual bool GetThreadID(uint32_t *thread_id) const;
- 
-   // Print a human-readable representation of the object to stdout.
-   void Print();
- 
-  protected:
-   explicit MinidumpThread(Minidump* minidump);
- 
-  private:
-@@ -343,111 +343,111 @@
- 
- 
- // MinidumpThreadList contains all of the threads (as MinidumpThreads) in
- // a process.
- class MinidumpThreadList : public MinidumpStream {
-  public:
-   virtual ~MinidumpThreadList();
- 
--  static void set_max_threads(u_int32_t max_threads) {
-+  static void set_max_threads(uint32_t max_threads) {
-     max_threads_ = max_threads;
-   }
--  static u_int32_t max_threads() { return max_threads_; }
-+  static uint32_t max_threads() { return max_threads_; }
- 
-   virtual unsigned int thread_count() const {
-     return valid_ ? thread_count_ : 0;
-   }
- 
-   // Sequential access to threads.
-   virtual MinidumpThread* GetThreadAtIndex(unsigned int index) const;
- 
-   // Random access to threads.
--  MinidumpThread* GetThreadByID(u_int32_t thread_id);
-+  MinidumpThread* GetThreadByID(uint32_t thread_id);
- 
-   // Print a human-readable representation of the object to stdout.
-   void Print();
- 
-  protected:
-   explicit MinidumpThreadList(Minidump* aMinidump);
- 
-  private:
-   friend class Minidump;
- 
--  typedef map<u_int32_t, MinidumpThread*> IDToThreadMap;
-+  typedef map<uint32_t, MinidumpThread*> IDToThreadMap;
-   typedef vector<MinidumpThread> MinidumpThreads;
- 
--  static const u_int32_t kStreamType = MD_THREAD_LIST_STREAM;
-+  static const uint32_t kStreamType = MD_THREAD_LIST_STREAM;
- 
--  bool Read(u_int32_t aExpectedSize);
-+  bool Read(uint32_t aExpectedSize);
- 
-   // The largest number of threads that will be read from a minidump.  The
-   // default is 256.
--  static u_int32_t max_threads_;
-+  static uint32_t max_threads_;
- 
-   // Access to threads using the thread ID as the key.
-   IDToThreadMap    id_to_thread_map_;
- 
-   // The list of threads.
-   MinidumpThreads* threads_;
--  u_int32_t        thread_count_;
-+  uint32_t        thread_count_;
- };
- 
- 
- // MinidumpModule wraps MDRawModule, which contains information about loaded
- // code modules.  Access is provided to various data referenced indirectly
- // by MDRawModule, such as the module's name and a specification for where
- // to locate debugging information for the module.
- class MinidumpModule : public MinidumpObject,
-                        public CodeModule {
-  public:
-   virtual ~MinidumpModule();
- 
--  static void set_max_cv_bytes(u_int32_t max_cv_bytes) {
-+  static void set_max_cv_bytes(uint32_t max_cv_bytes) {
-     max_cv_bytes_ = max_cv_bytes;
-   }
--  static u_int32_t max_cv_bytes() { return max_cv_bytes_; }
-+  static uint32_t max_cv_bytes() { return max_cv_bytes_; }
- 
--  static void set_max_misc_bytes(u_int32_t max_misc_bytes) {
-+  static void set_max_misc_bytes(uint32_t max_misc_bytes) {
-     max_misc_bytes_ = max_misc_bytes;
-   }
--  static u_int32_t max_misc_bytes() { return max_misc_bytes_; }
-+  static uint32_t max_misc_bytes() { return max_misc_bytes_; }
- 
-   const MDRawModule* module() const { return valid_ ? &module_ : NULL; }
- 
-   // CodeModule implementation
--  virtual u_int64_t base_address() const {
--    return valid_ ? module_.base_of_image : static_cast<u_int64_t>(-1);
-+  virtual uint64_t base_address() const {
-+    return valid_ ? module_.base_of_image : static_cast<uint64_t>(-1);
-   }
--  virtual u_int64_t size() const { return valid_ ? module_.size_of_image : 0; }
-+  virtual uint64_t size() const { return valid_ ? module_.size_of_image : 0; }
-   virtual string code_file() const;
-   virtual string code_identifier() const;
-   virtual string debug_file() const;
-   virtual string debug_identifier() const;
-   virtual string version() const;
-   virtual const CodeModule* Copy() const;
- 
-   // The CodeView record, which contains information to locate the module's
--  // debugging information (pdb).  This is returned as u_int8_t* because
-+  // debugging information (pdb).  This is returned as uint8_t* because
-   // the data can be of types MDCVInfoPDB20* or MDCVInfoPDB70*, or it may be
-   // of a type unknown to Breakpad, in which case the raw data will still be
-   // returned but no byte-swapping will have been performed.  Check the
-   // record's signature in the first four bytes to differentiate between
-   // the various types.  Current toolchains generate modules which carry
-   // MDCVInfoPDB70 by default.  Returns a pointer to the CodeView record on
-   // success, and NULL on failure.  On success, the optional |size| argument
-   // is set to the size of the CodeView record.
--  const u_int8_t* GetCVRecord(u_int32_t* size);
-+  const uint8_t* GetCVRecord(uint32_t* size);
- 
-   // The miscellaneous debug record, which is obsolete.  Current toolchains
-   // do not generate this type of debugging information (dbg), and this
-   // field is not expected to be present.  Returns a pointer to the debugging
-   // record on success, and NULL on failure.  On success, the optional |size|
-   // argument is set to the size of the debugging record.
--  const MDImageDebugMisc* GetMiscRecord(u_int32_t* size);
-+  const MDImageDebugMisc* GetMiscRecord(uint32_t* size);
- 
-   // Print a human-readable representation of the object to stdout.
-   void Print();
- 
-  private:
-   // These objects are managed by MinidumpModuleList.
-   friend class MinidumpModuleList;
- 
-@@ -464,18 +464,18 @@
-   // requiring seeks to read a contiguous set of MinidumpModule objects.
-   // All auxiliary data should be available when Read is called, in order to
-   // allow the CodeModule getters to be const methods.
-   bool ReadAuxiliaryData();
- 
-   // The largest number of bytes that will be read from a minidump for a
-   // CodeView record or miscellaneous debugging record, respectively.  The
-   // default for each is 1024.
--  static u_int32_t max_cv_bytes_;
--  static u_int32_t max_misc_bytes_;
-+  static uint32_t max_cv_bytes_;
-+  static uint32_t max_misc_bytes_;
- 
-   // True after a successful Read.  This is different from valid_, which is
-   // not set true until ReadAuxiliaryData also completes successfully.
-   // module_valid_ is only used by ReadAuxiliaryData and the functions it
-   // calls to determine whether the object is ready for auxiliary data to 
-   // be read.
-   bool              module_valid_;
- 
-@@ -485,52 +485,52 @@
-   bool              has_debug_info_;
- 
-   MDRawModule       module_;
- 
-   // Cached module name.
-   const string*     name_;
- 
-   // Cached CodeView record - this is MDCVInfoPDB20 or (likely)
--  // MDCVInfoPDB70, or possibly something else entirely.  Stored as a u_int8_t
-+  // MDCVInfoPDB70, or possibly something else entirely.  Stored as a uint8_t
-   // because the structure contains a variable-sized string and its exact
-   // size cannot be known until it is processed.
--  vector<u_int8_t>* cv_record_;
-+  vector<uint8_t>* cv_record_;
- 
-   // If cv_record_ is present, cv_record_signature_ contains a copy of the
-   // CodeView record's first four bytes, for ease of determinining the
-   // type of structure that cv_record_ contains.
--  u_int32_t cv_record_signature_;
-+  uint32_t cv_record_signature_;
- 
--  // Cached MDImageDebugMisc (usually not present), stored as u_int8_t
-+  // Cached MDImageDebugMisc (usually not present), stored as uint8_t
-   // because the structure contains a variable-sized string and its exact
-   // size cannot be known until it is processed.
--  vector<u_int8_t>* misc_record_;
-+  vector<uint8_t>* misc_record_;
- };
- 
- 
- // MinidumpModuleList contains all of the loaded code modules for a process
- // in the form of MinidumpModules.  It maintains a map of these modules
- // so that it may easily provide a code module corresponding to a specific
- // address.
- class MinidumpModuleList : public MinidumpStream,
-                            public CodeModules {
-  public:
-   virtual ~MinidumpModuleList();
- 
--  static void set_max_modules(u_int32_t max_modules) {
-+  static void set_max_modules(uint32_t max_modules) {
-     max_modules_ = max_modules;
-   }
--  static u_int32_t max_modules() { return max_modules_; }
-+  static uint32_t max_modules() { return max_modules_; }
- 
-   // CodeModules implementation.
-   virtual unsigned int module_count() const {
-     return valid_ ? module_count_ : 0;
-   }
--  virtual const MinidumpModule* GetModuleForAddress(u_int64_t address) const;
-+  virtual const MinidumpModule* GetModuleForAddress(uint64_t address) const;
-   virtual const MinidumpModule* GetMainModule() const;
-   virtual const MinidumpModule* GetModuleAtSequence(
-       unsigned int sequence) const;
-   virtual const MinidumpModule* GetModuleAtIndex(unsigned int index) const;
-   virtual const CodeModules* Copy() const;
- 
-   // Print a human-readable representation of the object to stdout.
-   void Print();
-@@ -538,90 +538,90 @@
-  protected:
-   explicit MinidumpModuleList(Minidump* minidump);
- 
-  private:
-   friend class Minidump;
- 
-   typedef vector<MinidumpModule> MinidumpModules;
- 
--  static const u_int32_t kStreamType = MD_MODULE_LIST_STREAM;
-+  static const uint32_t kStreamType = MD_MODULE_LIST_STREAM;
- 
--  bool Read(u_int32_t expected_size);
-+  bool Read(uint32_t expected_size);
- 
-   // The largest number of modules that will be read from a minidump.  The
-   // default is 1024.
--  static u_int32_t max_modules_;
-+  static uint32_t max_modules_;
- 
-   // Access to modules using addresses as the key.
--  RangeMap<u_int64_t, unsigned int> *range_map_;
-+  RangeMap<uint64_t, unsigned int> *range_map_;
- 
-   MinidumpModules *modules_;
--  u_int32_t module_count_;
-+  uint32_t module_count_;
- };
- 
- 
- // MinidumpMemoryList corresponds to a minidump's MEMORY_LIST_STREAM stream,
- // which references the snapshots of all of the memory regions contained
- // within the minidump.  For a normal minidump, this includes stack memory
- // (also referenced by each MinidumpThread, in fact, the MDMemoryDescriptors
- // here and in MDRawThread both point to exactly the same data in a
- // minidump file, conserving space), as well as a 256-byte snapshot of memory
- // surrounding the instruction pointer in the case of an exception.  Other
- // types of minidumps may contain significantly more memory regions.  Full-
- // memory minidumps contain all of a process' mapped memory.
- class MinidumpMemoryList : public MinidumpStream {
-  public:
-   virtual ~MinidumpMemoryList();
- 
--  static void set_max_regions(u_int32_t max_regions) {
-+  static void set_max_regions(uint32_t max_regions) {
-     max_regions_ = max_regions;
-   }
--  static u_int32_t max_regions() { return max_regions_; }
-+  static uint32_t max_regions() { return max_regions_; }
- 
-   unsigned int region_count() const { return valid_ ? region_count_ : 0; }
- 
-   // Sequential access to memory regions.
-   MinidumpMemoryRegion* GetMemoryRegionAtIndex(unsigned int index);
- 
-   // Random access to memory regions.  Returns the region encompassing
-   // the address identified by address.
--  MinidumpMemoryRegion* GetMemoryRegionForAddress(u_int64_t address);
-+  MinidumpMemoryRegion* GetMemoryRegionForAddress(uint64_t address);
- 
-   // Print a human-readable representation of the object to stdout.
-   void Print();
- 
-  private:
-   friend class Minidump;
- 
-   typedef vector<MDMemoryDescriptor>   MemoryDescriptors;
-   typedef vector<MinidumpMemoryRegion> MemoryRegions;
- 
--  static const u_int32_t kStreamType = MD_MEMORY_LIST_STREAM;
-+  static const uint32_t kStreamType = MD_MEMORY_LIST_STREAM;
- 
-   explicit MinidumpMemoryList(Minidump* minidump);
- 
--  bool Read(u_int32_t expected_size);
-+  bool Read(uint32_t expected_size);
- 
-   // The largest number of memory regions that will be read from a minidump.
-   // The default is 256.
--  static u_int32_t max_regions_;
-+  static uint32_t max_regions_;
- 
-   // Access to memory regions using addresses as the key.
--  RangeMap<u_int64_t, unsigned int> *range_map_;
-+  RangeMap<uint64_t, unsigned int> *range_map_;
- 
-   // The list of descriptors.  This is maintained separately from the list
-   // of regions, because MemoryRegion doesn't own its MemoryDescriptor, it
-   // maintains a pointer to it.  descriptors_ provides the storage for this
-   // purpose.
-   MemoryDescriptors *descriptors_;
- 
-   // The list of regions.
-   MemoryRegions *regions_;
--  u_int32_t region_count_;
-+  uint32_t region_count_;
- };
- 
- 
- // MinidumpException wraps MDRawExceptionStream, which contains information
- // about the exception that caused the minidump to be generated, if the
- // minidump was generated in an exception handler called as a result of
- // an exception.  It also provides access to a MinidumpContext object,
- // which contains the CPU context for the exception thread at the time
-@@ -633,31 +633,31 @@
-   const MDRawExceptionStream* exception() const {
-     return valid_ ? &exception_ : NULL;
-   }
- 
-   // The thread ID is used to determine if a thread is the exception thread,
-   // so a special getter is provided to retrieve this data from the
-   // MDRawExceptionStream structure.  Returns false if the thread ID cannot
-   // be determined.
--  bool GetThreadID(u_int32_t *thread_id) const;
-+  bool GetThreadID(uint32_t *thread_id) const;
- 
-   MinidumpContext* GetContext();
- 
-   // Print a human-readable representation of the object to stdout.
-   void Print();
- 
-  private:
-   friend class Minidump;
- 
--  static const u_int32_t kStreamType = MD_EXCEPTION_STREAM;
-+  static const uint32_t kStreamType = MD_EXCEPTION_STREAM;
- 
-   explicit MinidumpException(Minidump* minidump);
- 
--  bool Read(u_int32_t expected_size);
-+  bool Read(uint32_t expected_size);
- 
-   MDRawExceptionStream exception_;
-   MinidumpContext*     context_;
- };
- 
- // MinidumpAssertion wraps MDRawAssertionInfo, which contains information
- // about an assertion that caused the minidump to be generated.
- class MinidumpAssertion : public MinidumpStream {
-@@ -681,21 +681,21 @@
-   }
- 
-   // Print a human-readable representation of the object to stdout.
-   void Print();
- 
-  private:
-   friend class Minidump;
- 
--  static const u_int32_t kStreamType = MD_ASSERTION_INFO_STREAM;
-+  static const uint32_t kStreamType = MD_ASSERTION_INFO_STREAM;
- 
-   explicit MinidumpAssertion(Minidump* minidump);
- 
--  bool Read(u_int32_t expected_size);
-+  bool Read(uint32_t expected_size);
- 
-   MDRawAssertionInfo assertion_;
-   string expression_;
-   string function_;
-   string file_;
- };
- 
- 
-@@ -738,19 +738,19 @@
- 
-   // Textual representation of the OS service pack, for minidumps produced
-   // by MiniDumpWriteDump on Windows.
-   const string* csd_version_;
- 
-  private:
-   friend class Minidump;
- 
--  static const u_int32_t kStreamType = MD_SYSTEM_INFO_STREAM;
-+  static const uint32_t kStreamType = MD_SYSTEM_INFO_STREAM;
- 
--  bool Read(u_int32_t expected_size);
-+  bool Read(uint32_t expected_size);
- 
-   // A string identifying the CPU vendor, if known.
-   const string* cpu_vendor_;
- };
- 
- 
- // MinidumpMiscInfo wraps MDRawMiscInfo and provides information about
- // the process that generated the minidump, and optionally additional system
-@@ -762,21 +762,21 @@
-   }
- 
-   // Print a human-readable representation of the object to stdout.
-   void Print();
- 
-  private:
-   friend class Minidump;
- 
--  static const u_int32_t kStreamType = MD_MISC_INFO_STREAM;
-+  static const uint32_t kStreamType = MD_MISC_INFO_STREAM;
- 
-   explicit MinidumpMiscInfo(Minidump* minidump_);
- 
--  bool Read(u_int32_t expected_size_);
-+  bool Read(uint32_t expected_size_);
- 
-   MDRawMiscInfo misc_info_;
- };
- 
- 
- // MinidumpBreakpadInfo wraps MDRawBreakpadInfo, which is an optional stream in
- // a minidump that provides additional information about the process state
- // at the time the minidump was generated.
-@@ -785,46 +785,46 @@
-   const MDRawBreakpadInfo* breakpad_info() const {
-     return valid_ ? &breakpad_info_ : NULL;
-   }
- 
-   // These thread IDs are used to determine if threads deserve special
-   // treatment, so special getters are provided to retrieve this data from
-   // the MDRawBreakpadInfo structure.  The getters return false if the thread
-   // IDs cannot be determined.
--  bool GetDumpThreadID(u_int32_t *thread_id) const;
--  bool GetRequestingThreadID(u_int32_t *thread_id) const;
-+  bool GetDumpThreadID(uint32_t *thread_id) const;
-+  bool GetRequestingThreadID(uint32_t *thread_id) const;
- 
-   // Print a human-readable representation of the object to stdout.
-   void Print();
- 
-  private:
-   friend class Minidump;
- 
--  static const u_int32_t kStreamType = MD_BREAKPAD_INFO_STREAM;
-+  static const uint32_t kStreamType = MD_BREAKPAD_INFO_STREAM;
- 
-   explicit MinidumpBreakpadInfo(Minidump* minidump_);
- 
--  bool Read(u_int32_t expected_size_);
-+  bool Read(uint32_t expected_size_);
- 
-   MDRawBreakpadInfo breakpad_info_;
- };
- 
- // MinidumpMemoryInfo wraps MDRawMemoryInfo, which provides information
- // about mapped memory regions in a process, including their ranges
- // and protection.
- class MinidumpMemoryInfo : public MinidumpObject {
-  public:
-   const MDRawMemoryInfo* info() const { return valid_ ? &memory_info_ : NULL; }
- 
-   // The address of the base of the memory region.
--  u_int64_t GetBase() const { return valid_ ? memory_info_.base_address : 0; }
-+  uint64_t GetBase() const { return valid_ ? memory_info_.base_address : 0; }
- 
-   // The size, in bytes, of the memory region.
--  u_int32_t GetSize() const { return valid_ ? memory_info_.region_size : 0; }
-+  uint32_t GetSize() const { return valid_ ? memory_info_.region_size : 0; }
- 
-   // Return true if the memory protection allows execution.
-   bool IsExecutable() const;
- 
-   // Return true if the memory protection allows writing.
-   bool IsWritable() const;
- 
-   // Print a human-readable representation of the object to stdout.
-@@ -849,38 +849,38 @@
- // It maintains a map of these structures so that it may easily provide
- // info corresponding to a specific address.
- class MinidumpMemoryInfoList : public MinidumpStream {
-  public:
-   virtual ~MinidumpMemoryInfoList();
- 
-   unsigned int info_count() const { return valid_ ? info_count_ : 0; }
- 
--  const MinidumpMemoryInfo* GetMemoryInfoForAddress(u_int64_t address) const;
-+  const MinidumpMemoryInfo* GetMemoryInfoForAddress(uint64_t address) const;
-   const MinidumpMemoryInfo* GetMemoryInfoAtIndex(unsigned int index) const;
- 
-   // Print a human-readable representation of the object to stdout.
-   void Print();
- 
-  private:
-   friend class Minidump;
- 
-   typedef vector<MinidumpMemoryInfo> MinidumpMemoryInfos;
- 
--  static const u_int32_t kStreamType = MD_MEMORY_INFO_LIST_STREAM;
-+  static const uint32_t kStreamType = MD_MEMORY_INFO_LIST_STREAM;
- 
-   explicit MinidumpMemoryInfoList(Minidump* minidump);
- 
--  bool Read(u_int32_t expected_size);
-+  bool Read(uint32_t expected_size);
- 
-   // Access to memory info using addresses as the key.
--  RangeMap<u_int64_t, unsigned int> *range_map_;
-+  RangeMap<uint64_t, unsigned int> *range_map_;
- 
-   MinidumpMemoryInfos* infos_;
--  u_int32_t info_count_;
-+  uint32_t info_count_;
- };
- 
- 
- // Minidump is the user's interface to a minidump file.  It wraps MDRawHeader
- // and provides access to the minidump's top-level stream directory.
- class Minidump {
-  public:
-   // path is the pathname of a file containing the minidump.
-@@ -891,37 +891,37 @@
-   explicit Minidump(std::istream& input);
- 
-   virtual ~Minidump();
- 
-   // path may be empty if the minidump was not opened from a file
-   virtual string path() const {
-     return path_;
-   }
--  static void set_max_streams(u_int32_t max_streams) {
-+  static void set_max_streams(uint32_t max_streams) {
-     max_streams_ = max_streams;
-   }
--  static u_int32_t max_streams() { return max_streams_; }
-+  static uint32_t max_streams() { return max_streams_; }
- 
--  static void set_max_string_length(u_int32_t max_string_length) {
-+  static void set_max_string_length(uint32_t max_string_length) {
-     max_string_length_ = max_string_length;
-   }
--  static u_int32_t max_string_length() { return max_string_length_; }
-+  static uint32_t max_string_length() { return max_string_length_; }
- 
-   virtual const MDRawHeader* header() const { return valid_ ? &header_ : NULL; }
- 
-   // Reads the CPU information from the system info stream and generates the
-   // appropriate CPU flags.  The returned context_cpu_flags are the same as
-   // if the CPU type bits were set in the context_flags of a context record.
-   // On success, context_cpu_flags will have the flags that identify the CPU.
-   // If a system info stream is missing, context_cpu_flags will be 0.
-   // Returns true if the current position in the stream was not changed.
-   // Returns false when the current location in the stream was changed and the
-   // attempt to restore the original position failed.
--  bool GetContextCPUFlagsFromSystemInfo(u_int32_t* context_cpu_flags);
-+  bool GetContextCPUFlagsFromSystemInfo(uint32_t* context_cpu_flags);
- 
-   // Reads the minidump file's header and top-level stream directory.
-   // The minidump is expected to be positioned at the beginning of the
-   // header.  Read() sets up the stream list and map, and validates the
-   // Minidump object.
-   virtual bool Read();
- 
-   // The next set of methods are stubs that call GetStream.  They exist to
-@@ -975,17 +975,17 @@
-   // thinking that the stream that this seeks to is the only stream with
-   // type stream_type.  That can't happen for streams that these classes
-   // deal with directly, because they're only supposed to be present in the
-   // file singly, and that's verified when stream_map_ is built.  Users who
-   // are looking for other stream types should be aware of this
-   // possibility, and consider using GetDirectoryEntryAtIndex (possibly
-   // with GetDirectoryEntryCount) if expecting multiple streams of the same
-   // type in a single minidump file.
--  bool SeekToStreamType(u_int32_t stream_type, u_int32_t* stream_length);
-+  bool SeekToStreamType(uint32_t stream_type, uint32_t* stream_length);
- 
-   bool swap() const { return valid_ ? swap_ : false; }
- 
-   // Print a human-readable representation of the object to stdout.
-   void Print();
- 
-  private:
-   // MinidumpStreamInfo is used in the MinidumpStreamMap.  It lets
-@@ -998,27 +998,27 @@
-     // Index into the MinidumpDirectoryEntries vector
-     unsigned int    stream_index;
- 
-     // Pointer to the stream if cached, or NULL if not yet populated
-     MinidumpStream* stream;
-   };
- 
-   typedef vector<MDRawDirectory> MinidumpDirectoryEntries;
--  typedef map<u_int32_t, MinidumpStreamInfo> MinidumpStreamMap;
-+  typedef map<uint32_t, MinidumpStreamInfo> MinidumpStreamMap;
- 
-   template<typename T> T* GetStream(T** stream);
- 
-   // Opens the minidump file, or if already open, seeks to the beginning.
-   bool Open();
- 
-   // The largest number of top-level streams that will be read from a minidump.
-   // Note that streams are only read (and only consume memory) as needed,
-   // when directed by the caller.  The default is 128.
--  static u_int32_t max_streams_;
-+  static uint32_t max_streams_;
- 
-   // The maximum length of a UTF-16 string that will be read from a minidump
-   // in 16-bit words.  The default is 1024.  UTF-16 strings are converted
-   // to UTF-8 when stored in memory, and each UTF-16 word will be represented
-   // by as many as 3 bytes in UTF-8.
-   static unsigned int max_string_length_;
- 
-   MDRawHeader               header_;
-diff --git a/src/google_breakpad/processor/minidump_processor.h b/src/google_breakpad/processor/minidump_processor.h
---- a/src/google_breakpad/processor/minidump_processor.h
-+++ b/src/google_breakpad/processor/minidump_processor.h
-@@ -126,17 +126,17 @@
-   // Returns a textual representation of the reason that a crash occurred,
-   // if the minidump in dump was produced as a result of a crash.  Returns
-   // an empty string if this information cannot be determined.  If address
-   // is non-NULL, it will be set to contain the address that caused the
-   // exception, if this information is available.  This will be a code
-   // address when the crash was caused by problems such as illegal
-   // instructions or divisions by zero, or a data address when the crash
-   // was caused by a memory access violation.
--  static string GetCrashReason(Minidump* dump, u_int64_t* address);
-+  static string GetCrashReason(Minidump* dump, uint64_t* address);
- 
-   // This function returns true if the passed-in error code is
-   // something unrecoverable(i.e. retry should not happen).  For
-   // instance, if the minidump is corrupt, then it makes no sense to
-   // retry as we won't be able to glean additional information.
-   // However, as an example of the other case, the symbol supplier can
-   // return an error code indicating it was 'interrupted', which can
-   // happen of the symbols are fetched from a remote store, and a
-diff --git a/src/google_breakpad/processor/process_state.h b/src/google_breakpad/processor/process_state.h
---- a/src/google_breakpad/processor/process_state.h
-+++ b/src/google_breakpad/processor/process_state.h
-@@ -89,52 +89,52 @@
-  public:
-   ProcessState() : modules_(NULL) { Clear(); }
-   ~ProcessState();
- 
-   // Resets the ProcessState to its default values
-   void Clear();
- 
-   // Accessors.  See the data declarations below.
--  u_int32_t time_date_stamp() const { return time_date_stamp_; }
-+  uint32_t time_date_stamp() const { return time_date_stamp_; }
-   bool crashed() const { return crashed_; }
-   string crash_reason() const { return crash_reason_; }
--  u_int64_t crash_address() const { return crash_address_; }
-+  uint64_t crash_address() const { return crash_address_; }
-   string assertion() const { return assertion_; }
-   int requesting_thread() const { return requesting_thread_; }
-   const vector<CallStack*>* threads() const { return &threads_; }
-   const vector<MinidumpMemoryRegion*>* thread_memory_regions() const {
-     return &thread_memory_regions_;
-   }
-   const SystemInfo* system_info() const { return &system_info_; }
-   const CodeModules* modules() const { return modules_; }
-   ExploitabilityRating exploitability() const { return exploitability_; }
- 
-  private:
-   // MinidumpProcessor is responsible for building ProcessState objects.
-   friend class MinidumpProcessor;
- 
-   // The time-date stamp of the minidump (time_t format)
--  u_int32_t time_date_stamp_;
-+  uint32_t time_date_stamp_;
- 
-   // True if the process crashed, false if the dump was produced outside
-   // of an exception handler.
-   bool crashed_;
- 
-   // If the process crashed, the type of crash.  OS- and possibly CPU-
-   // specific.  For example, "EXCEPTION_ACCESS_VIOLATION" (Windows),
-   // "EXC_BAD_ACCESS / KERN_INVALID_ADDRESS" (Mac OS X), "SIGSEGV"
-   // (other Unix).
-   string crash_reason_;
- 
-   // If the process crashed, and if crash_reason implicates memory,
-   // the memory address that caused the crash.  For data access errors,
-   // this will be the data address that caused the fault.  For code errors,
-   // this will be the address of the instruction that caused the fault.
--  u_int64_t crash_address_;
-+  uint64_t crash_address_;
- 
-   // If there was an assertion that was hit, a textual representation
-   // of that assertion, possibly including the file and line at which
-   // it occurred.
-   string assertion_;
- 
-   // The index of the thread that requested a dump be written in the
-   // threads vector.  If a dump was produced as a result of a crash, this
-diff --git a/src/google_breakpad/processor/source_line_resolver_interface.h b/src/google_breakpad/processor/source_line_resolver_interface.h
---- a/src/google_breakpad/processor/source_line_resolver_interface.h
-+++ b/src/google_breakpad/processor/source_line_resolver_interface.h
-@@ -43,17 +43,17 @@
- namespace google_breakpad {
- 
- struct StackFrame;
- struct WindowsFrameInfo;
- class CFIFrameInfo;
- 
- class SourceLineResolverInterface {
-  public:
--  typedef u_int64_t MemAddr;
-+  typedef uint64_t MemAddr;
- 
-   virtual ~SourceLineResolverInterface() {}
- 
-   // Adds a module to this resolver, returning true on success.
-   //
-   // module should have at least the code_file, debug_file,
-   // and debug_identifier members populated.
-   //
-diff --git a/src/google_breakpad/processor/stack_frame.h b/src/google_breakpad/processor/stack_frame.h
---- a/src/google_breakpad/processor/stack_frame.h
-+++ b/src/google_breakpad/processor/stack_frame.h
-@@ -80,17 +80,17 @@
-         return "stack scanning";
-       default:
-         return "unknown";
-     }
-   };
- 
-   // Return the actual return address, as saved on the stack or in a
-   // register. See the comments for 'instruction', below, for details.
--  virtual u_int64_t ReturnAddress() const { return instruction; }
-+  virtual uint64_t ReturnAddress() const { return instruction; }
- 
-   // The program counter location as an absolute virtual address.
-   //
-   // - For the innermost called frame in a stack, this will be an exact
-   //   program counter or instruction pointer value.
-   //
-   // - For all other frames, this address is within the instruction that
-   //   caused execution to branch to this frame's callee (although it may
-@@ -103,38 +103,38 @@
-   //   code, such that the "return address" (which will never be used)
-   //   immediately after the call instruction is in an entirely different
-   //   function, perhaps even from a different source file.)
-   //
-   // On some architectures, the return address as saved on the stack or in
-   // a register is fine for looking up the point of the call. On others, it
-   // requires adjustment. ReturnAddress returns the address as saved by the
-   // machine.
--  u_int64_t instruction;
-+  uint64_t instruction;
- 
-   // The module in which the instruction resides.
-   const CodeModule *module;
- 
-   // The function name, may be omitted if debug symbols are not available.
-   string function_name;
- 
-   // The start address of the function, may be omitted if debug symbols
-   // are not available.
--  u_int64_t function_base;
-+  uint64_t function_base;
- 
-   // The source file name, may be omitted if debug symbols are not available.
-   string source_file_name;
- 
-   // The (1-based) source line number, may be omitted if debug symbols are
-   // not available.
-   int source_line;
- 
-   // The start address of the source line, may be omitted if debug symbols
-   // are not available.
--  u_int64_t source_line_base;
-+  uint64_t source_line_base;
- 
-   // Amount of trust the stack walker has in the instruction pointer
-   // of this frame.
-   FrameTrust trust;
- };
- 
- }  // namespace google_breakpad
- 
-diff --git a/src/google_breakpad/processor/stack_frame_cpu.h b/src/google_breakpad/processor/stack_frame_cpu.h
---- a/src/google_breakpad/processor/stack_frame_cpu.h
-+++ b/src/google_breakpad/processor/stack_frame_cpu.h
-@@ -73,17 +73,17 @@
-   StackFrameX86()
-      : context(),
-        context_validity(CONTEXT_VALID_NONE),
-        windows_frame_info(NULL),
-        cfi_frame_info(NULL) {}
-   ~StackFrameX86();
- 
-   // Overriden to return the return address as saved on the stack.
--  virtual u_int64_t ReturnAddress() const;
-+  virtual uint64_t ReturnAddress() const;
- 
-   // Register state.  This is only fully valid for the topmost frame in a
-   // stack.  In other frames, the values of nonvolatile registers may be
-   // present, given sufficient debugging information.  Refer to
-   // context_validity.
-   MDRawContextX86 context;
- 
-   // context_validity is actually ContextValidity, but int is used because
-@@ -146,17 +146,17 @@
-     CONTEXT_VALID_R15   = 1 << 15,
-     CONTEXT_VALID_RIP   = 1 << 16,
-     CONTEXT_VALID_ALL  = -1
-   };
- 
-   StackFrameAMD64() : context(), context_validity(CONTEXT_VALID_NONE) {}
- 
-   // Overriden to return the return address as saved on the stack.
--  virtual u_int64_t ReturnAddress() const;
-+  virtual uint64_t ReturnAddress() const;
- 
-   // Register state. This is only fully valid for the topmost frame in a
-   // stack. In other frames, which registers are present depends on what
-   // debugging information we had available. Refer to context_validity.
-   MDRawContextAMD64 context;
- 
-   // For each register in context whose value has been recovered, we set
-   // the corresponding CONTEXT_VALID_ bit in context_validity.
-diff --git a/src/google_breakpad/processor/stackwalker.h b/src/google_breakpad/processor/stackwalker.h
---- a/src/google_breakpad/processor/stackwalker.h
-+++ b/src/google_breakpad/processor/stackwalker.h
-@@ -73,18 +73,18 @@
-   // argument.  If no suitable concrete subclass exists, returns NULL.
-   static Stackwalker* StackwalkerForCPU(
-      const SystemInfo* system_info,
-      MinidumpContext* context,
-      MemoryRegion* memory,
-      const CodeModules* modules,
-      StackFrameSymbolizer* resolver_helper);
- 
--  static void set_max_frames(u_int32_t max_frames) { max_frames_ = max_frames; }
--  static u_int32_t max_frames() { return max_frames_; }
-+  static void set_max_frames(uint32_t max_frames) { max_frames_ = max_frames; }
-+  static uint32_t max_frames() { return max_frames_; }
- 
-  protected:
-   // system_info identifies the operating system, NULL or empty if unknown.
-   // memory identifies a MemoryRegion that provides the stack memory
-   // for the stack to walk.  modules, if non-NULL, is a CodeModules
-   // object that is used to look up which code module each stack frame is
-   // associated with.  frame_symbolizer is a StackFrameSymbolizer object that
-   // encapsulates the logic of how source line resolver interacts with symbol
-@@ -99,17 +99,17 @@
-   // This can be used to filter out potential return addresses when
-   // the stack walker resorts to stack scanning.
-   // Returns true if any of:
-   // * This address is within a loaded module, but we don't have symbols
-   //   for that module.
-   // * This address is within a loaded module for which we have symbols,
-   //   and falls inside a function in that module.
-   // Returns false otherwise.
--  bool InstructionAddressSeemsValid(u_int64_t address);
-+  bool InstructionAddressSeemsValid(uint64_t address);
- 
-   // The default number of words to search through on the stack
-   // for a return address.
-   static const int kRASearchWords;
- 
-   template<typename InstructionType>
-   bool ScanForReturnAddress(InstructionType location_start,
-                             InstructionType* location_found,
-@@ -180,15 +180,15 @@
-   // return NULL on failure or when there are no more caller frames (when
-   // the end of the stack has been reached).  GetCallerFrame allocates a new
-   // StackFrame (or StackFrame subclass), ownership of which is taken by
-   // the caller.
-   virtual StackFrame* GetCallerFrame(const CallStack* stack) = 0;
- 
-   // The maximum number of frames Stackwalker will walk through.
-   // This defaults to 1024 to prevent infinite loops.
--  static u_int32_t max_frames_;
-+  static uint32_t max_frames_;
- };
- 
- }  // namespace google_breakpad
- 
- 
- #endif  // GOOGLE_BREAKPAD_PROCESSOR_STACKWALKER_H__
-diff --git a/src/processor/basic_code_module.h b/src/processor/basic_code_module.h
---- a/src/processor/basic_code_module.h
-+++ b/src/processor/basic_code_module.h
-@@ -58,17 +58,17 @@
-       : base_address_(that->base_address()),
-         size_(that->size()),
-         code_file_(that->code_file()),
-         code_identifier_(that->code_identifier()),
-         debug_file_(that->debug_file()),
-         debug_identifier_(that->debug_identifier()),
-         version_(that->version()) {}
- 
--  BasicCodeModule(u_int64_t base_address, u_int64_t size,
-+  BasicCodeModule(uint64_t base_address, uint64_t size,
- 		  const string &code_file,
- 		  const string &code_identifier,
- 		  const string &debug_file,
- 		  const string &debug_identifier,
- 		  const string &version)
-     : base_address_(base_address),
-       size_(size),
-       code_file_(code_file),
-@@ -76,28 +76,28 @@
-       debug_file_(debug_file),
-       debug_identifier_(debug_identifier),
-       version_(version)
-     {}
-   virtual ~BasicCodeModule() {}
- 
-   // See code_module.h for descriptions of these methods and the associated
-   // members.
--  virtual u_int64_t base_address() const { return base_address_; }
--  virtual u_int64_t size() const { return size_; }
-+  virtual uint64_t base_address() const { return base_address_; }
-+  virtual uint64_t size() const { return size_; }
-   virtual string code_file() const { return code_file_; }
-   virtual string code_identifier() const { return code_identifier_; }
-   virtual string debug_file() const { return debug_file_; }
-   virtual string debug_identifier() const { return debug_identifier_; }
-   virtual string version() const { return version_; }
-   virtual const CodeModule* Copy() const { return new BasicCodeModule(this); }
- 
-  private:
--  u_int64_t base_address_;
--  u_int64_t size_;
-+  uint64_t base_address_;
-+  uint64_t size_;
-   string code_file_;
-   string code_identifier_;
-   string debug_file_;
-   string debug_identifier_;
-   string version_;
- 
-   // Disallow copy constructor and assignment operator.
-   BasicCodeModule(const BasicCodeModule &that);
-diff --git a/src/processor/basic_code_modules.cc b/src/processor/basic_code_modules.cc
---- a/src/processor/basic_code_modules.cc
-+++ b/src/processor/basic_code_modules.cc
-@@ -42,17 +42,17 @@
- #include "processor/linked_ptr.h"
- #include "processor/logging.h"
- #include "processor/range_map-inl.h"
- 
- namespace google_breakpad {
- 
- BasicCodeModules::BasicCodeModules(const CodeModules *that)
-     : main_address_(0),
--      map_(new RangeMap<u_int64_t, linked_ptr<const CodeModule> >()) {
-+      map_(new RangeMap<uint64_t, linked_ptr<const CodeModule> >()) {
-   BPLOG_IF(ERROR, !that) << "BasicCodeModules::BasicCodeModules requires "
-                             "|that|";
-   assert(that);
- 
-   const CodeModule *main_module = that->GetMainModule();
-   if (main_module)
-     main_address_ = main_module->base_address();
- 
-@@ -77,17 +77,17 @@
-   delete map_;
- }
- 
- unsigned int BasicCodeModules::module_count() const {
-   return map_->GetCount();
- }
- 
- const CodeModule* BasicCodeModules::GetModuleForAddress(
--    u_int64_t address) const {
-+    uint64_t address) const {
-   linked_ptr<const CodeModule> module;
-   if (!map_->RetrieveRange(address, &module, NULL, NULL)) {
-     BPLOG(INFO) << "No module at " << HexString(address);
-     return NULL;
-   }
- 
-   return module.get();
- }
-diff --git a/src/processor/basic_code_modules.h b/src/processor/basic_code_modules.h
---- a/src/processor/basic_code_modules.h
-+++ b/src/processor/basic_code_modules.h
-@@ -56,29 +56,29 @@
-   // resources that other implementations may require.  A copy will be
-   // made of each contained CodeModule using CodeModule::Copy.
-   explicit BasicCodeModules(const CodeModules *that);
- 
-   virtual ~BasicCodeModules();
- 
-   // See code_modules.h for descriptions of these methods.
-   virtual unsigned int module_count() const;
--  virtual const CodeModule* GetModuleForAddress(u_int64_t address) const;
-+  virtual const CodeModule* GetModuleForAddress(uint64_t address) const;
-   virtual const CodeModule* GetMainModule() const;
-   virtual const CodeModule* GetModuleAtSequence(unsigned int sequence) const;
-   virtual const CodeModule* GetModuleAtIndex(unsigned int index) const;
-   virtual const CodeModules* Copy() const;
- 
-  private:
-   // The base address of the main module.
--  u_int64_t main_address_;
-+  uint64_t main_address_;
- 
-   // The map used to contain each CodeModule, keyed by each CodeModule's
-   // address range.
--  RangeMap<u_int64_t, linked_ptr<const CodeModule> > *map_;
-+  RangeMap<uint64_t, linked_ptr<const CodeModule> > *map_;
- 
-   // Disallow copy constructor and assignment operator.
-   BasicCodeModules(const BasicCodeModules &that);
-   void operator=(const BasicCodeModules &that);
- };
- 
- }  // namespace google_breakpad
- 
-diff --git a/src/processor/basic_source_line_resolver.cc b/src/processor/basic_source_line_resolver.cc
---- a/src/processor/basic_source_line_resolver.cc
-+++ b/src/processor/basic_source_line_resolver.cc
-@@ -295,34 +295,34 @@
-   // FUNC <address> <size> <stack_param_size> <name>
-   function_line += 5;  // skip prefix
- 
-   vector<char*> tokens;
-   if (!Tokenize(function_line, kWhitespace, 4, &tokens)) {
-     return NULL;
-   }
- 
--  u_int64_t address    = strtoull(tokens[0], NULL, 16);
--  u_int64_t size       = strtoull(tokens[1], NULL, 16);
-+  uint64_t address    = strtoull(tokens[0], NULL, 16);
-+  uint64_t size       = strtoull(tokens[1], NULL, 16);
-   int stack_param_size = strtoull(tokens[2], NULL, 16);
-   char *name           = tokens[3];
- 
-   return new Function(name, address, size, stack_param_size);
- }
- 
- BasicSourceLineResolver::Line* BasicSourceLineResolver::Module::ParseLine(
-     char *line_line) {
-   // <address> <line number> <source file id>
-   vector<char*> tokens;
-   if (!Tokenize(line_line, kWhitespace, 4, &tokens)) {
-     return NULL;
-   }
- 
--  u_int64_t address = strtoull(tokens[0], NULL, 16);
--  u_int64_t size    = strtoull(tokens[1], NULL, 16);
-+  uint64_t address = strtoull(tokens[0], NULL, 16);
-+  uint64_t size    = strtoull(tokens[1], NULL, 16);
-   int line_number   = atoi(tokens[2]);
-   int source_file   = atoi(tokens[3]);
-   if (line_number <= 0) {
-     return NULL;
-   }
- 
-   return new Line(address, size, source_file, line_number);
- }
-@@ -333,17 +333,17 @@
-   // Skip "PUBLIC " prefix.
-   public_line += 7;
- 
-   vector<char*> tokens;
-   if (!Tokenize(public_line, kWhitespace, 3, &tokens)) {
-     return false;
-   }
- 
--  u_int64_t address    = strtoull(tokens[0], NULL, 16);
-+  uint64_t address    = strtoull(tokens[0], NULL, 16);
-   int stack_param_size = strtoull(tokens[1], NULL, 16);
-   char *name           = tokens[2];
- 
-   // A few public symbols show up with an address of 0.  This has been seen
-   // in the dumped output of ntdll.pdb for symbols such as _CIlog, _CIpow,
-   // RtlDescribeChunkLZNT1, and RtlReserveChunkLZNT1.  They would conflict
-   // with one another if they were allowed into the public_symbols_ map,
-   // but since the address is obviously invalid, gracefully accept them
-@@ -368,17 +368,17 @@
-   const char *platform = stack_info_line;
-   while (!strchr(kWhitespace, *stack_info_line))
-     stack_info_line++;
-   *stack_info_line++ = '\0';
- 
-   // MSVC stack frame info.
-   if (strcmp(platform, "WIN") == 0) {
-     int type = 0;
--    u_int64_t rva, code_size;
-+    uint64_t rva, code_size;
-     linked_ptr<WindowsFrameInfo>
-       stack_frame_info(WindowsFrameInfo::ParseFromString(stack_info_line,
-                                                          type,
-                                                          rva,
-                                                          code_size));
-     if (stack_frame_info == NULL)
-       return false;
- 
-diff --git a/src/processor/basic_source_line_resolver_unittest.cc b/src/processor/basic_source_line_resolver_unittest.cc
---- a/src/processor/basic_source_line_resolver_unittest.cc
-+++ b/src/processor/basic_source_line_resolver_unittest.cc
-@@ -54,77 +54,77 @@
- using google_breakpad::linked_ptr;
- using google_breakpad::scoped_ptr;
- 
- class TestCodeModule : public CodeModule {
-  public:
-   TestCodeModule(string code_file) : code_file_(code_file) {}
-   virtual ~TestCodeModule() {}
- 
--  virtual u_int64_t base_address() const { return 0; }
--  virtual u_int64_t size() const { return 0xb000; }
-+  virtual uint64_t base_address() const { return 0; }
-+  virtual uint64_t size() const { return 0xb000; }
-   virtual string code_file() const { return code_file_; }
-   virtual string code_identifier() const { return ""; }
-   virtual string debug_file() const { return ""; }
-   virtual string debug_identifier() const { return ""; }
-   virtual string version() const { return ""; }
-   virtual const CodeModule* Copy() const {
-     return new TestCodeModule(code_file_);
-   }
- 
-  private:
-   string code_file_;
- };
- 
- // A mock memory region object, for use by the STACK CFI tests.
- class MockMemoryRegion: public MemoryRegion {
--  u_int64_t GetBase() const { return 0x10000; }
--  u_int32_t GetSize() const { return 0x01000; }
--  bool GetMemoryAtAddress(u_int64_t address, u_int8_t *value) const {
-+  uint64_t GetBase() const { return 0x10000; }
-+  uint32_t GetSize() const { return 0x01000; }
-+  bool GetMemoryAtAddress(uint64_t address, uint8_t *value) const {
-     *value = address & 0xff;
-     return true;
-   }
--  bool GetMemoryAtAddress(u_int64_t address, u_int16_t *value) const {
-+  bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const {
-     *value = address & 0xffff;
-     return true;
-   }
--  bool GetMemoryAtAddress(u_int64_t address, u_int32_t *value) const {
-+  bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const {
-     switch (address) {
-       case 0x10008: *value = 0x98ecadc3; break; // saved %ebx
-       case 0x1000c: *value = 0x878f7524; break; // saved %esi
-       case 0x10010: *value = 0x6312f9a5; break; // saved %edi
-       case 0x10014: *value = 0x10038;    break; // caller's %ebp
-       case 0x10018: *value = 0xf6438648; break; // return address
-       default: *value = 0xdeadbeef;      break; // junk
-     }
-     return true;
-   }
--  bool GetMemoryAtAddress(u_int64_t address, u_int64_t *value) const {
-+  bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const {
-     *value = address;
-     return true;
-   }
- };
- 
- // Verify that, for every association in ACTUAL, EXPECTED has the same
- // association. (That is, ACTUAL's associations should be a subset of
- // EXPECTED's.) Also verify that ACTUAL has associations for ".ra" and
- // ".cfa".
- static bool VerifyRegisters(
-     const char *file, int line,
--    const CFIFrameInfo::RegisterValueMap<u_int32_t> &expected,
--    const CFIFrameInfo::RegisterValueMap<u_int32_t> &actual) {
--  CFIFrameInfo::RegisterValueMap<u_int32_t>::const_iterator a;
-+    const CFIFrameInfo::RegisterValueMap<uint32_t> &expected,
-+    const CFIFrameInfo::RegisterValueMap<uint32_t> &actual) {
-+  CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator a;
-   a = actual.find(".cfa");
-   if (a == actual.end())
-     return false;
-   a = actual.find(".ra");
-   if (a == actual.end())
-     return false;
-   for (a = actual.begin(); a != actual.end(); a++) {
--    CFIFrameInfo::RegisterValueMap<u_int32_t>::const_iterator e =
-+    CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator e =
-       expected.find(a->first);
-     if (e == expected.end()) {
-       fprintf(stderr, "%s:%d: unexpected register '%s' recovered, value 0x%x\n",
-               file, line, a->first.c_str(), a->second);
-       return false;
-     }
-     if (e->second != a->second) {
-       fprintf(stderr,
-@@ -247,19 +247,19 @@
-   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
-   ASSERT_FALSE(cfi_frame_info.get());
- 
-   frame.instruction = 0x3e9f;
-   frame.module = &module1;
-   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
-   ASSERT_FALSE(cfi_frame_info.get());
- 
--  CFIFrameInfo::RegisterValueMap<u_int32_t> current_registers;
--  CFIFrameInfo::RegisterValueMap<u_int32_t> caller_registers;
--  CFIFrameInfo::RegisterValueMap<u_int32_t> expected_caller_registers;
-+  CFIFrameInfo::RegisterValueMap<uint32_t> current_registers;
-+  CFIFrameInfo::RegisterValueMap<uint32_t> caller_registers;
-+  CFIFrameInfo::RegisterValueMap<uint32_t> expected_caller_registers;
-   MockMemoryRegion memory;
- 
-   // Regardless of which instruction evaluation takes place at, it
-   // should produce the same values for the caller's registers.
-   expected_caller_registers[".cfa"] = 0x1001c;
-   expected_caller_registers[".ra"]  = 0xf6438648;
-   expected_caller_registers["$ebp"] = 0x10038;
-   expected_caller_registers["$ebx"] = 0x98ecadc3;
-@@ -272,67 +272,67 @@
-   current_registers["$esp"] = 0x10018;
-   current_registers["$ebp"] = 0x10038;
-   current_registers["$ebx"] = 0x98ecadc3;
-   current_registers["$esi"] = 0x878f7524;
-   current_registers["$edi"] = 0x6312f9a5;
-   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
-   ASSERT_TRUE(cfi_frame_info.get());
-   ASSERT_TRUE(cfi_frame_info.get()
--              ->FindCallerRegs<u_int32_t>(current_registers, memory,
-+              ->FindCallerRegs<uint32_t>(current_registers, memory,
-                                           &caller_registers));
-   ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__,
-                               expected_caller_registers, caller_registers));
- 
-   frame.instruction = 0x3d41;
-   current_registers["$esp"] = 0x10014;
-   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
-   ASSERT_TRUE(cfi_frame_info.get());
-   ASSERT_TRUE(cfi_frame_info.get()
--              ->FindCallerRegs<u_int32_t>(current_registers, memory,
-+              ->FindCallerRegs<uint32_t>(current_registers, memory,
-                                           &caller_registers));
-   ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__,
-                               expected_caller_registers, caller_registers));
- 
-   frame.instruction = 0x3d43;
-   current_registers["$ebp"] = 0x10014;
-   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
-   ASSERT_TRUE(cfi_frame_info.get());
-   ASSERT_TRUE(cfi_frame_info.get()
--              ->FindCallerRegs<u_int32_t>(current_registers, memory,
-+              ->FindCallerRegs<uint32_t>(current_registers, memory,
-                                           &caller_registers));
-   VerifyRegisters(__FILE__, __LINE__,
-                   expected_caller_registers, caller_registers);
- 
-   frame.instruction = 0x3d54;
-   current_registers["$ebx"] = 0x6864f054U;
-   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
-   ASSERT_TRUE(cfi_frame_info.get());
-   ASSERT_TRUE(cfi_frame_info.get()
--              ->FindCallerRegs<u_int32_t>(current_registers, memory,
-+              ->FindCallerRegs<uint32_t>(current_registers, memory,
-                                           &caller_registers));
-   VerifyRegisters(__FILE__, __LINE__,
-                   expected_caller_registers, caller_registers);
- 
-   frame.instruction = 0x3d5a;
-   current_registers["$esi"] = 0x6285f79aU;
-   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
-   ASSERT_TRUE(cfi_frame_info.get());
-   ASSERT_TRUE(cfi_frame_info.get()
--              ->FindCallerRegs<u_int32_t>(current_registers, memory,
-+              ->FindCallerRegs<uint32_t>(current_registers, memory,
-                                           &caller_registers));
-   VerifyRegisters(__FILE__, __LINE__,
-                   expected_caller_registers, caller_registers);
- 
-   frame.instruction = 0x3d84;
-   current_registers["$edi"] = 0x64061449U;
-   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
-   ASSERT_TRUE(cfi_frame_info.get());
-   ASSERT_TRUE(cfi_frame_info.get()
--              ->FindCallerRegs<u_int32_t>(current_registers, memory,
-+              ->FindCallerRegs<uint32_t>(current_registers, memory,
-                                           &caller_registers));
-   VerifyRegisters(__FILE__, __LINE__,
-                   expected_caller_registers, caller_registers);
- 
-   frame.instruction = 0x2900;
-   frame.module = &module1;
-   resolver.FillSourceLineInfo(&frame);
-   ASSERT_EQ(frame.function_name, string("PublicSymbol"));
-diff --git a/src/processor/binarystream.cc b/src/processor/binarystream.cc
---- a/src/processor/binarystream.cc
-+++ b/src/processor/binarystream.cc
-@@ -35,90 +35,90 @@
- 
- #include "common/using_std_string.h"
- #include "processor/binarystream.h"
- 
- namespace google_breakpad {
- using std::vector;
- 
- binarystream &binarystream::operator>>(string &str) {
--  u_int16_t length;
-+  uint16_t length;
-   *this >> length;
-   if (eof())
-     return *this;
-   if (length == 0) {
-     str.clear();
-     return *this;
-   }
-   vector<char> buffer(length);
-   stream_.read(&buffer[0], length);
-   if (!eof())
-     str.assign(&buffer[0], length);
-   return *this;
- }
- 
--binarystream &binarystream::operator>>(u_int8_t &u8) {
-+binarystream &binarystream::operator>>(uint8_t &u8) {
-   stream_.read((char *)&u8, 1);
-   return *this;
- }
- 
--binarystream &binarystream::operator>>(u_int16_t &u16) {
--  u_int16_t temp;
-+binarystream &binarystream::operator>>(uint16_t &u16) {
-+  uint16_t temp;
-   stream_.read((char *)&temp, 2);
-   if (!eof())
-     u16 = ntohs(temp);
-   return *this;
- }
- 
--binarystream &binarystream::operator>>(u_int32_t &u32) {
--  u_int32_t temp;
-+binarystream &binarystream::operator>>(uint32_t &u32) {
-+  uint32_t temp;
-   stream_.read((char *)&temp, 4);
-   if (!eof())
-     u32 = ntohl(temp);
-   return *this;
- }
- 
--binarystream &binarystream::operator>>(u_int64_t &u64) {
--  u_int32_t lower, upper;
-+binarystream &binarystream::operator>>(uint64_t &u64) {
-+  uint32_t lower, upper;
-   *this >> lower >> upper;
-   if (!eof())
--    u64 = static_cast<u_int64_t>(lower) | (static_cast<u_int64_t>(upper) << 32);
-+    u64 = static_cast<uint64_t>(lower) | (static_cast<uint64_t>(upper) << 32);
-   return *this;
- }
- 
- binarystream &binarystream::operator<<(const string &str) {
-   if (str.length() > USHRT_MAX) {
-     // truncate to 16-bit length
--    *this << static_cast<u_int16_t>(USHRT_MAX);
-+    *this << static_cast<uint16_t>(USHRT_MAX);
-     stream_.write(str.c_str(), USHRT_MAX);
-   } else {
--    *this << (u_int16_t)(str.length() & 0xFFFF);
-+    *this << (uint16_t)(str.length() & 0xFFFF);
-     stream_.write(str.c_str(), str.length());
-   }
-   return *this;
- }
- 
--binarystream &binarystream::operator<<(u_int8_t u8) {
-+binarystream &binarystream::operator<<(uint8_t u8) {
-   stream_.write((const char*)&u8, 1);
-   return *this;
- }
- 
--binarystream &binarystream::operator<<(u_int16_t u16) {
-+binarystream &binarystream::operator<<(uint16_t u16) {
-   u16 = htons(u16);
-   stream_.write((const char*)&u16, 2);
-   return *this;
- }
- 
--binarystream &binarystream::operator<<(u_int32_t u32) {
-+binarystream &binarystream::operator<<(uint32_t u32) {
-   u32 = htonl(u32);
-   stream_.write((const char*)&u32, 4);
-   return *this;
- }
- 
--binarystream &binarystream::operator<<(u_int64_t u64) {
-+binarystream &binarystream::operator<<(uint64_t u64) {
-   // write 64-bit ints as two 32-bit ints, so we can byte-swap them easily
--  u_int32_t lower = static_cast<u_int32_t>(u64 & 0xFFFFFFFF);
--  u_int32_t upper = static_cast<u_int32_t>(u64 >> 32);
-+  uint32_t lower = static_cast<uint32_t>(u64 & 0xFFFFFFFF);
-+  uint32_t upper = static_cast<uint32_t>(u64 >> 32);
-   *this << lower << upper;
-   return *this;
- }
- 
- }  // namespace google_breakpad
-diff --git a/src/processor/binarystream.h b/src/processor/binarystream.h
---- a/src/processor/binarystream.h
-+++ b/src/processor/binarystream.h
-@@ -51,27 +51,27 @@
-   explicit binarystream(const string &str,
-                         ios_base::openmode which = ios_base::out|ios_base::in)
-     : stream_(str, which) {}
-   explicit binarystream(const char *str, size_t size,
-                         ios_base::openmode which = ios_base::out|ios_base::in)
-     : stream_(string(str, size), which) {}
- 
-   binarystream &operator>>(string &str);
--  binarystream &operator>>(u_int8_t &u8);
--  binarystream &operator>>(u_int16_t &u16);
--  binarystream &operator>>(u_int32_t &u32);
--  binarystream &operator>>(u_int64_t &u64);
-+  binarystream &operator>>(uint8_t &u8);
-+  binarystream &operator>>(uint16_t &u16);
-+  binarystream &operator>>(uint32_t &u32);
-+  binarystream &operator>>(uint64_t &u64);
- 
-   // Note: strings are truncated at 65535 characters
-   binarystream &operator<<(const string &str);
--  binarystream &operator<<(u_int8_t u8);
--  binarystream &operator<<(u_int16_t u16);
--  binarystream &operator<<(u_int32_t u32);
--  binarystream &operator<<(u_int64_t u64);
-+  binarystream &operator<<(uint8_t u8);
-+  binarystream &operator<<(uint16_t u16);
-+  binarystream &operator<<(uint32_t u32);
-+  binarystream &operator<<(uint64_t u64);
- 
-   // Forward a few methods directly from the stream object
-   bool eof() const { return stream_.eof(); }
-   void clear() { stream_.clear(); }
-   string str() const { return stream_.str(); }
-   void str(const string &s) { stream_.str(s); }
-     
-   // Seek both read and write pointers to the beginning of the stream.
-diff --git a/src/processor/binarystream_unittest.cc b/src/processor/binarystream_unittest.cc
---- a/src/processor/binarystream_unittest.cc
-+++ b/src/processor/binarystream_unittest.cc
-@@ -42,69 +42,69 @@
- 
- 
- class BinaryStreamBasicTest : public ::testing::Test {
- protected:
-   binarystream stream;
- };
-  
- TEST_F(BinaryStreamBasicTest, ReadU8) {
--  u_int8_t u8 = 0;
-+  uint8_t u8 = 0;
-   ASSERT_FALSE(stream.eof());
-   stream >> u8;
-   ASSERT_TRUE(stream.eof());
-   EXPECT_EQ(0U, u8);
-   stream.rewind();
-   stream.clear();
--  stream << (u_int8_t)1;
-+  stream << (uint8_t)1;
-   ASSERT_FALSE(stream.eof());
-   stream >> u8;
-   EXPECT_EQ(1, u8);
-   EXPECT_FALSE(stream.eof());
- }
- 
- TEST_F(BinaryStreamBasicTest, ReadU16) {
--  u_int16_t u16 = 0;
-+  uint16_t u16 = 0;
-   ASSERT_FALSE(stream.eof());
-   stream >> u16;
-   ASSERT_TRUE(stream.eof());
-   EXPECT_EQ(0U, u16);
-   stream.rewind();
-   stream.clear();
--  stream << (u_int16_t)1;
-+  stream << (uint16_t)1;
-   ASSERT_FALSE(stream.eof());
-   stream >> u16;
-   EXPECT_EQ(1, u16);
-   EXPECT_FALSE(stream.eof());
- }
- 
- TEST_F(BinaryStreamBasicTest, ReadU32) {
--  u_int32_t u32 = 0;
-+  uint32_t u32 = 0;
-   ASSERT_FALSE(stream.eof());
-   stream >> u32;
-   ASSERT_TRUE(stream.eof());
-   EXPECT_EQ(0U, u32);
-   stream.rewind();
-   stream.clear();
--  stream << (u_int32_t)1;
-+  stream << (uint32_t)1;
-   ASSERT_FALSE(stream.eof());
-   stream >> u32;
-   EXPECT_EQ(1U, u32);
-   EXPECT_FALSE(stream.eof());
- }
- 
- TEST_F(BinaryStreamBasicTest, ReadU64) {
--  u_int64_t u64 = 0;
-+  uint64_t u64 = 0;
-   ASSERT_FALSE(stream.eof());
-   stream >> u64;
-   ASSERT_TRUE(stream.eof());
-   EXPECT_EQ(0U, u64);
-   stream.rewind();
-   stream.clear();
--  stream << (u_int64_t)1;
-+  stream << (uint64_t)1;
-   ASSERT_FALSE(stream.eof());
-   stream >> u64;
-   EXPECT_EQ(1U, u64);
-   EXPECT_FALSE(stream.eof());
- }
- 
- TEST_F(BinaryStreamBasicTest, ReadString) {
-   string s("");
-@@ -132,18 +132,18 @@
- TEST_F(BinaryStreamBasicTest, ReadEmptyString) {
-   string s("abc");
-   stream << string("");
-   stream >> s;
-   EXPECT_EQ("", s);
- }
- 
- TEST_F(BinaryStreamBasicTest, ReadMultiU8) {
--  const u_int8_t ea = 0, eb = 100, ec = 200, ed = 0xFF;
--  u_int8_t a, b, c, d, e;
-+  const uint8_t ea = 0, eb = 100, ec = 200, ed = 0xFF;
-+  uint8_t a, b, c, d, e;
-   stream << ea << eb << ec << ed;
-   stream >> a >> b >> c >> d;
-   ASSERT_FALSE(stream.eof());
-   EXPECT_EQ(ea, a);
-   EXPECT_EQ(eb, b);
-   EXPECT_EQ(ec, c);
-   EXPECT_EQ(ed, d);
-   ASSERT_FALSE(stream.eof());
-@@ -162,18 +162,18 @@
-   EXPECT_EQ(eb, b);
-   EXPECT_EQ(ec, c);
-   EXPECT_EQ(ed, d);
-   EXPECT_EQ(0U, e);
-   EXPECT_TRUE(stream.eof());
- }
- 
- TEST_F(BinaryStreamBasicTest, ReadMultiU16) {
--  const u_int16_t ea = 0, eb = 0x100, ec = 0x8000, ed = 0xFFFF;
--  u_int16_t a, b, c, d, e;
-+  const uint16_t ea = 0, eb = 0x100, ec = 0x8000, ed = 0xFFFF;
-+  uint16_t a, b, c, d, e;
-   stream << ea << eb << ec << ed;
-   stream >> a >> b >> c >> d;
-   ASSERT_FALSE(stream.eof());
-   EXPECT_EQ(ea, a);
-   EXPECT_EQ(eb, b);
-   EXPECT_EQ(ec, c);
-   EXPECT_EQ(ed, d);
-   ASSERT_FALSE(stream.eof());
-@@ -192,18 +192,18 @@
-   EXPECT_EQ(eb, b);
-   EXPECT_EQ(ec, c);
-   EXPECT_EQ(ed, d);
-   EXPECT_EQ(0U, e);
-   EXPECT_TRUE(stream.eof());
- }
- 
- TEST_F(BinaryStreamBasicTest, ReadMultiU32) {
--  const u_int32_t ea = 0, eb = 0x10000, ec = 0x8000000, ed = 0xFFFFFFFF;
--  u_int32_t a, b, c, d, e;
-+  const uint32_t ea = 0, eb = 0x10000, ec = 0x8000000, ed = 0xFFFFFFFF;
-+  uint32_t a, b, c, d, e;
-   stream << ea << eb << ec << ed;
-   stream >> a >> b >> c >> d;
-   ASSERT_FALSE(stream.eof());
-   EXPECT_EQ(ea, a);
-   EXPECT_EQ(eb, b);
-   EXPECT_EQ(ec, c);
-   EXPECT_EQ(ed, d);
-   ASSERT_FALSE(stream.eof());
-@@ -222,19 +222,19 @@
-   EXPECT_EQ(eb, b);
-   EXPECT_EQ(ec, c);
-   EXPECT_EQ(ed, d);
-   EXPECT_EQ(0U, e);
-   EXPECT_TRUE(stream.eof());
- }
- 
- TEST_F(BinaryStreamBasicTest, ReadMultiU64) {
--  const u_int64_t ea = 0, eb = 0x10000, ec = 0x100000000ULL,
-+  const uint64_t ea = 0, eb = 0x10000, ec = 0x100000000ULL,
-     ed = 0xFFFFFFFFFFFFFFFFULL;
--  u_int64_t a, b, c, d, e;
-+  uint64_t a, b, c, d, e;
-   stream << ea << eb << ec << ed;
-   stream >> a >> b >> c >> d;
-   ASSERT_FALSE(stream.eof());
-   EXPECT_EQ(ea, a);
-   EXPECT_EQ(eb, b);
-   EXPECT_EQ(ec, c);
-   EXPECT_EQ(ed, d);
-   ASSERT_FALSE(stream.eof());
-@@ -253,73 +253,73 @@
-   EXPECT_EQ(eb, b);
-   EXPECT_EQ(ec, c);
-   EXPECT_EQ(ed, d);
-   EXPECT_EQ(0U, e);
-   EXPECT_TRUE(stream.eof());
- }
- 
- TEST_F(BinaryStreamBasicTest, ReadMixed) {
--  const u_int8_t e8 = 0x10;
--  const u_int16_t e16 = 0x2020;
--  const u_int32_t e32 = 0x30303030;
--  const u_int64_t e64 = 0x4040404040404040ULL;
-+  const uint8_t e8 = 0x10;
-+  const uint16_t e16 = 0x2020;
-+  const uint32_t e32 = 0x30303030;
-+  const uint64_t e64 = 0x4040404040404040ULL;
-   const string es = "test";
--  u_int8_t u8 = 0;
--  u_int16_t u16 = 0;
--  u_int32_t u32 = 0;
--  u_int64_t u64 = 0;
-+  uint8_t u8 = 0;
-+  uint16_t u16 = 0;
-+  uint32_t u32 = 0;
-+  uint64_t u64 = 0;
-   string s("test");
-   stream << e8 << e16 << e32 << e64 << es;
-   stream >> u8 >> u16 >> u32 >> u64 >> s;
-   EXPECT_FALSE(stream.eof());
-   EXPECT_EQ(e8, u8);
-   EXPECT_EQ(e16, u16);
-   EXPECT_EQ(e32, u32);
-   EXPECT_EQ(e64, u64);
-   EXPECT_EQ(es, s);
- }
- 
- TEST_F(BinaryStreamBasicTest, ReadStringMissing) {
-   // ensure that reading a string where only the length is present fails
--  u_int16_t u16 = 8;
-+  uint16_t u16 = 8;
-   stream << u16;
-   stream.rewind();
-   string s("");
-   stream >> s;
-   EXPECT_EQ("", s);
-   EXPECT_TRUE(stream.eof());
- }
- 
- TEST_F(BinaryStreamBasicTest, ReadStringTruncated) {
-   // ensure that reading a string where not all the data is present fails
--  u_int16_t u16 = 8;
-+  uint16_t u16 = 8;
-   stream << u16;
--  stream << (u_int8_t)'t' << (u_int8_t)'e' << (u_int8_t)'s' << (u_int8_t)'t';
-+  stream << (uint8_t)'t' << (uint8_t)'e' << (uint8_t)'s' << (uint8_t)'t';
-   stream.rewind();
-   string s("");
-   stream >> s;
-   EXPECT_EQ("", s);
-   EXPECT_TRUE(stream.eof());
- }
- 
- TEST_F(BinaryStreamBasicTest, StreamByteLength) {
-   // Test that the stream buffer contains the right amount of data
--  stream << (u_int8_t)0 << (u_int16_t)1 << (u_int32_t)2 << (u_int64_t)3
-+  stream << (uint8_t)0 << (uint16_t)1 << (uint32_t)2 << (uint64_t)3
-          << string("test");
-   string s = stream.str();
-   EXPECT_EQ(21U, s.length());
- }
- 
- TEST_F(BinaryStreamBasicTest, AppendStreamResultsByteLength) {
-   // Test that appending the str() results from two streams
-   // gives the right byte length
-   binarystream stream2;
--  stream << (u_int8_t)0 << (u_int16_t)1;
--  stream2 << (u_int32_t)0 << (u_int64_t)2
-+  stream << (uint8_t)0 << (uint16_t)1;
-+  stream2 << (uint32_t)0 << (uint64_t)2
-           << string("test");
-   string s = stream.str();
-   string s2 = stream2.str();
-   s.append(s2);
-   EXPECT_EQ(21U, s.length());
- }
- 
- TEST_F(BinaryStreamBasicTest, StreamSetStr) {
-@@ -339,38 +339,38 @@
-   EXPECT_EQ("test", s);
- }
- 
- class BinaryStreamU8Test : public ::testing::Test {
- protected:
-   binarystream stream;
- 
-   void SetUp() {
--    stream << (u_int8_t)1;
-+    stream << (uint8_t)1;
-   }
- };
- 
- TEST_F(BinaryStreamU8Test, ReadU16) {
--  u_int16_t u16 = 0;
-+  uint16_t u16 = 0;
-   ASSERT_FALSE(stream.eof());
-   stream >> u16;
-   ASSERT_TRUE(stream.eof());
-   EXPECT_EQ(0U, u16);
- }
- 
- TEST_F(BinaryStreamU8Test, ReadU32) {
--  u_int32_t u32 = 0;
-+  uint32_t u32 = 0;
-   ASSERT_FALSE(stream.eof());
-   stream >> u32;
-   ASSERT_TRUE(stream.eof());
-   EXPECT_EQ(0U, u32);
- }
- 
- TEST_F(BinaryStreamU8Test, ReadU64) {
--  u_int64_t u64 = 0;
-+  uint64_t u64 = 0;
-   ASSERT_FALSE(stream.eof());
-   stream >> u64;
-   ASSERT_TRUE(stream.eof());
-   EXPECT_EQ(0U, u64);
- }
- 
- TEST_F(BinaryStreamU8Test, ReadString) {
-   string s("");
-@@ -379,29 +379,29 @@
-   ASSERT_TRUE(stream.eof());
-   EXPECT_EQ("", s);
- }
- 
- 
- TEST(BinaryStreamTest, InitWithData) {
-   const char *data = "abcd";
-   binarystream stream(data);
--  u_int8_t a, b, c, d;
-+  uint8_t a, b, c, d;
-   stream >> a >> b >> c >> d;
-   ASSERT_FALSE(stream.eof());
-   EXPECT_EQ('a', a);
-   EXPECT_EQ('b', b);
-   EXPECT_EQ('c', c);
-   EXPECT_EQ('d', d);
- }
- 
- TEST(BinaryStreamTest, InitWithDataLeadingNull) {
-   const char *data = "\0abcd";
-   binarystream stream(data, 5);
--  u_int8_t z, a, b, c, d;
-+  uint8_t z, a, b, c, d;
-   stream >> z >> a >> b >> c >> d;
-   ASSERT_FALSE(stream.eof());
-   EXPECT_EQ(0U, z);
-   EXPECT_EQ('a', a);
-   EXPECT_EQ('b', b);
-   EXPECT_EQ('c', c);
-   EXPECT_EQ('d', d);
- }
-@@ -410,17 +410,17 @@
-   vector<char> data;
-   data.push_back('a');
-   data.push_back('b');
-   data.push_back('c');
-   data.push_back('d');
-   data.push_back('e');
-   data.resize(4);
-   binarystream stream(&data[0], data.size());
--  u_int8_t a, b, c, d;
-+  uint8_t a, b, c, d;
-   stream >> a >> b >> c >> d;
-   ASSERT_FALSE(stream.eof());
-   EXPECT_EQ('a', a);
-   EXPECT_EQ('b', b);
-   EXPECT_EQ('c', c);
-   EXPECT_EQ('d', d);
- }
- 
-diff --git a/src/processor/cfi_frame_info.cc b/src/processor/cfi_frame_info.cc
---- a/src/processor/cfi_frame_info.cc
-+++ b/src/processor/cfi_frame_info.cc
-@@ -83,24 +83,24 @@
- 
-   (*caller_registers)[".ra"] = ra;
-   (*caller_registers)[".cfa"] = cfa;
- 
-   return true;
- }
- 
- // Explicit instantiations for 32-bit and 64-bit architectures.
--template bool CFIFrameInfo::FindCallerRegs<u_int32_t>(
--    const RegisterValueMap<u_int32_t> &registers,
-+template bool CFIFrameInfo::FindCallerRegs<uint32_t>(
-+    const RegisterValueMap<uint32_t> &registers,
-     const MemoryRegion &memory,
--    RegisterValueMap<u_int32_t> *caller_registers) const;
--template bool CFIFrameInfo::FindCallerRegs<u_int64_t>(
--    const RegisterValueMap<u_int64_t> &registers,
-+    RegisterValueMap<uint32_t> *caller_registers) const;
-+template bool CFIFrameInfo::FindCallerRegs<uint64_t>(
-+    const RegisterValueMap<uint64_t> &registers,
-     const MemoryRegion &memory,
--    RegisterValueMap<u_int64_t> *caller_registers) const;
-+    RegisterValueMap<uint64_t> *caller_registers) const;
- 
- string CFIFrameInfo::Serialize() const {
-   std::ostringstream stream;
- 
-   if (!cfa_rule_.empty()) {
-     stream << ".cfa: " << cfa_rule_;
-   }
-   if (!ra_rule_.empty()) {
-diff --git a/src/processor/cfi_frame_info.h b/src/processor/cfi_frame_info.h
---- a/src/processor/cfi_frame_info.h
-+++ b/src/processor/cfi_frame_info.h
-@@ -75,18 +75,18 @@
-   void SetCFARule(const string &expression) { cfa_rule_ = expression; }
-   void SetRARule(const string &expression)  { ra_rule_ = expression; }
-   void SetRegisterRule(const string &register_name, const string &expression) {
-     register_rules_[register_name] = expression;
-   }
- 
-   // Compute the values of the calling frame's registers, according to
-   // this rule set. Use ValueType in expression evaluation; this
--  // should be u_int32_t on machines with 32-bit addresses, or
--  // u_int64_t on machines with 64-bit addresses.
-+  // should be uint32_t on machines with 32-bit addresses, or
-+  // uint64_t on machines with 64-bit addresses.
-   //
-   // Return true on success, false otherwise.
-   //
-   // MEMORY provides access to the contents of the stack. REGISTERS is
-   // a dictionary mapping the names of registers whose values are
-   // known in the current frame to their values. CALLER_REGISTERS is
-   // populated with the values of the recoverable registers in the
-   // frame that called the current frame.
-@@ -199,17 +199,17 @@
- //
- // This class template doesn't use any internal knowledge of CFIFrameInfo
- // or the other stack walking structures; it just uses the public interface
- // of CFIFrameInfo to do the usual things. But the logic it handles should
- // be common to many different architectures' stack walkers, so wrapping it
- // up in a class should allow the walkers to share code.
- //
- // RegisterType should be the type of this architecture's registers, either
--// u_int32_t or u_int64_t. RawContextType should be the raw context
-+// uint32_t or uint64_t. RawContextType should be the raw context
- // structure type for this architecture.
- template <typename RegisterType, class RawContextType>
- class SimpleCFIWalker {
-  public:
-   // A structure describing one architecture register.
-   struct RegisterSet {
-     // The register name, as it appears in STACK CFI rules.
-     const char *name;
-diff --git a/src/processor/cfi_frame_info_unittest.cc b/src/processor/cfi_frame_info_unittest.cc
---- a/src/processor/cfi_frame_info_unittest.cc
-+++ b/src/processor/cfi_frame_info_unittest.cc
-@@ -49,70 +49,70 @@
- using testing::AtMost;
- using testing::DoAll;
- using testing::Return;
- using testing::SetArgumentPointee;
- using testing::Test;
- 
- class MockMemoryRegion: public MemoryRegion {
-  public:
--  MOCK_CONST_METHOD0(GetBase, u_int64_t());
--  MOCK_CONST_METHOD0(GetSize, u_int32_t());
--  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(u_int64_t, u_int8_t *));
--  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(u_int64_t, u_int16_t *));
--  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(u_int64_t, u_int32_t *));
--  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(u_int64_t, u_int64_t *));
-+  MOCK_CONST_METHOD0(GetBase, uint64_t());
-+  MOCK_CONST_METHOD0(GetSize, uint32_t());
-+  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint8_t *));
-+  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint16_t *));
-+  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint32_t *));
-+  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint64_t *));
- };
- 
- // Handy definitions for all tests.
- struct CFIFixture {
- 
-   // Set up the mock memory object to expect no references.
-   void ExpectNoMemoryReferences() {
-     EXPECT_CALL(memory, GetBase()).Times(0);
-     EXPECT_CALL(memory, GetSize()).Times(0);
--    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<u_int8_t *>())).Times(0);
--    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<u_int16_t *>())).Times(0);
--    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<u_int32_t *>())).Times(0);
--    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<u_int64_t *>())).Times(0);
-+    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint8_t *>())).Times(0);
-+    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint16_t *>())).Times(0);
-+    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint32_t *>())).Times(0);
-+    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint64_t *>())).Times(0);
-   }
- 
-   CFIFrameInfo cfi;
-   MockMemoryRegion memory;
--  CFIFrameInfo::RegisterValueMap<u_int64_t> registers, caller_registers;
-+  CFIFrameInfo::RegisterValueMap<uint64_t> registers, caller_registers;
- };
- 
- class Simple: public CFIFixture, public Test { };
- 
- // FindCallerRegs should fail if no .cfa rule is provided.
- TEST_F(Simple, NoCFA) {
-   ExpectNoMemoryReferences();
- 
-   cfi.SetRARule("0");
--  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                              &caller_registers));
-   ASSERT_EQ(".ra: 0", cfi.Serialize());
- }
- 
- // FindCallerRegs should fail if no .ra rule is provided.
- TEST_F(Simple, NoRA) {
-   ExpectNoMemoryReferences();
- 
-   cfi.SetCFARule("0");
--  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                              &caller_registers));
-   ASSERT_EQ(".cfa: 0", cfi.Serialize());
- }
- 
- TEST_F(Simple, SetCFAAndRARule) {
-   ExpectNoMemoryReferences();
- 
-   cfi.SetCFARule("330903416631436410");
-   cfi.SetRARule("5870666104170902211");
--  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                             &caller_registers));
-   ASSERT_EQ(2U, caller_registers.size());
-   ASSERT_EQ(330903416631436410ULL, caller_registers[".cfa"]);
-   ASSERT_EQ(5870666104170902211ULL, caller_registers[".ra"]);
- 
-   ASSERT_EQ(".cfa: 330903416631436410 .ra: 5870666104170902211",
-             cfi.Serialize());
- }
-@@ -121,17 +121,17 @@
-   ExpectNoMemoryReferences();
- 
-   cfi.SetCFARule("$temp1 68737028 = $temp2 61072337 = $temp1 $temp2 -");
-   cfi.SetRARule(".cfa 99804755 +");
-   cfi.SetRegisterRule("register1", ".cfa 54370437 *");
-   cfi.SetRegisterRule("vodkathumbscrewingly", "24076308 .cfa +");
-   cfi.SetRegisterRule("pubvexingfjordschmaltzy", ".cfa 29801007 -");
-   cfi.SetRegisterRule("uncopyrightables", "92642917 .cfa /");
--  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                             &caller_registers));
-   ASSERT_EQ(6U, caller_registers.size());
-   ASSERT_EQ(7664691U,           caller_registers[".cfa"]);
-   ASSERT_EQ(107469446U,         caller_registers[".ra"]);
-   ASSERT_EQ(416732599139967ULL, caller_registers["register1"]);
-   ASSERT_EQ(31740999U,          caller_registers["vodkathumbscrewingly"]);
-   ASSERT_EQ(-22136316ULL,       caller_registers["pubvexingfjordschmaltzy"]);
-   ASSERT_EQ(12U,                caller_registers["uncopyrightables"]);
-@@ -145,152 +145,152 @@
- }
- 
- TEST_F(Simple, RulesOverride) {
-   ExpectNoMemoryReferences();
- 
-   cfi.SetCFARule("330903416631436410");
-   cfi.SetRARule("5870666104170902211");
-   cfi.SetCFARule("2828089117179001");
--  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                             &caller_registers));
-   ASSERT_EQ(2U, caller_registers.size());
-   ASSERT_EQ(2828089117179001ULL, caller_registers[".cfa"]);
-   ASSERT_EQ(5870666104170902211ULL, caller_registers[".ra"]);
-   ASSERT_EQ(".cfa: 2828089117179001 .ra: 5870666104170902211",
-             cfi.Serialize());
- }
- 
- class Scope: public CFIFixture, public Test { };
- 
- // There should be no value for .cfa in scope when evaluating the CFA rule.
- TEST_F(Scope, CFALacksCFA) {
-   ExpectNoMemoryReferences();
- 
-   cfi.SetCFARule(".cfa");
-   cfi.SetRARule("0");
--  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                              &caller_registers));
- }
- 
- // There should be no value for .ra in scope when evaluating the CFA rule.
- TEST_F(Scope, CFALacksRA) {
-   ExpectNoMemoryReferences();
- 
-   cfi.SetCFARule(".ra");
-   cfi.SetRARule("0");
--  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                              &caller_registers));
- }
- 
- // The current frame's registers should be in scope when evaluating
- // the CFA rule.
- TEST_F(Scope, CFASeesCurrentRegs) {
-   ExpectNoMemoryReferences();
- 
-   registers[".baraminology"] = 0x06a7bc63e4f13893ULL;
-   registers[".ornithorhynchus"] = 0x5e0bf850bafce9d2ULL;
-   cfi.SetCFARule(".baraminology .ornithorhynchus +");
-   cfi.SetRARule("0");
--  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                             &caller_registers));
-   ASSERT_EQ(2U, caller_registers.size());
-   ASSERT_EQ(0x06a7bc63e4f13893ULL + 0x5e0bf850bafce9d2ULL,
-             caller_registers[".cfa"]);
- }
- 
- // .cfa should be in scope in the return address expression.
- TEST_F(Scope, RASeesCFA) {
-   ExpectNoMemoryReferences();
- 
-   cfi.SetCFARule("48364076");
-   cfi.SetRARule(".cfa");
--  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                             &caller_registers));
-   ASSERT_EQ(2U, caller_registers.size());
-   ASSERT_EQ(48364076U, caller_registers[".ra"]);
- }
- 
- // There should be no value for .ra in scope when evaluating the CFA rule.
- TEST_F(Scope, RALacksRA) {
-   ExpectNoMemoryReferences();
- 
-   cfi.SetCFARule("0");
-   cfi.SetRARule(".ra");
--  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                              &caller_registers));
- }
- 
- // The current frame's registers should be in scope in the return
- // address expression.
- TEST_F(Scope, RASeesCurrentRegs) {
-   ExpectNoMemoryReferences();
- 
-   registers["noachian"] = 0x54dc4a5d8e5eb503ULL;
-   cfi.SetCFARule("10359370");
-   cfi.SetRARule("noachian");
--  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                             &caller_registers));
-   ASSERT_EQ(2U, caller_registers.size());
-   ASSERT_EQ(0x54dc4a5d8e5eb503ULL, caller_registers[".ra"]);
- }
- 
- // .cfa should be in scope for register rules.
- TEST_F(Scope, RegistersSeeCFA) {
-   ExpectNoMemoryReferences();
- 
-   cfi.SetCFARule("6515179");
-   cfi.SetRARule(".cfa");
-   cfi.SetRegisterRule("rogerian", ".cfa");
--  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                             &caller_registers));
-   ASSERT_EQ(3U, caller_registers.size());
-   ASSERT_EQ(6515179U, caller_registers["rogerian"]);
- }
- 
- // The return address should not be in scope for register rules.
- TEST_F(Scope, RegsLackRA) {
-   ExpectNoMemoryReferences();
- 
-   cfi.SetCFARule("42740329");
-   cfi.SetRARule("27045204");
-   cfi.SetRegisterRule("$r1", ".ra");
--  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                              &caller_registers));
- }
- 
- // Register rules can see the current frame's register values.
- TEST_F(Scope, RegsSeeRegs) {
-   ExpectNoMemoryReferences();
- 
-   registers["$r1"] = 0x6ed3582c4bedb9adULL;
-   registers["$r2"] = 0xd27d9e742b8df6d0ULL;
-   cfi.SetCFARule("88239303");
-   cfi.SetRARule("30503835");
-   cfi.SetRegisterRule("$r1", "$r1 42175211 = $r2");
-   cfi.SetRegisterRule("$r2", "$r2 21357221 = $r1");
--  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                             &caller_registers));
-   ASSERT_EQ(4U, caller_registers.size());
-   ASSERT_EQ(0xd27d9e742b8df6d0ULL, caller_registers["$r1"]);
-   ASSERT_EQ(0x6ed3582c4bedb9adULL, caller_registers["$r2"]);
- }
- 
- // Each rule's temporaries are separate.
- TEST_F(Scope, SeparateTempsRA) {
-   ExpectNoMemoryReferences();
- 
-   cfi.SetCFARule("$temp1 76569129 = $temp1");
-   cfi.SetRARule("0");
--  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                             &caller_registers));
- 
-   cfi.SetCFARule("$temp1 76569129 = $temp1");
-   cfi.SetRARule("$temp1");
--  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                              &caller_registers));
- }
- 
- class MockCFIRuleParserHandler: public CFIRuleParser::Handler {
-  public:
-   MOCK_METHOD1(CFARule, void(const string &));
-   MOCK_METHOD1(RARule,  void(const string &));
-   MOCK_METHOD2(RegisterRule, void(const string &, const string &));
-@@ -422,53 +422,53 @@
- 
- class ParseHandler: public ParseHandlerFixture, public Test { };
- 
- TEST_F(ParseHandler, CFARARule) {
-   handler.CFARule("reg-for-cfa");
-   handler.RARule("reg-for-ra");
-   registers["reg-for-cfa"] = 0x268a9a4a3821a797ULL;
-   registers["reg-for-ra"] = 0x6301b475b8b91c02ULL;
--  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                             &caller_registers));
-   ASSERT_EQ(0x268a9a4a3821a797ULL, caller_registers[".cfa"]);
-   ASSERT_EQ(0x6301b475b8b91c02ULL, caller_registers[".ra"]);
- }
- 
- TEST_F(ParseHandler, RegisterRules) {
-   handler.CFARule("reg-for-cfa");
-   handler.RARule("reg-for-ra");
-   handler.RegisterRule("reg1", "reg-for-reg1");
-   handler.RegisterRule("reg2", "reg-for-reg2");
-   registers["reg-for-cfa"] = 0x268a9a4a3821a797ULL;
-   registers["reg-for-ra"] = 0x6301b475b8b91c02ULL;
-   registers["reg-for-reg1"] = 0x06cde8e2ff062481ULL;
-   registers["reg-for-reg2"] = 0xff0c4f76403173e2ULL;
--  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
-+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
-                                             &caller_registers));
-   ASSERT_EQ(0x268a9a4a3821a797ULL, caller_registers[".cfa"]);
-   ASSERT_EQ(0x6301b475b8b91c02ULL, caller_registers[".ra"]);
-   ASSERT_EQ(0x06cde8e2ff062481ULL, caller_registers["reg1"]);
-   ASSERT_EQ(0xff0c4f76403173e2ULL, caller_registers["reg2"]);
- }
- 
- struct SimpleCFIWalkerFixture {
-   struct RawContext {
--    u_int64_t r0, r1, r2, r3, r4, sp, pc;
-+    uint64_t r0, r1, r2, r3, r4, sp, pc;
-   };
-   enum Validity {
-     R0_VALID = 0x01,
-     R1_VALID = 0x02,
-     R2_VALID = 0x04,
-     R3_VALID = 0x08,
-     R4_VALID = 0x10,
-     SP_VALID = 0x20,
-     PC_VALID = 0x40
-   };
--  typedef SimpleCFIWalker<u_int64_t, RawContext> CFIWalker;
-+  typedef SimpleCFIWalker<uint64_t, RawContext> CFIWalker;
- 
-   SimpleCFIWalkerFixture()
-       : walker(register_map,
-                sizeof(register_map) / sizeof(register_map[0])) { }
- 
-   static CFIWalker::RegisterSet register_map[7];
-   CFIFrameInfo call_frame_info;
-   CFIWalker walker;
-@@ -499,26 +499,26 @@
-   // cfa -> 
-   //
-   // r0 has been saved on the stack.
-   // r1 has been saved in r2.
-   // r2 and r3 are not recoverable.
-   // r4 is not recoverable, even though it is a callee-saves register.
-   //    Some earlier frame's unwinder must have failed to recover it.
- 
--  u_int64_t stack_top = 0x83254944b20d5512ULL;
-+  uint64_t stack_top = 0x83254944b20d5512ULL;
- 
-   // Saved r0.
-   EXPECT_CALL(memory,
--              GetMemoryAtAddress(stack_top, A<u_int64_t *>()))
-+              GetMemoryAtAddress(stack_top, A<uint64_t *>()))
-       .WillRepeatedly(DoAll(SetArgumentPointee<1>(0xdc1975eba8602302ULL),
-                             Return(true)));
-   // Saved return address.
-   EXPECT_CALL(memory,
--              GetMemoryAtAddress(stack_top + 16, A<u_int64_t *>()))
-+              GetMemoryAtAddress(stack_top + 16, A<uint64_t *>()))
-       .WillRepeatedly(DoAll(SetArgumentPointee<1>(0xba5ad6d9acce28deULL),
-                             Return(true)));
- 
-   call_frame_info.SetCFARule("sp 24 +");
-   call_frame_info.SetRARule(".cfa 8 - ^");
-   call_frame_info.SetRegisterRule("r0", ".cfa 24 - ^");
-   call_frame_info.SetRegisterRule("r1", "r2");
- 
-diff --git a/src/processor/disassembler_x86.cc b/src/processor/disassembler_x86.cc
---- a/src/processor/disassembler_x86.cc
-+++ b/src/processor/disassembler_x86.cc
-@@ -26,19 +26,19 @@
- 
- #include "processor/disassembler_x86.h"
- 
- #include <string.h>
- #include <unistd.h>
- 
- namespace google_breakpad {
- 
--DisassemblerX86::DisassemblerX86(const u_int8_t *bytecode,
--                                 u_int32_t size,
--                                 u_int32_t virtual_address) :
-+DisassemblerX86::DisassemblerX86(const uint8_t *bytecode,
-+                                 uint32_t size,
-+                                 uint32_t virtual_address) :
-                                      bytecode_(bytecode),
-                                      size_(size),
-                                      virtual_address_(virtual_address),
-                                      current_byte_offset_(0),
-                                      current_inst_offset_(0),
-                                      instr_valid_(false),
-                                      register_valid_(false),
-                                      pushed_bad_value_(false),
-@@ -49,25 +49,25 @@
- 
- DisassemblerX86::~DisassemblerX86() {
-   if (instr_valid_)
-     libdis::x86_oplist_free(&current_instr_);
- 
-   libdis::x86_cleanup();
- }
- 
--u_int32_t DisassemblerX86::NextInstruction() {
-+uint32_t DisassemblerX86::NextInstruction() {
-   if (instr_valid_)
-     libdis::x86_oplist_free(&current_instr_);
- 
-   if (current_byte_offset_ >= size_) {
-     instr_valid_ = false;
-     return 0;
-   }
--  u_int32_t instr_size = 0;
-+  uint32_t instr_size = 0;
-   instr_size = libdis::x86_disasm((unsigned char *)bytecode_, size_,
-                           virtual_address_, current_byte_offset_,
-                           &current_instr_);
-   if (instr_size == 0) {
-     instr_valid_ = false;
-     return 0;
-   }
- 
-diff --git a/src/processor/disassembler_x86.h b/src/processor/disassembler_x86.h
---- a/src/processor/disassembler_x86.h
-+++ b/src/processor/disassembler_x86.h
-@@ -32,16 +32,17 @@
- // tests to be run against bytecode to test for various properties.
- //
- // Author: Cris Neckar
- 
- #ifndef GOOGLE_BREAKPAD_PROCESSOR_DISASSEMBLER_X86_H_
- #define GOOGLE_BREAKPAD_PROCESSOR_DISASSEMBLER_X86_H_
- 
- #include <stddef.h>
-+#include <sys/types.h>
- 
- #include "google_breakpad/common/breakpad_types.h"
- 
- namespace libdis {
- #include "third_party/libdisasm/libdis.h"
- }
- 
- namespace google_breakpad {
-@@ -57,25 +58,25 @@
-   DISX86_BAD_COMPARISON =       0x40
- };
- 
- class DisassemblerX86 {
-   public:
-     // TODO(cdn): Modify this class to take a MemoryRegion instead of just
-     // a raw buffer. This will make it easier to use this on arbitrary
-     // minidumps without first copying out the code segment.
--    DisassemblerX86(const u_int8_t *bytecode, u_int32_t, u_int32_t);
-+    DisassemblerX86(const uint8_t *bytecode, uint32_t, uint32_t);
-     ~DisassemblerX86();
- 
-     // This walks to the next instruction in the memory region and
-     // sets flags based on the type of instruction and previous state
-     // including any registers marked as bad through setBadRead()
-     // or setBadWrite(). This method can be called in a loop to
-     // disassemble until the end of a region.
--    u_int32_t NextInstruction();
-+    uint32_t NextInstruction();
- 
-     // Indicates whether the current disassembled instruction was valid.
-     bool currentInstructionValid() { return instr_valid_; }
- 
-     // Returns the current instruction as defined in libdis.h,
-     // or NULL if the current instruction is not valid.
-     const libdis::x86_insn_t* currentInstruction() {
-       return instr_valid_ ? &current_instr_ : NULL;
-@@ -85,42 +86,42 @@
-     libdis::x86_insn_group currentInstructionGroup() {
-       return current_instr_.group;
-     }
- 
-     // Indicates whether a return instruction has been encountered.
-     bool endOfBlock() { return end_of_block_; }
- 
-     // The flags set so far for the disassembly.
--    u_int16_t flags() { return flags_; }
-+    uint16_t flags() { return flags_; }
- 
-     // This sets an indicator that the register used to determine
-     // src or dest for the current instruction is tainted. These can
-     // be used after examining the current instruction to indicate,
-     // for example that a bad read or write occurred and the pointer
-     // stored in the register is currently invalid.
-     bool setBadRead();
-     bool setBadWrite();
- 
-   protected:
--    const u_int8_t *bytecode_;
--    u_int32_t size_;
--    u_int32_t virtual_address_;
--    u_int32_t current_byte_offset_;
--    u_int32_t current_inst_offset_;
-+    const uint8_t *bytecode_;
-+    uint32_t size_;
-+    uint32_t virtual_address_;
-+    uint32_t current_byte_offset_;
-+    uint32_t current_inst_offset_;
- 
-     bool instr_valid_;
-     libdis::x86_insn_t current_instr_;
- 
-     // TODO(cdn): Maybe also track an expression's index register.
-     // ex: mov eax, [ebx + ecx]; ebx is base, ecx is index.
-     bool register_valid_;
-     libdis::x86_reg_t bad_register_;
- 
-     bool pushed_bad_value_;
-     bool end_of_block_;
- 
--    u_int16_t flags_;
-+    uint16_t flags_;
- };
- 
- }  // namespace google_breakpad
- 
- #endif  // GOOGLE_BREAKPAD_PROCESSOR_DISASSEMBLER_X86_H_
-diff --git a/src/processor/exploitability.cc b/src/processor/exploitability.cc
---- a/src/processor/exploitability.cc
-+++ b/src/processor/exploitability.cc
-@@ -87,19 +87,19 @@
-   }
- 
-   BPLOG_IF(ERROR, !platform_exploitability) <<
-     "No Exploitability module for platform: " <<
-     process_state->system_info()->os;
-   return platform_exploitability;
- }
- 
--bool Exploitability::AddressIsAscii(u_int64_t address) {
-+bool Exploitability::AddressIsAscii(uint64_t address) {
-   for (int i = 0; i < 8; i++) {
--    u_int8_t byte = (address >> (8*i)) & 0xff;
-+    uint8_t byte = (address >> (8*i)) & 0xff;
-     if ((byte >= ' ' && byte <= '~') || byte == 0)
-       continue;
-     return false;
-   }
-   return true;
- }
- 
- }  // namespace google_breakpad
-diff --git a/src/processor/exploitability_win.cc b/src/processor/exploitability_win.cc
---- a/src/processor/exploitability_win.cc
-+++ b/src/processor/exploitability_win.cc
-@@ -45,18 +45,18 @@
- #include "processor/logging.h"
- 
- #include "third_party/libdisasm/libdis.h"
- 
- namespace google_breakpad {
- 
- // The cutoff that we use to judge if and address is likely an offset
- // from various interesting addresses.
--static const u_int64_t kProbableNullOffset = 4096;
--static const u_int64_t kProbableStackOffset = 8192;
-+static const uint64_t kProbableNullOffset = 4096;
-+static const uint64_t kProbableStackOffset = 8192;
- 
- // The various cutoffs for the different ratings.
- static const size_t kHighCutoff        = 100;
- static const size_t kMediumCutoff      = 80;
- static const size_t kLowCutoff         = 50;
- static const size_t kInterestingCutoff = 25;
- 
- // Predefined incremental values for conditional weighting.
-@@ -93,24 +93,24 @@
-   }
- 
-   MinidumpMemoryList *memory_list = dump_->GetMemoryList();
-   bool memory_available = true;
-   if (!memory_list) {
-     BPLOG(INFO) << "Minidump memory segments not available.";
-     memory_available = false;
-   }
--  u_int64_t address = process_state_->crash_address();
--  u_int32_t exception_code = raw_exception->exception_record.exception_code;
-+  uint64_t address = process_state_->crash_address();
-+  uint32_t exception_code = raw_exception->exception_record.exception_code;
- 
--  u_int32_t exploitability_weight = 0;
-+  uint32_t exploitability_weight = 0;
- 
--  u_int64_t stack_ptr = 0;
--  u_int64_t instruction_ptr = 0;
--  u_int64_t this_ptr = 0;
-+  uint64_t stack_ptr = 0;
-+  uint64_t instruction_ptr = 0;
-+  uint64_t this_ptr = 0;
- 
-   switch (context->GetContextCPU()) {
-     case MD_CONTEXT_X86:
-       stack_ptr = context->GetContextX86()->esp;
-       instruction_ptr = context->GetContextX86()->eip;
-       this_ptr = context->GetContextX86()->ecx;
-       break;
-     case MD_CONTEXT_AMD64:
-@@ -206,24 +206,24 @@
-         if (memory_available) {
-           instruction_region =
-               memory_list->GetMemoryRegionForAddress(instruction_ptr);
-         }
-         if (!near_null && instruction_region &&
-             context->GetContextCPU() == MD_CONTEXT_X86 &&
-             (bad_read || bad_write)) {
-           // Perform checks related to memory around instruction pointer.
--          u_int32_t memory_offset =
-+          uint32_t memory_offset =
-               instruction_ptr - instruction_region->GetBase();
--          u_int32_t available_memory =
-+          uint32_t available_memory =
-               instruction_region->GetSize() - memory_offset;
-           available_memory = available_memory > kDisassembleBytesBeyondPC ?
-               kDisassembleBytesBeyondPC : available_memory;
-           if (available_memory) {
--            const u_int8_t *raw_memory =
-+            const uint8_t *raw_memory =
-                 instruction_region->GetMemory() + memory_offset;
-             DisassemblerX86 disassembler(raw_memory,
-                                          available_memory,
-                                          instruction_ptr);
-             disassembler.NextInstruction();
-             if (bad_read)
-               disassembler.setBadRead();
-             else
-diff --git a/src/processor/fast_source_line_resolver.cc b/src/processor/fast_source_line_resolver.cc
---- a/src/processor/fast_source_line_resolver.cc
-+++ b/src/processor/fast_source_line_resolver.cc
-@@ -111,25 +111,25 @@
- WindowsFrameInfo FastSourceLineResolver::CopyWFI(const char *raw) {
-   const WindowsFrameInfo::StackInfoTypes type =
-      static_cast<const WindowsFrameInfo::StackInfoTypes>(
-          *reinterpret_cast<const int32_t*>(raw));
- 
-   // The first 8 bytes of int data are unused.
-   // They correspond to "StackInfoTypes type_;" and "int valid;"
-   // data member of WFI.
--  const u_int32_t *para_uint32 = reinterpret_cast<const u_int32_t*>(
-+  const uint32_t *para_uint32 = reinterpret_cast<const uint32_t*>(
-       raw + 2 * sizeof(int32_t));
- 
--  u_int32_t prolog_size = para_uint32[0];;
--  u_int32_t epilog_size = para_uint32[1];
--  u_int32_t parameter_size = para_uint32[2];
--  u_int32_t saved_register_size = para_uint32[3];
--  u_int32_t local_size = para_uint32[4];
--  u_int32_t max_stack_size = para_uint32[5];
-+  uint32_t prolog_size = para_uint32[0];;
-+  uint32_t epilog_size = para_uint32[1];
-+  uint32_t parameter_size = para_uint32[2];
-+  uint32_t saved_register_size = para_uint32[3];
-+  uint32_t local_size = para_uint32[4];
-+  uint32_t max_stack_size = para_uint32[5];
-   const char *boolean = reinterpret_cast<const char*>(para_uint32 + 6);
-   bool allocates_base_pointer = (*boolean != 0);
-   string program_string = boolean + 1;
- 
-   return WindowsFrameInfo(type,
-                           prolog_size,
-                           epilog_size,
-                           parameter_size,
-@@ -141,17 +141,17 @@
- }
- 
- // Loads a map from the given buffer in char* type.
- // Does NOT take ownership of mem_buffer.
- // In addition, treat mem_buffer as const char*.
- bool FastSourceLineResolver::Module::LoadMapFromMemory(char *mem_buffer) {
-   if (!mem_buffer) return false;
- 
--  const u_int32_t *map_sizes = reinterpret_cast<const u_int32_t*>(mem_buffer);
-+  const uint32_t *map_sizes = reinterpret_cast<const uint32_t*>(mem_buffer);
- 
-   unsigned int header_size = kNumberMaps_ * sizeof(unsigned int);
- 
-   // offsets[]: an array of offset addresses (with respect to mem_buffer),
-   // for each "Static***Map" component of Module.
-   // "Static***Map": static version of std::map or map wrapper, i.e., StaticMap,
-   // StaticAddressMap, StaticContainedRangeMap, and StaticRangeMap.
-   unsigned int offsets[kNumberMaps_];
-diff --git a/src/processor/fast_source_line_resolver_unittest.cc b/src/processor/fast_source_line_resolver_unittest.cc
---- a/src/processor/fast_source_line_resolver_unittest.cc
-+++ b/src/processor/fast_source_line_resolver_unittest.cc
-@@ -66,77 +66,77 @@
- using google_breakpad::linked_ptr;
- using google_breakpad::scoped_ptr;
- 
- class TestCodeModule : public CodeModule {
-  public:
-   explicit TestCodeModule(string code_file) : code_file_(code_file) {}
-   virtual ~TestCodeModule() {}
- 
--  virtual u_int64_t base_address() const { return 0; }
--  virtual u_int64_t size() const { return 0xb000; }
-+  virtual uint64_t base_address() const { return 0; }
-+  virtual uint64_t size() const { return 0xb000; }
-   virtual string code_file() const { return code_file_; }
-   virtual string code_identifier() const { return ""; }
-   virtual string debug_file() const { return ""; }
-   virtual string debug_identifier() const { return ""; }
-   virtual string version() const { return ""; }
-   virtual const CodeModule* Copy() const {
-     return new TestCodeModule(code_file_);
-   }
- 
-  private:
-   string code_file_;
- };
- 
- // A mock memory region object, for use by the STACK CFI tests.
- class MockMemoryRegion: public MemoryRegion {
--  u_int64_t GetBase() const { return 0x10000; }
--  u_int32_t GetSize() const { return 0x01000; }
--  bool GetMemoryAtAddress(u_int64_t address, u_int8_t *value) const {
-+  uint64_t GetBase() const { return 0x10000; }
-+  uint32_t GetSize() const { return 0x01000; }
-+  bool GetMemoryAtAddress(uint64_t address, uint8_t *value) const {
-     *value = address & 0xff;
-     return true;
-   }
--  bool GetMemoryAtAddress(u_int64_t address, u_int16_t *value) const {
-+  bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const {
-     *value = address & 0xffff;
-     return true;
-   }
--  bool GetMemoryAtAddress(u_int64_t address, u_int32_t *value) const {
-+  bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const {
-     switch (address) {
-       case 0x10008: *value = 0x98ecadc3; break;  // saved %ebx
-       case 0x1000c: *value = 0x878f7524; break;  // saved %esi
-       case 0x10010: *value = 0x6312f9a5; break;  // saved %edi
-       case 0x10014: *value = 0x10038;    break;  // caller's %ebp
-       case 0x10018: *value = 0xf6438648; break;  // return address
-       default: *value = 0xdeadbeef;      break;  // junk
-     }
-     return true;
-   }
--  bool GetMemoryAtAddress(u_int64_t address, u_int64_t *value) const {
-+  bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const {
-     *value = address;
-     return true;
-   }
- };
- 
- // Verify that, for every association in ACTUAL, EXPECTED has the same
- // association. (That is, ACTUAL's associations should be a subset of
- // EXPECTED's.) Also verify that ACTUAL has associations for ".ra" and
- // ".cfa".
- static bool VerifyRegisters(
-     const char *file, int line,
--    const CFIFrameInfo::RegisterValueMap<u_int32_t> &expected,
--    const CFIFrameInfo::RegisterValueMap<u_int32_t> &actual) {
--  CFIFrameInfo::RegisterValueMap<u_int32_t>::const_iterator a;
-+    const CFIFrameInfo::RegisterValueMap<uint32_t> &expected,
-+    const CFIFrameInfo::RegisterValueMap<uint32_t> &actual) {
-+  CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator a;
-   a = actual.find(".cfa");
-   if (a == actual.end())
-     return false;
-   a = actual.find(".ra");
-   if (a == actual.end())
-     return false;
-   for (a = actual.begin(); a != actual.end(); a++) {
--    CFIFrameInfo::RegisterValueMap<u_int32_t>::const_iterator e =
-+    CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator e =
-       expected.find(a->first);
-     if (e == expected.end()) {
-       fprintf(stderr, "%s:%d: unexpected register '%s' recovered, value 0x%x\n",
-               file, line, a->first.c_str(), a->second);
-       return false;
-     }
-     if (e->second != a->second) {
-       fprintf(stderr,
-@@ -275,19 +275,19 @@
-   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
-   ASSERT_FALSE(cfi_frame_info.get());
- 
-   frame.instruction = 0x3e9f;
-   frame.module = &module1;
-   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
-   ASSERT_FALSE(cfi_frame_info.get());
- 
--  CFIFrameInfo::RegisterValueMap<u_int32_t> current_registers;
--  CFIFrameInfo::RegisterValueMap<u_int32_t> caller_registers;
--  CFIFrameInfo::RegisterValueMap<u_int32_t> expected_caller_registers;
-+  CFIFrameInfo::RegisterValueMap<uint32_t> current_registers;
-+  CFIFrameInfo::RegisterValueMap<uint32_t> caller_registers;
-+  CFIFrameInfo::RegisterValueMap<uint32_t> expected_caller_registers;
-   MockMemoryRegion memory;
- 
-   // Regardless of which instruction evaluation takes place at, it
-   // should produce the same values for the caller's registers.
-   expected_caller_registers[".cfa"] = 0x1001c;
-   expected_caller_registers[".ra"]  = 0xf6438648;
-   expected_caller_registers["$ebp"] = 0x10038;
-   expected_caller_registers["$ebx"] = 0x98ecadc3;
-@@ -300,67 +300,67 @@
-   current_registers["$esp"] = 0x10018;
-   current_registers["$ebp"] = 0x10038;
-   current_registers["$ebx"] = 0x98ecadc3;
-   current_registers["$esi"] = 0x878f7524;
-   current_registers["$edi"] = 0x6312f9a5;
-   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
-   ASSERT_TRUE(cfi_frame_info.get());
-   ASSERT_TRUE(cfi_frame_info.get()
--              ->FindCallerRegs<u_int32_t>(current_registers, memory,
-+              ->FindCallerRegs<uint32_t>(current_registers, memory,
-                                           &caller_registers));
-   ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__,
-                               expected_caller_registers, caller_registers));
- 
-   frame.instruction = 0x3d41;
-   current_registers["$esp"] = 0x10014;
-   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
-   ASSERT_TRUE(cfi_frame_info.get());
-   ASSERT_TRUE(cfi_frame_info.get()
--              ->FindCallerRegs<u_int32_t>(current_registers, memory,
-+              ->FindCallerRegs<uint32_t>(current_registers, memory,
-                                           &caller_registers));
-   ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__,
-                               expected_caller_registers, caller_registers));
- 
-   frame.instruction = 0x3d43;
-   current_registers["$ebp"] = 0x10014;
-   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
-   ASSERT_TRUE(cfi_frame_info.get());
-   ASSERT_TRUE(cfi_frame_info.get()
--              ->FindCallerRegs<u_int32_t>(current_registers, memory,
-+              ->FindCallerRegs<uint32_t>(current_registers, memory,
-                                           &caller_registers));
-   VerifyRegisters(__FILE__, __LINE__,
-                   expected_caller_registers, caller_registers);
- 
-   frame.instruction = 0x3d54;
-   current_registers["$ebx"] = 0x6864f054U;
-   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
-   ASSERT_TRUE(cfi_frame_info.get());
-   ASSERT_TRUE(cfi_frame_info.get()
--              ->FindCallerRegs<u_int32_t>(current_registers, memory,
-+              ->FindCallerRegs<uint32_t>(current_registers, memory,
-                                           &caller_registers));
-   VerifyRegisters(__FILE__, __LINE__,
-                   expected_caller_registers, caller_registers);
- 
-   frame.instruction = 0x3d5a;
-   current_registers["$esi"] = 0x6285f79aU;
-   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
-   ASSERT_TRUE(cfi_frame_info.get());
-   ASSERT_TRUE(cfi_frame_info.get()
--              ->FindCallerRegs<u_int32_t>(current_registers, memory,
-+              ->FindCallerRegs<uint32_t>(current_registers, memory,
-                                           &caller_registers));
-   VerifyRegisters(__FILE__, __LINE__,
-                   expected_caller_registers, caller_registers);
- 
-   frame.instruction = 0x3d84;
-   current_registers["$edi"] = 0x64061449U;
-   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
-   ASSERT_TRUE(cfi_frame_info.get());
-   ASSERT_TRUE(cfi_frame_info.get()
--              ->FindCallerRegs<u_int32_t>(current_registers, memory,
-+              ->FindCallerRegs<uint32_t>(current_registers, memory,
-                                           &caller_registers));
-   VerifyRegisters(__FILE__, __LINE__,
-                   expected_caller_registers, caller_registers);
- 
-   frame.instruction = 0x2900;
-   frame.module = &module1;
-   fast_resolver.FillSourceLineInfo(&frame);
-   ASSERT_EQ(frame.function_name, string("PublicSymbol"));
-diff --git a/src/processor/logging.cc b/src/processor/logging.cc
---- a/src/processor/logging.cc
-+++ b/src/processor/logging.cc
-@@ -78,23 +78,23 @@
-   stream_ << time_string << ": " << PathnameStripper::File(file) << ":" <<
-              line << ": " << severity_string << ": ";
- }
- 
- LogStream::~LogStream() {
-   stream_ << std::endl;
- }
- 
--string HexString(u_int32_t number) {
-+string HexString(uint32_t number) {
-   char buffer[11];
-   snprintf(buffer, sizeof(buffer), "0x%x", number);
-   return string(buffer);
- }
- 
--string HexString(u_int64_t number) {
-+string HexString(uint64_t number) {
-   char buffer[19];
-   snprintf(buffer, sizeof(buffer), "0x%" PRIx64, number);
-   return string(buffer);
- }
- 
- string HexString(int number) {
-   char buffer[19];
-   snprintf(buffer, sizeof(buffer), "0x%x", number);
-diff --git a/src/processor/logging.h b/src/processor/logging.h
---- a/src/processor/logging.h
-+++ b/src/processor/logging.h
-@@ -114,18 +114,18 @@
-   LogMessageVoidify() {}
- 
-   // This has to be an operator with a precedence lower than << but higher
-   // than ?:
-   void operator&(std::ostream &) {}
- };
- 
- // Returns number formatted as a hexadecimal string, such as "0x7b".
--string HexString(u_int32_t number);
--string HexString(u_int64_t number);
-+string HexString(uint32_t number);
-+string HexString(uint64_t number);
- string HexString(int number);
- 
- // Returns the error code as set in the global errno variable, and sets
- // error_string, a required argument, to a string describing that error
- // code.
- int ErrnoString(string *error_string);
- 
- }  // namespace google_breakpad
-diff --git a/src/processor/map_serializers-inl.h b/src/processor/map_serializers-inl.h
---- a/src/processor/map_serializers-inl.h
-+++ b/src/processor/map_serializers-inl.h
-@@ -50,17 +50,17 @@
- #include "processor/logging.h"
- 
- namespace google_breakpad {
- 
- template<typename Key, typename Value>
- size_t StdMapSerializer<Key, Value>::SizeOf(
-     const std::map<Key, Value> &m) const {
-   size_t size = 0;
--  size_t header_size = (1 + m.size()) * sizeof(u_int32_t);
-+  size_t header_size = (1 + m.size()) * sizeof(uint32_t);
-   size += header_size;
- 
-   typename std::map<Key, Value>::const_iterator iter;
-   for (iter = m.begin(); iter != m.end(); ++iter) {
-     size += key_serializer_.SizeOf(iter->first);
-     size += value_serializer_.SizeOf(iter->second);
-   }
-   return size;
-@@ -72,29 +72,29 @@
-   if (!dest) {
-     BPLOG(ERROR) << "StdMapSerializer failed: write to NULL address.";
-     return NULL;
-   }
-   char *start_address = dest;
- 
-   // Write header:
-   // Number of nodes.
--  dest = SimpleSerializer<u_int32_t>::Write(m.size(), dest);
-+  dest = SimpleSerializer<uint32_t>::Write(m.size(), dest);
-   // Nodes offsets.
--  u_int32_t *offsets = reinterpret_cast<u_int32_t*>(dest);
--  dest += sizeof(u_int32_t) * m.size();
-+  uint32_t *offsets = reinterpret_cast<uint32_t*>(dest);
-+  dest += sizeof(uint32_t) * m.size();
- 
-   char *key_address = dest;
-   dest += sizeof(Key) * m.size();
- 
-   // Traverse map.
-   typename std::map<Key, Value>::const_iterator iter;
-   int index = 0;
-   for (iter = m.begin(); iter != m.end(); ++iter, ++index) {
--    offsets[index] = static_cast<u_int32_t>(dest - start_address);
-+    offsets[index] = static_cast<uint32_t>(dest - start_address);
-     key_address = key_serializer_.Write(iter->first, key_address);
-     dest = value_serializer_.Write(iter->second, dest);
-   }
-   return dest;
- }
- 
- template<typename Key, typename Value>
- char *StdMapSerializer<Key, Value>::Serialize(
-@@ -114,17 +114,17 @@
-   if (size) *size = size_to_alloc;
-   return serialized_data;
- }
- 
- template<typename Address, typename Entry>
- size_t RangeMapSerializer<Address, Entry>::SizeOf(
-     const RangeMap<Address, Entry> &m) const {
-   size_t size = 0;
--  size_t header_size = (1 + m.map_.size()) * sizeof(u_int32_t);
-+  size_t header_size = (1 + m.map_.size()) * sizeof(uint32_t);
-   size += header_size;
- 
-   typename std::map<Address, Range>::const_iterator iter;
-   for (iter = m.map_.begin(); iter != m.map_.end(); ++iter) {
-     // Size of key (high address).
-     size += address_serializer_.SizeOf(iter->first);
-     // Size of base (low address).
-     size += address_serializer_.SizeOf(iter->second.base());
-@@ -140,29 +140,29 @@
-   if (!dest) {
-     BPLOG(ERROR) << "RangeMapSerializer failed: write to NULL address.";
-     return NULL;
-   }
-   char *start_address = dest;
- 
-   // Write header:
-   // Number of nodes.
--  dest = SimpleSerializer<u_int32_t>::Write(m.map_.size(), dest);
-+  dest = SimpleSerializer<uint32_t>::Write(m.map_.size(), dest);
-   // Nodes offsets.
--  u_int32_t *offsets = reinterpret_cast<u_int32_t*>(dest);
--  dest += sizeof(u_int32_t) * m.map_.size();
-+  uint32_t *offsets = reinterpret_cast<uint32_t*>(dest);
-+  dest += sizeof(uint32_t) * m.map_.size();
- 
-   char *key_address = dest;
-   dest += sizeof(Address) * m.map_.size();
- 
-   // Traverse map.
-   typename std::map<Address, Range>::const_iterator iter;
-   int index = 0;
-   for (iter = m.map_.begin(); iter != m.map_.end(); ++iter, ++index) {
--    offsets[index] = static_cast<u_int32_t>(dest - start_address);
-+    offsets[index] = static_cast<uint32_t>(dest - start_address);
-     key_address = address_serializer_.Write(iter->first, key_address);
-     dest = address_serializer_.Write(iter->second.base(), dest);
-     dest = entry_serializer_.Write(iter->second.entry(), dest);
-   }
-   return dest;
- }
- 
- template<typename Address, typename Entry>
-@@ -187,22 +187,22 @@
- 
- 
- template<class AddrType, class EntryType>
- size_t ContainedRangeMapSerializer<AddrType, EntryType>::SizeOf(
-     const ContainedRangeMap<AddrType, EntryType> *m) const {
-   size_t size = 0;
-   size_t header_size = addr_serializer_.SizeOf(m->base_)
-                        + entry_serializer_.SizeOf(m->entry_)
--                       + sizeof(u_int32_t);
-+                       + sizeof(uint32_t);
-   size += header_size;
-   // In case m.map_ == NULL, we treat it as an empty map:
--  size += sizeof(u_int32_t);
-+  size += sizeof(uint32_t);
-   if (m->map_) {
--    size += m->map_->size() * sizeof(u_int32_t);
-+    size += m->map_->size() * sizeof(uint32_t);
-     typename Map::const_iterator iter;
-     for (iter = m->map_->begin(); iter != m->map_->end(); ++iter) {
-       size += addr_serializer_.SizeOf(iter->first);
-       // Recursive calculation of size:
-       size += SizeOf(iter->second);
-     }
-   }
-   return size;
-@@ -211,37 +211,37 @@
- template<class AddrType, class EntryType>
- char *ContainedRangeMapSerializer<AddrType, EntryType>::Write(
-     const ContainedRangeMap<AddrType, EntryType> *m, char *dest) const {
-   if (!dest) {
-     BPLOG(ERROR) << "StdMapSerializer failed: write to NULL address.";
-     return NULL;
-   }
-   dest = addr_serializer_.Write(m->base_, dest);
--  dest = SimpleSerializer<u_int32_t>::Write(entry_serializer_.SizeOf(m->entry_),
-+  dest = SimpleSerializer<uint32_t>::Write(entry_serializer_.SizeOf(m->entry_),
-                                             dest);
-   dest = entry_serializer_.Write(m->entry_, dest);
- 
-   // Write map<<AddrType, ContainedRangeMap*>:
-   char *map_address = dest;
-   if (m->map_ == NULL) {
--    dest = SimpleSerializer<u_int32_t>::Write(0, dest);
-+    dest = SimpleSerializer<uint32_t>::Write(0, dest);
-   } else {
--    dest = SimpleSerializer<u_int32_t>::Write(m->map_->size(), dest);
--    u_int32_t *offsets = reinterpret_cast<u_int32_t*>(dest);
--    dest += sizeof(u_int32_t) * m->map_->size();
-+    dest = SimpleSerializer<uint32_t>::Write(m->map_->size(), dest);
-+    uint32_t *offsets = reinterpret_cast<uint32_t*>(dest);
-+    dest += sizeof(uint32_t) * m->map_->size();
- 
-     char *key_address = dest;
-     dest += sizeof(AddrType) * m->map_->size();
- 
-     // Traverse map.
-     typename Map::const_iterator iter;
-     int index = 0;
-     for (iter = m->map_->begin(); iter != m->map_->end(); ++iter, ++index) {
--      offsets[index] = static_cast<u_int32_t>(dest - map_address);
-+      offsets[index] = static_cast<uint32_t>(dest - map_address);
-       key_address = addr_serializer_.Write(iter->first, key_address);
-       // Recursively write.
-       dest = Write(iter->second, dest);
-     }
-   }
-   return dest;
- }
- 
-diff --git a/src/processor/map_serializers_unittest.cc b/src/processor/map_serializers_unittest.cc
---- a/src/processor/map_serializers_unittest.cc
-+++ b/src/processor/map_serializers_unittest.cc
-@@ -59,23 +59,23 @@
-   }
- 
-   void TearDown() {
-     delete [] serialized_data_;
-   }
- 
-   std::map<AddrType, EntryType> std_map_;
-   google_breakpad::StdMapSerializer<AddrType, EntryType> serializer_;
--  u_int32_t serialized_size_;
-+  uint32_t serialized_size_;
-   char *serialized_data_;
- };
- 
- TEST_F(TestStdMapSerializer, EmptyMapTestCase) {
-   const int32_t correct_data[] = { 0 };
--  u_int32_t correct_size = sizeof(correct_data);
-+  uint32_t correct_size = sizeof(correct_data);
- 
-   // std_map_ is empty.
-   serialized_data_ = serializer_.Serialize(std_map_, &serialized_size_);
- 
-   EXPECT_EQ(correct_size, serialized_size_);
-   EXPECT_EQ(memcmp(correct_data, serialized_data_, correct_size), 0);
- }
- 
-@@ -85,17 +85,17 @@
-       2,
-       // Offsets
-       20, 24,
-       // Keys
-       1, 3,
-       // Values
-       2, 6
-   };
--  u_int32_t correct_size = sizeof(correct_data);
-+  uint32_t correct_size = sizeof(correct_data);
- 
-   std_map_.insert(std::make_pair(1, 2));
-   std_map_.insert(std::make_pair(3, 6));
- 
-   serialized_data_ = serializer_.Serialize(std_map_, &serialized_size_);
- 
-   EXPECT_EQ(correct_size, serialized_size_);
-   EXPECT_EQ(memcmp(correct_data, serialized_data_, correct_size), 0);
-@@ -107,17 +107,17 @@
-       5,
-       // Offsets
-       44, 48, 52, 56, 60,
-       // Keys
-       1, 2, 3, 4, 5,
-       // Values
-       11, 12, 13, 14, 15
-   };
--  u_int32_t correct_size = sizeof(correct_data);
-+  uint32_t correct_size = sizeof(correct_data);
- 
-   for (int i = 1; i < 6; ++i)
-     std_map_.insert(std::make_pair(i, 10 + i));
- 
-   serialized_data_ = serializer_.Serialize(std_map_, &serialized_size_);
- 
-   EXPECT_EQ(correct_size, serialized_size_);
-   EXPECT_EQ(memcmp(correct_data, serialized_data_, correct_size), 0);
-@@ -131,23 +131,23 @@
-   }
- 
-   void TearDown() {
-     delete [] serialized_data_;
-   }
- 
-   google_breakpad::AddressMap<AddrType, EntryType> address_map_;
-   google_breakpad::AddressMapSerializer<AddrType, EntryType> serializer_;
--  u_int32_t serialized_size_;
-+  uint32_t serialized_size_;
-   char *serialized_data_;
- };
- 
- TEST_F(TestAddressMapSerializer, EmptyMapTestCase) {
-   const int32_t correct_data[] = { 0 };
--  u_int32_t correct_size = sizeof(correct_data);
-+  uint32_t correct_size = sizeof(correct_data);
- 
-   // std_map_ is empty.
-   serialized_data_ = serializer_.Serialize(address_map_, &serialized_size_);
- 
-   EXPECT_EQ(correct_size, serialized_size_);
-   EXPECT_EQ(memcmp(correct_data, serialized_data_, correct_size), 0);
- }
- 
-@@ -157,17 +157,17 @@
-       2,
-       // Offsets
-       20, 24,
-       // Keys
-       1, 3,
-       // Values
-       2, 6
-   };
--  u_int32_t correct_size = sizeof(correct_data);
-+  uint32_t correct_size = sizeof(correct_data);
- 
-   address_map_.Store(1, 2);
-   address_map_.Store(3, 6);
- 
-   serialized_data_ = serializer_.Serialize(address_map_, &serialized_size_);
- 
-   EXPECT_EQ(correct_size, serialized_size_);
-   EXPECT_EQ(memcmp(correct_data, serialized_data_, correct_size), 0);
-@@ -179,17 +179,17 @@
-       4,
-       // Offsets
-       36, 40, 44, 48,
-       // Keys
-       -6, -4, 8, 123,
-       // Values
-       2, 3, 5, 8
-   };
--  u_int32_t correct_size = sizeof(correct_data);
-+  uint32_t correct_size = sizeof(correct_data);
- 
-   address_map_.Store(-6, 2);
-   address_map_.Store(-4, 3);
-   address_map_.Store(8, 5);
-   address_map_.Store(123, 8);
- 
-   serialized_data_ = serializer_.Serialize(address_map_, &serialized_size_);
- 
-@@ -206,23 +206,23 @@
-   }
- 
-   void TearDown() {
-     delete [] serialized_data_;
-   }
- 
-   google_breakpad::RangeMap<AddrType, EntryType> range_map_;
-   google_breakpad::RangeMapSerializer<AddrType, EntryType> serializer_;
--  u_int32_t serialized_size_;
-+  uint32_t serialized_size_;
-   char *serialized_data_;
- };
- 
- TEST_F(TestRangeMapSerializer, EmptyMapTestCase) {
-   const int32_t correct_data[] = { 0 };
--  u_int32_t correct_size = sizeof(correct_data);
-+  uint32_t correct_size = sizeof(correct_data);
- 
-   // range_map_ is empty.
-   serialized_data_ = serializer_.Serialize(range_map_, &serialized_size_);
- 
-   EXPECT_EQ(correct_size, serialized_size_);
-   EXPECT_EQ(memcmp(correct_data, serialized_data_, correct_size), 0);
- }
- 
-@@ -232,17 +232,17 @@
-       1,
-       // Offsets
-       12,
-       // Keys: high address
-       10,
-       // Values: (low address, entry) pairs
-       1, 6
-   };
--  u_int32_t correct_size = sizeof(correct_data);
-+  uint32_t correct_size = sizeof(correct_data);
- 
-   range_map_.StoreRange(1, 10, 6);
- 
-   serialized_data_ = serializer_.Serialize(range_map_, &serialized_size_);
- 
-   EXPECT_EQ(correct_size, serialized_size_);
-   EXPECT_EQ(memcmp(correct_data, serialized_data_, correct_size), 0);
- }
-@@ -253,17 +253,17 @@
-       3,
-       // Offsets
-       28,    36,    44,
-       // Keys: high address
-       5,     9,     20,
-       // Values: (low address, entry) pairs
-       2, 1,  6, 2,  10, 3
-   };
--  u_int32_t correct_size = sizeof(correct_data);
-+  uint32_t correct_size = sizeof(correct_data);
- 
-   ASSERT_TRUE(range_map_.StoreRange(2, 4, 1));
-   ASSERT_TRUE(range_map_.StoreRange(6, 4, 2));
-   ASSERT_TRUE(range_map_.StoreRange(10, 11, 3));
- 
-   serialized_data_ = serializer_.Serialize(range_map_, &serialized_size_);
- 
-   EXPECT_EQ(correct_size, serialized_size_);
-@@ -279,28 +279,28 @@
-   }
- 
-   void TearDown() {
-     delete [] serialized_data_;
-   }
- 
-   google_breakpad::ContainedRangeMap<AddrType, EntryType> crm_map_;
-   google_breakpad::ContainedRangeMapSerializer<AddrType, EntryType> serializer_;
--  u_int32_t serialized_size_;
-+  uint32_t serialized_size_;
-   char *serialized_data_;
- };
- 
- TEST_F(TestContainedRangeMapSerializer, EmptyMapTestCase) {
-   const int32_t correct_data[] = {
-       0,  // base address of root
-       4,  // size of entry
-       0,  // entry stored at root
-       0   // empty map stored at root
-   };
--  u_int32_t correct_size = sizeof(correct_data);
-+  uint32_t correct_size = sizeof(correct_data);
- 
-   // crm_map_ is empty.
-   serialized_data_ = serializer_.Serialize(&crm_map_, &serialized_size_);
- 
-   EXPECT_EQ(correct_size, serialized_size_);
-   EXPECT_EQ(memcmp(correct_data, serialized_data_, correct_size), 0);
- }
- 
-@@ -314,17 +314,17 @@
-       12, // offset
-       9,  // key
-       // value: a child ContainedRangeMap
-       3,  // base address of child CRM
-       4,  // size of entry
-       -1, // entry stored in child CRM
-       0   // empty sub-map stored in child CRM
-   };
--  u_int32_t correct_size = sizeof(correct_data);
-+  uint32_t correct_size = sizeof(correct_data);
- 
-   crm_map_.StoreRange(3, 7, -1);
- 
-   serialized_data_ = serializer_.Serialize(&crm_map_, &serialized_size_);
- 
-   EXPECT_EQ(correct_size, serialized_size_);
-   EXPECT_EQ(memcmp(correct_data, serialized_data_, correct_size), 0);
- }
-@@ -356,17 +356,17 @@
-         6, 4, -1, 0,
-       // child2: base, entry_size, entry:
-       10, 4, -1,
-       // child2's map: # of nodes, offset1, key1
-       1, 12, 20,
-         // grandchild3: base, entry_size, entry, empty_map
-         16, 4, -1, 0
-   };
--  u_int32_t correct_size = sizeof(correct_data);
-+  uint32_t correct_size = sizeof(correct_data);
- 
-   // Store child1.
-   ASSERT_TRUE(crm_map_.StoreRange(2, 7, -1));
-   // Store child2.
-   ASSERT_TRUE(crm_map_.StoreRange(10, 11, -1));
-   // Store grandchild1.
-   ASSERT_TRUE(crm_map_.StoreRange(3, 2, -1));
-   // Store grandchild2.
-diff --git a/src/processor/minidump.cc b/src/processor/minidump.cc
-old mode 100644
-new mode 100755
---- a/src/processor/minidump.cc
-+++ b/src/processor/minidump.cc
-@@ -38,17 +38,19 @@
- #include <assert.h>
- #include <fcntl.h>
- #include <stdio.h>
- #include <string.h>
- #include <time.h>
- 
- #ifdef _WIN32
- #include <io.h>
-+#if _MSC_VER < 1600
- typedef SSIZE_T ssize_t;
-+#endif
- #define PRIx64 "llx"
- #define PRIx32 "lx"
- #define snprintf _snprintf
- #else  // _WIN32
- #include <unistd.h>
- #define O_BINARY 0
- #endif  // _WIN32
- 
-@@ -81,68 +83,68 @@
- //
- // Inlining these doesn't increase code size significantly, and it saves
- // a whole lot of unnecessary jumping back and forth.
- //
- 
- 
- // Swapping an 8-bit quantity is a no-op.  This function is only provided
- // to account for certain templatized operations that require swapping for
--// wider types but handle u_int8_t too
-+// wider types but handle uint8_t too
- // (MinidumpMemoryRegion::GetMemoryAtAddressInternal).
--static inline void Swap(u_int8_t* value) {
-+static inline void Swap(uint8_t* value) {
- }
- 
- 
- // Optimization: don't need to AND the furthest right shift, because we're
- // shifting an unsigned quantity.  The standard requires zero-filling in this
- // case.  If the quantities were signed, a bitmask whould be needed for this
- // right shift to avoid an arithmetic shift (which retains the sign bit).
- // The furthest left shift never needs to be ANDed bitmask.
- 
- 
--static inline void Swap(u_int16_t* value) {
-+static inline void Swap(uint16_t* value) {
-   *value = (*value >> 8) |
-            (*value << 8);
- }
- 
- 
--static inline void Swap(u_int32_t* value) {
-+static inline void Swap(uint32_t* value) {
-   *value =  (*value >> 24) |
-            ((*value >> 8)  & 0x0000ff00) |
-            ((*value << 8)  & 0x00ff0000) |
-             (*value << 24);
- }
- 
- 
--static inline void Swap(u_int64_t* value) {
--  u_int32_t* value32 = reinterpret_cast<u_int32_t*>(value);
-+static inline void Swap(uint64_t* value) {
-+  uint32_t* value32 = reinterpret_cast<uint32_t*>(value);
-   Swap(&value32[0]);
-   Swap(&value32[1]);
--  u_int32_t temp = value32[0];
-+  uint32_t temp = value32[0];
-   value32[0] = value32[1];
-   value32[1] = temp;
- }
- 
- 
- // Given a pointer to a 128-bit int in the minidump data, set the "low"
- // and "high" fields appropriately.
--static void Normalize128(u_int128_t* value, bool is_big_endian) {
-+static void Normalize128(uint128_t* value, bool is_big_endian) {
-   // The struct format is [high, low], so if the format is big-endian,
-   // the most significant bytes will already be in the high field.
-   if (!is_big_endian) {
--    u_int64_t temp = value->low;
-+    uint64_t temp = value->low;
-     value->low = value->high;
-     value->high = temp;
-   }
- }
- 
- // This just swaps each int64 half of the 128-bit value.
- // The value should also be normalized by calling Normalize128().
--static void Swap(u_int128_t* value) {
-+static void Swap(uint128_t* value) {
-   Swap(&value->low);
-   Swap(&value->high);
- }
- 
- 
- static inline void Swap(MDLocationDescriptor* location_descriptor) {
-   Swap(&location_descriptor->data_size);
-   Swap(&location_descriptor->rva);
-@@ -172,48 +174,48 @@
- // idea of what width a wide character should be: some use 16 bits, and
- // some use 32 bits.  For the purposes of a minidump, wide strings are
- // always represented with 16-bit UTF-16 chracters.  iconv isn't available
- // everywhere, and its interface varies where it is available.  iconv also
- // deals purely with char* pointers, so in addition to considering the swap
- // parameter, a converter that uses iconv would also need to take the host
- // CPU's endianness into consideration.  It doesn't seems worth the trouble
- // of making it a dependency when we don't care about anything but UTF-16.
--static string* UTF16ToUTF8(const vector<u_int16_t>& in,
-+static string* UTF16ToUTF8(const vector<uint16_t>& in,
-                            bool                     swap) {
-   scoped_ptr<string> out(new string());
- 
-   // Set the string's initial capacity to the number of UTF-16 characters,
-   // because the UTF-8 representation will always be at least this long.
-   // If the UTF-8 representation is longer, the string will grow dynamically.
-   out->reserve(in.size());
- 
--  for (vector<u_int16_t>::const_iterator iterator = in.begin();
-+  for (vector<uint16_t>::const_iterator iterator = in.begin();
-        iterator != in.end();
-        ++iterator) {
-     // Get a 16-bit value from the input
--    u_int16_t in_word = *iterator;
-+    uint16_t in_word = *iterator;
-     if (swap)
-       Swap(&in_word);
- 
-     // Convert the input value (in_word) into a Unicode code point (unichar).
--    u_int32_t unichar;
-+    uint32_t unichar;
-     if (in_word >= 0xdc00 && in_word <= 0xdcff) {
-       BPLOG(ERROR) << "UTF16ToUTF8 found low surrogate " <<
-                       HexString(in_word) << " without high";
-       return NULL;
-     } else if (in_word >= 0xd800 && in_word <= 0xdbff) {
-       // High surrogate.
-       unichar = (in_word - 0xd7c0) << 10;
-       if (++iterator == in.end()) {
-         BPLOG(ERROR) << "UTF16ToUTF8 found high surrogate " <<
-                         HexString(in_word) << " at end of string";
-         return NULL;
-       }
--      u_int32_t high_word = in_word;
-+      uint32_t high_word = in_word;
-       in_word = *iterator;
-       if (in_word < 0xdc00 || in_word > 0xdcff) {
-         BPLOG(ERROR) << "UTF16ToUTF8 found high surrogate " <<
-                         HexString(high_word) << " without low " <<
-                         HexString(in_word);
-         return NULL;
-       }
-       unichar |= in_word & 0x03ff;
-@@ -246,17 +248,17 @@
-     }
-   }
- 
-   return out.release();
- }
- 
- // Return the smaller of the number of code units in the UTF-16 string,
- // not including the terminating null word, or maxlen.
--static size_t UTF16codeunits(const u_int16_t *string, size_t maxlen) {
-+static size_t UTF16codeunits(const uint16_t *string, size_t maxlen) {
-   size_t count = 0;
-   while (count < maxlen && string[count] != 0)
-     count++;
-   return count;
- }
- 
- 
- //
-@@ -292,17 +294,17 @@
- }
- 
- 
- MinidumpContext::~MinidumpContext() {
-   FreeContext();
- }
- 
- 
--bool MinidumpContext::Read(u_int32_t expected_size) {
-+bool MinidumpContext::Read(uint32_t expected_size) {
-   valid_ = false;
- 
-   FreeContext();
- 
-   // First, figure out what type of CPU this context structure is for.
-   // For some reason, the AMD64 Context doesn't have context_flags
-   // at the beginning of the structure, so special case it here.
-   if (expected_size == sizeof(MDRawContextAMD64)) {
-@@ -313,17 +315,17 @@
-                               sizeof(MDRawContextAMD64))) {
-       BPLOG(ERROR) << "MinidumpContext could not read amd64 context";
-       return false;
-     }
- 
-     if (minidump_->swap())
-       Swap(&context_amd64->context_flags);
- 
--    u_int32_t cpu_type = context_amd64->context_flags & MD_CONTEXT_CPU_MASK;
-+    uint32_t cpu_type = context_amd64->context_flags & MD_CONTEXT_CPU_MASK;
-     if (cpu_type == 0) {
-       if (minidump_->GetContextCPUFlagsFromSystemInfo(&cpu_type)) {
-         context_amd64->context_flags |= cpu_type;
-       } else {
-         BPLOG(ERROR) << "Failed to preserve the current stream position";
-         return false;
-       }
-     }
-@@ -405,25 +407,25 @@
-       Swap(&context_amd64->last_exception_from_rip);
-     }
- 
-     context_flags_ = context_amd64->context_flags;
- 
-     context_.amd64 = context_amd64.release();
-   }
-   else {
--    u_int32_t context_flags;
-+    uint32_t context_flags;
-     if (!minidump_->ReadBytes(&context_flags, sizeof(context_flags))) {
-       BPLOG(ERROR) << "MinidumpContext could not read context flags";
-       return false;
-     }
-     if (minidump_->swap())
-       Swap(&context_flags);
- 
--    u_int32_t cpu_type = context_flags & MD_CONTEXT_CPU_MASK;
-+    uint32_t cpu_type = context_flags & MD_CONTEXT_CPU_MASK;
-     if (cpu_type == 0) {
-       // Unfortunately the flag for MD_CONTEXT_ARM that was taken
-       // from a Windows CE SDK header conflicts in practice with
-       // the CONTEXT_XSTATE flag. MD_CONTEXT_ARM has been renumbered,
-       // but handle dumps with the legacy value gracefully here.
-       if (context_flags & MD_CONTEXT_ARM_OLD) {
-         context_flags |= MD_CONTEXT_ARM;
-         context_flags &= ~MD_CONTEXT_ARM_OLD;
-@@ -455,18 +457,18 @@
-         scoped_ptr<MDRawContextX86> context_x86(new MDRawContextX86());
- 
-         // Set the context_flags member, which has already been read, and
-         // read the rest of the structure beginning with the first member
-         // after context_flags.
-         context_x86->context_flags = context_flags;
- 
-         size_t flags_size = sizeof(context_x86->context_flags);
--        u_int8_t* context_after_flags =
--          reinterpret_cast<u_int8_t*>(context_x86.get()) + flags_size;
-+        uint8_t* context_after_flags =
-+          reinterpret_cast<uint8_t*>(context_x86.get()) + flags_size;
-         if (!minidump_->ReadBytes(context_after_flags,
-                                   sizeof(MDRawContextX86) - flags_size)) {
-           BPLOG(ERROR) << "MinidumpContext could not read x86 context";
-           return false;
-         }
- 
-         // Do this after reading the entire MDRawContext structure because
-         // GetSystemInfo may seek minidump to a new position.
-@@ -528,18 +530,18 @@
-         scoped_ptr<MDRawContextPPC> context_ppc(new MDRawContextPPC());
- 
-         // Set the context_flags member, which has already been read, and
-         // read the rest of the structure beginning with the first member
-         // after context_flags.
-         context_ppc->context_flags = context_flags;
- 
-         size_t flags_size = sizeof(context_ppc->context_flags);
--        u_int8_t* context_after_flags =
--          reinterpret_cast<u_int8_t*>(context_ppc.get()) + flags_size;
-+        uint8_t* context_after_flags =
-+          reinterpret_cast<uint8_t*>(context_ppc.get()) + flags_size;
-         if (!minidump_->ReadBytes(context_after_flags,
-                                   sizeof(MDRawContextPPC) - flags_size)) {
-           BPLOG(ERROR) << "MinidumpContext could not read ppc context";
-           return false;
-         }
- 
-         // Do this after reading the entire MDRawContext structure because
-         // GetSystemInfo may seek minidump to a new position.
-@@ -604,18 +606,18 @@
-         scoped_ptr<MDRawContextSPARC> context_sparc(new MDRawContextSPARC());
- 
-         // Set the context_flags member, which has already been read, and
-         // read the rest of the structure beginning with the first member
-         // after context_flags.
-         context_sparc->context_flags = context_flags;
- 
-         size_t flags_size = sizeof(context_sparc->context_flags);
--        u_int8_t* context_after_flags =
--            reinterpret_cast<u_int8_t*>(context_sparc.get()) + flags_size;
-+        uint8_t* context_after_flags =
-+            reinterpret_cast<uint8_t*>(context_sparc.get()) + flags_size;
-         if (!minidump_->ReadBytes(context_after_flags,
-                                   sizeof(MDRawContextSPARC) - flags_size)) {
-           BPLOG(ERROR) << "MinidumpContext could not read sparc context";
-           return false;
-         }
- 
-         // Do this after reading the entire MDRawContext structure because
-         // GetSystemInfo may seek minidump to a new position.
-@@ -660,18 +662,18 @@
-         scoped_ptr<MDRawContextARM> context_arm(new MDRawContextARM());
- 
-         // Set the context_flags member, which has already been read, and
-         // read the rest of the structure beginning with the first member
-         // after context_flags.
-         context_arm->context_flags = context_flags;
- 
-         size_t flags_size = sizeof(context_arm->context_flags);
--        u_int8_t* context_after_flags =
--            reinterpret_cast<u_int8_t*>(context_arm.get()) + flags_size;
-+        uint8_t* context_after_flags =
-+            reinterpret_cast<uint8_t*>(context_arm.get()) + flags_size;
-         if (!minidump_->ReadBytes(context_after_flags,
-                                   sizeof(MDRawContextARM) - flags_size)) {
-           BPLOG(ERROR) << "MinidumpContext could not read arm context";
-           return false;
-         }
- 
-         // Do this after reading the entire MDRawContext structure because
-         // GetSystemInfo may seek minidump to a new position.
-@@ -717,27 +719,27 @@
-     context_flags_ = context_flags;
-   }
- 
-   valid_ = true;
-   return true;
- }
- 
- 
--u_int32_t MinidumpContext::GetContextCPU() const {
-+uint32_t MinidumpContext::GetContextCPU() const {
-   if (!valid_) {
-     // Don't log a message, GetContextCPU can be legitimately called with
-     // valid_ false by FreeContext, which is called by Read.
-     return 0;
-   }
- 
-   return context_flags_ & MD_CONTEXT_CPU_MASK;
- }
- 
--bool MinidumpContext::GetInstructionPointer(u_int64_t* ip) const {
-+bool MinidumpContext::GetInstructionPointer(uint64_t* ip) const {
-   BPLOG_IF(ERROR, !ip) << "MinidumpContext::GetInstructionPointer "
-                           "requires |ip|";
-   assert(ip);
-   *ip = 0;
- 
-   if (!valid_) {
-     BPLOG(ERROR) << "Invalid MinidumpContext for GetInstructionPointer";
-     return false;
-@@ -843,17 +845,17 @@
-       break;
-   }
- 
-   context_flags_ = 0;
-   context_.base = NULL;
- }
- 
- 
--bool MinidumpContext::CheckAgainstSystemInfo(u_int32_t context_cpu_type) {
-+bool MinidumpContext::CheckAgainstSystemInfo(uint32_t context_cpu_type) {
-   // It's OK if the minidump doesn't contain an MD_SYSTEM_INFO_STREAM,
-   // as this function just implements a sanity check.
-   MinidumpSystemInfo* system_info = minidump_->GetSystemInfo();
-   if (!system_info) {
-     BPLOG(INFO) << "MinidumpContext could not be compared against "
-                    "MinidumpSystemInfo";
-     return true;
-   }
-@@ -1142,17 +1144,17 @@
- }
- 
- 
- //
- // MinidumpMemoryRegion
- //
- 
- 
--u_int32_t MinidumpMemoryRegion::max_bytes_ = 1024 * 1024;  // 1MB
-+uint32_t MinidumpMemoryRegion::max_bytes_ = 1024 * 1024;  // 1MB
- 
- 
- MinidumpMemoryRegion::MinidumpMemoryRegion(Minidump* minidump)
-     : MinidumpObject(minidump),
-       descriptor_(NULL),
-       memory_(NULL) {
- }
- 
-@@ -1161,22 +1163,22 @@
-   delete memory_;
- }
- 
- 
- void MinidumpMemoryRegion::SetDescriptor(MDMemoryDescriptor* descriptor) {
-   descriptor_ = descriptor;
-   valid_ = descriptor &&
-            descriptor_->memory.data_size <=
--               numeric_limits<u_int64_t>::max() -
-+               numeric_limits<uint64_t>::max() -
-                descriptor_->start_of_memory_range;
- }
- 
- 
--const u_int8_t* MinidumpMemoryRegion::GetMemory() const {
-+const uint8_t* MinidumpMemoryRegion::GetMemory() const {
-   if (!valid_) {
-     BPLOG(ERROR) << "Invalid MinidumpMemoryRegion for GetMemory";
-     return NULL;
-   }
- 
-   if (!memory_) {
-     if (descriptor_->memory.data_size == 0) {
-       BPLOG(ERROR) << "MinidumpMemoryRegion is empty";
-@@ -1190,84 +1192,84 @@
- 
-     if (descriptor_->memory.data_size > max_bytes_) {
-       BPLOG(ERROR) << "MinidumpMemoryRegion size " <<
-                       descriptor_->memory.data_size << " exceeds maximum " <<
-                       max_bytes_;
-       return NULL;
-     }
- 
--    scoped_ptr< vector<u_int8_t> > memory(
--        new vector<u_int8_t>(descriptor_->memory.data_size));
-+    scoped_ptr< vector<uint8_t> > memory(
-+        new vector<uint8_t>(descriptor_->memory.data_size));
- 
-     if (!minidump_->ReadBytes(&(*memory)[0], descriptor_->memory.data_size)) {
-       BPLOG(ERROR) << "MinidumpMemoryRegion could not read memory region";
-       return NULL;
-     }
- 
-     memory_ = memory.release();
-   }
- 
-   return &(*memory_)[0];
- }
- 
- 
--u_int64_t MinidumpMemoryRegion::GetBase() const {
-+uint64_t MinidumpMemoryRegion::GetBase() const {
-   if (!valid_) {
-     BPLOG(ERROR) << "Invalid MinidumpMemoryRegion for GetBase";
--    return static_cast<u_int64_t>(-1);
-+    return static_cast<uint64_t>(-1);
-   }
- 
-   return descriptor_->start_of_memory_range;
- }
- 
- 
--u_int32_t MinidumpMemoryRegion::GetSize() const {
-+uint32_t MinidumpMemoryRegion::GetSize() const {
-   if (!valid_) {
-     BPLOG(ERROR) << "Invalid MinidumpMemoryRegion for GetSize";
-     return 0;
-   }
- 
-   return descriptor_->memory.data_size;
- }
- 
- 
- void MinidumpMemoryRegion::FreeMemory() {
-   delete memory_;
-   memory_ = NULL;
- }
- 
- 
- template<typename T>
--bool MinidumpMemoryRegion::GetMemoryAtAddressInternal(u_int64_t address,
-+bool MinidumpMemoryRegion::GetMemoryAtAddressInternal(uint64_t address,
-                                                       T*        value) const {
-   BPLOG_IF(ERROR, !value) << "MinidumpMemoryRegion::GetMemoryAtAddressInternal "
-                              "requires |value|";
-   assert(value);
-   *value = 0;
- 
-   if (!valid_) {
-     BPLOG(ERROR) << "Invalid MinidumpMemoryRegion for "
-                     "GetMemoryAtAddressInternal";
-     return false;
-   }
- 
-   // Common failure case
-   if (address < descriptor_->start_of_memory_range ||
--      sizeof(T) > numeric_limits<u_int64_t>::max() - address ||
-+      sizeof(T) > numeric_limits<uint64_t>::max() - address ||
-       address + sizeof(T) > descriptor_->start_of_memory_range +
-                             descriptor_->memory.data_size) {
-     BPLOG(INFO) << "MinidumpMemoryRegion request out of range: " <<
-                     HexString(address) << "+" << sizeof(T) << "/" <<
-                     HexString(descriptor_->start_of_memory_range) << "+" <<
-                     HexString(descriptor_->memory.data_size);
-     return false;
-   }
- 
--  const u_int8_t* memory = GetMemory();
-+  const uint8_t* memory = GetMemory();
-   if (!memory) {
-     // GetMemory already logged a perfectly good message.
-     return false;
-   }
- 
-   // If the CPU requires memory accesses to be aligned, this can crash.
-   // x86 and ppc are able to cope, though.
-   *value = *reinterpret_cast<const T*>(
-@@ -1275,47 +1277,47 @@
- 
-   if (minidump_->swap())
-     Swap(value);
- 
-   return true;
- }
- 
- 
--bool MinidumpMemoryRegion::GetMemoryAtAddress(u_int64_t  address,
--                                              u_int8_t*  value) const {
-+bool MinidumpMemoryRegion::GetMemoryAtAddress(uint64_t  address,
-+                                              uint8_t*  value) const {
-   return GetMemoryAtAddressInternal(address, value);
- }
- 
- 
--bool MinidumpMemoryRegion::GetMemoryAtAddress(u_int64_t  address,
--                                              u_int16_t* value) const {
-+bool MinidumpMemoryRegion::GetMemoryAtAddress(uint64_t  address,
-+                                              uint16_t* value) const {
-   return GetMemoryAtAddressInternal(address, value);
- }
- 
- 
--bool MinidumpMemoryRegion::GetMemoryAtAddress(u_int64_t  address,
--                                              u_int32_t* value) const {
-+bool MinidumpMemoryRegion::GetMemoryAtAddress(uint64_t  address,
-+                                              uint32_t* value) const {
-   return GetMemoryAtAddressInternal(address, value);
- }
- 
- 
--bool MinidumpMemoryRegion::GetMemoryAtAddress(u_int64_t  address,
--                                              u_int64_t* value) const {
-+bool MinidumpMemoryRegion::GetMemoryAtAddress(uint64_t  address,
-+                                              uint64_t* value) const {
-   return GetMemoryAtAddressInternal(address, value);
- }
- 
- 
- void MinidumpMemoryRegion::Print() {
-   if (!valid_) {
-     BPLOG(ERROR) << "MinidumpMemoryRegion cannot print invalid data";
-     return;
-   }
- 
--  const u_int8_t* memory = GetMemory();
-+  const uint8_t* memory = GetMemory();
-   if (memory) {
-     printf("0x");
-     for (unsigned int byte_index = 0;
-          byte_index < descriptor_->memory.data_size;
-          byte_index++) {
-       printf("%02x", memory[byte_index]);
-     }
-     printf("\n");
-@@ -1365,17 +1367,17 @@
-     Swap(&thread_.priority);
-     Swap(&thread_.teb);
-     Swap(&thread_.stack);
-     Swap(&thread_.thread_context);
-   }
- 
-   // Check for base + size overflow or undersize.
-   if (thread_.stack.memory.data_size == 0 ||
--      thread_.stack.memory.data_size > numeric_limits<u_int64_t>::max() -
-+      thread_.stack.memory.data_size > numeric_limits<uint64_t>::max() -
-                                        thread_.stack.start_of_memory_range) {
-     // This is ok, but log an error anyway.