bug 779291 - Add some more local Breakpad patches, update a few patches. r=various
authorTed Mielczarek <ted@mielczarek.org>
Tue, 05 Mar 2013 09:32:34 -0500
changeset 123946 5fe39d67806e0836414953802247bb1aee4a49a5
parent 123945 ae8113482b550efb2984f3cfd5beabbe84163a5c
child 123947 e6835779f327d95d7e7dc2ae2417885007b9c763
push idunknown
push userunknown
push dateunknown
reviewersvarious
bugs779291
milestone22.0a1
bug 779291 - Add some more local Breakpad patches, update a few patches. r=various also contains fixup for stdint changes in Breakpad. r=glandium
configure.in
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/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/src/client/linux/crash_generation/crash_generation_server.cc
toolkit/crashreporter/google-breakpad/src/client/linux/handler/exception_handler.cc
toolkit/crashreporter/google-breakpad/src/client/linux/handler/exception_handler.h
toolkit/crashreporter/google-breakpad/src/client/linux/handler/exception_handler_unittest.cc
toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/minidump_writer.cc
toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/minidump_writer.h
toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/minidump_writer_unittest.cc
toolkit/crashreporter/google-breakpad/src/client/mac/handler/minidump_generator.cc
toolkit/crashreporter/google-breakpad/src/client/mac/handler/minidump_generator.h
toolkit/crashreporter/google-breakpad/src/client/mac/tests/crash_generation_server_test.cc
toolkit/crashreporter/google-breakpad/src/client/mac/tests/exception_handler_test.cc
toolkit/crashreporter/google-breakpad/src/client/mac/tests/minidump_generator_test.cc
toolkit/crashreporter/google-breakpad/src/client/mac/tests/spawn_child_process.h
toolkit/crashreporter/google-breakpad/src/client/minidump_file_writer.cc
toolkit/crashreporter/google-breakpad/src/client/minidump_file_writer.h
toolkit/crashreporter/google-breakpad/src/client/solaris/handler/minidump_generator.cc
toolkit/crashreporter/google-breakpad/src/client/windows/crash_generation/minidump_generator.h
toolkit/crashreporter/google-breakpad/src/client/windows/unittests/exception_handler_death_test.cc
toolkit/crashreporter/google-breakpad/src/client/windows/unittests/exception_handler_test.cc
toolkit/crashreporter/google-breakpad/src/common/dwarf/cfi_assembler.cc
toolkit/crashreporter/google-breakpad/src/common/dwarf/cfi_assembler.h
toolkit/crashreporter/google-breakpad/src/common/dwarf/dwarf2reader.cc
toolkit/crashreporter/google-breakpad/src/common/dwarf/dwarf2reader_cfi_unittest.cc
toolkit/crashreporter/google-breakpad/src/common/dwarf/dwarf2reader_die_unittest.cc
toolkit/crashreporter/google-breakpad/src/common/dwarf/dwarf2reader_test_common.h
toolkit/crashreporter/google-breakpad/src/common/linux/dump_symbols.cc
toolkit/crashreporter/google-breakpad/src/common/linux/dump_symbols.cc.orig
toolkit/crashreporter/google-breakpad/src/common/linux/guid_creator.cc
toolkit/crashreporter/google-breakpad/src/common/linux/memory_mapped_file.cc
toolkit/crashreporter/google-breakpad/src/common/mac/MachIPC.h
toolkit/crashreporter/google-breakpad/src/common/memory_range.h
toolkit/crashreporter/google-breakpad/src/common/memory_range_unittest.cc
toolkit/crashreporter/google-breakpad/src/common/module.h
toolkit/crashreporter/google-breakpad/src/common/solaris/dump_symbols.cc
toolkit/crashreporter/google-breakpad/src/common/solaris/guid_creator.cc
toolkit/crashreporter/google-breakpad/src/common/stabs_reader_unittest.cc
toolkit/crashreporter/google-breakpad/src/common/string_conversion.cc
toolkit/crashreporter/google-breakpad/src/common/string_conversion.h
toolkit/crashreporter/google-breakpad/src/common/test_assembler.cc
toolkit/crashreporter/google-breakpad/src/common/test_assembler.h
toolkit/crashreporter/google-breakpad/src/common/test_assembler_unittest.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_cpu_x86.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/common/minidump_format.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/code_module.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/code_modules.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/exploitability.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/memory_region.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/minidump.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/minidump_processor.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/process_state.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/source_line_resolver_interface.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/stack_frame.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/stack_frame_cpu.h
toolkit/crashreporter/google-breakpad/src/google_breakpad/processor/stackwalker.h
toolkit/crashreporter/google-breakpad/src/processor/basic_code_module.h
toolkit/crashreporter/google-breakpad/src/processor/basic_code_modules.cc
toolkit/crashreporter/google-breakpad/src/processor/basic_code_modules.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/basic_source_line_resolver_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/binarystream.cc
toolkit/crashreporter/google-breakpad/src/processor/binarystream.h
toolkit/crashreporter/google-breakpad/src/processor/binarystream_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/cfi_frame_info.cc
toolkit/crashreporter/google-breakpad/src/processor/cfi_frame_info.h
toolkit/crashreporter/google-breakpad/src/processor/cfi_frame_info_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/disassembler_x86.cc
toolkit/crashreporter/google-breakpad/src/processor/disassembler_x86.h
toolkit/crashreporter/google-breakpad/src/processor/exploitability.cc
toolkit/crashreporter/google-breakpad/src/processor/exploitability_win.cc
toolkit/crashreporter/google-breakpad/src/processor/fast_source_line_resolver.cc
toolkit/crashreporter/google-breakpad/src/processor/fast_source_line_resolver_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/logging.cc
toolkit/crashreporter/google-breakpad/src/processor/logging.h
toolkit/crashreporter/google-breakpad/src/processor/map_serializers-inl.h
toolkit/crashreporter/google-breakpad/src/processor/map_serializers_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/minidump.cc
toolkit/crashreporter/google-breakpad/src/processor/minidump_dump.cc
toolkit/crashreporter/google-breakpad/src/processor/minidump_processor.cc
toolkit/crashreporter/google-breakpad/src/processor/minidump_processor_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/minidump_stackwalk.cc
toolkit/crashreporter/google-breakpad/src/processor/minidump_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/module_serializer.cc
toolkit/crashreporter/google-breakpad/src/processor/module_serializer.h
toolkit/crashreporter/google-breakpad/src/processor/postfix_evaluator_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/simple_serializer-inl.h
toolkit/crashreporter/google-breakpad/src/processor/simple_serializer.h
toolkit/crashreporter/google-breakpad/src/processor/source_line_resolver_base_types.h
toolkit/crashreporter/google-breakpad/src/processor/stackwalker.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_amd64.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_amd64.h
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_amd64_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_arm.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_arm_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_ppc.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_selftest.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_sparc.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_unittest_utils.h
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_x86.cc
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_x86.h
toolkit/crashreporter/google-breakpad/src/processor/stackwalker_x86_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/static_contained_range_map-inl.h
toolkit/crashreporter/google-breakpad/src/processor/static_contained_range_map.h
toolkit/crashreporter/google-breakpad/src/processor/static_map-inl.h
toolkit/crashreporter/google-breakpad/src/processor/static_map.h
toolkit/crashreporter/google-breakpad/src/processor/static_map_iterator-inl.h
toolkit/crashreporter/google-breakpad/src/processor/static_map_iterator.h
toolkit/crashreporter/google-breakpad/src/processor/static_map_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/synth_minidump.cc
toolkit/crashreporter/google-breakpad/src/processor/synth_minidump.h
toolkit/crashreporter/google-breakpad/src/processor/synth_minidump_unittest.cc
toolkit/crashreporter/google-breakpad/src/processor/synth_minidump_unittest_data.h
toolkit/crashreporter/google-breakpad/src/processor/tokenize.cc
toolkit/crashreporter/google-breakpad/src/processor/windows_frame_info.h
toolkit/crashreporter/google-breakpad/src/tools/linux/md2core/minidump-2-core.cc
toolkit/crashreporter/google-breakpad/src/tools/linux/md2core/minidump_memory_range.h
toolkit/crashreporter/google-breakpad/src/tools/linux/md2core/minidump_memory_range_unittest.cc
toolkit/crashreporter/google-breakpad/src/tools/mac/dump_syms/dump_syms.xcodeproj/project.pbxproj.orig
toolkit/crashreporter/test/dumputils.cpp
--- a/configure.in
+++ b/configure.in
@@ -5976,19 +5976,22 @@ if test -n "$MOZ_CRASHREPORTER"; then
     AC_SUBST(MOZ_GTHREAD_CFLAGS)
     AC_SUBST(MOZ_GTHREAD_LIBS)
   fi
 
   if test "$OS_ARCH" != "$HOST_OS_ARCH"; then
     AC_MSG_ERROR([Breakpad tools do not support compiling on $HOST_OS_ARCH while targeting $OS_ARCH.  Use --disable-crashreporter.])
   fi
 
-  if test "$OS_ARCH" = "WINNT" -a -z "$HAVE_64BIT_OS"; then
-    MOZ_CRASHREPORTER_INJECTOR=1
-    AC_DEFINE(MOZ_CRASHREPORTER_INJECTOR)
+  if test "$OS_ARCH" = "WINNT"; then
+    AC_DEFINE_UNQUOTED(BREAKPAD_CUSTOM_STDINT_H, "mozilla/StandardInteger.h")
+    if test -z "$HAVE_64BIT_OS"; then
+      MOZ_CRASHREPORTER_INJECTOR=1
+      AC_DEFINE(MOZ_CRASHREPORTER_INJECTOR)
+    fi
   fi
 fi
 
 MOZ_ARG_WITH_STRING(crashreporter-enable-percent,
 [  --with-crashreporter-enable-percent=NN
                           Enable sending crash reports by default on NN% of users. (default=100)],
 [ val=`echo $withval | sed 's/[^0-9]//g'`
     MOZ_CRASHREPORTER_ENABLE_PERCENT="$val"])
new file mode 100644
--- /dev/null
+++ b/toolkit/crashreporter/breakpad-patches/00-stdint.patch
@@ -0,0 +1,12909 @@
+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.
+   seria