Use stdint.h numeric types

Change-Id: Ib815b0757539145c005d828080b92cbfa971a21b
Reviewed-on: https://chromium-review.googlesource.com/c/breakpad/breakpad/+/2141226
Reviewed-by: Ivan Penkov <ivanpe@chromium.org>

15 files changed, 477 insertions, 482 deletions

diff --git a/src/common/dwarf/bytereader-inl.h b/src/common/dwarf/bytereader-inl.h
index 42c92f94..f4c068a2 100644
--- a/src/common/dwarf/bytereader-inl.h
+++ b/src/common/dwarf/bytereader-inl.h
@@ -36,13 +36,13 @@
 
 namespace dwarf2reader {
 
-inline uint8 ByteReader::ReadOneByte(const uint8_t *buffer) const {
+inline uint8_t ByteReader::ReadOneByte(const uint8_t *buffer) const {
   return buffer[0];
 }
 
-inline uint16 ByteReader::ReadTwoBytes(const uint8_t *buffer) const {
-  const uint16 buffer0 = buffer[0];
-  const uint16 buffer1 = buffer[1];
+inline uint16_t ByteReader::ReadTwoBytes(const uint8_t *buffer) const {
+  const uint16_t buffer0 = buffer[0];
+  const uint16_t buffer1 = buffer[1];
   if (endian_ == ENDIANNESS_LITTLE) {
     return buffer0 | buffer1 << 8;
   } else {
@@ -50,11 +50,11 @@ inline uint16 ByteReader::ReadTwoBytes(const uint8_t *buffer) const {
   }
 }
 
-inline uint64 ByteReader::ReadFourBytes(const uint8_t *buffer) const {
-  const uint32 buffer0 = buffer[0];
-  const uint32 buffer1 = buffer[1];
-  const uint32 buffer2 = buffer[2];
-  const uint32 buffer3 = buffer[3];
+inline uint64_t ByteReader::ReadFourBytes(const uint8_t *buffer) const {
+  const uint32_t buffer0 = buffer[0];
+  const uint32_t buffer1 = buffer[1];
+  const uint32_t buffer2 = buffer[2];
+  const uint32_t buffer3 = buffer[3];
   if (endian_ == ENDIANNESS_LITTLE) {
     return buffer0 | buffer1 << 8 | buffer2 << 16 | buffer3 << 24;
   } else {
@@ -62,15 +62,15 @@ inline uint64 ByteReader::ReadFourBytes(const uint8_t *buffer) const {
   }
 }
 
-inline uint64 ByteReader::ReadEightBytes(const uint8_t *buffer) const {
-  const uint64 buffer0 = buffer[0];
-  const uint64 buffer1 = buffer[1];
-  const uint64 buffer2 = buffer[2];
-  const uint64 buffer3 = buffer[3];
-  const uint64 buffer4 = buffer[4];
-  const uint64 buffer5 = buffer[5];
-  const uint64 buffer6 = buffer[6];
-  const uint64 buffer7 = buffer[7];
+inline uint64_t ByteReader::ReadEightBytes(const uint8_t *buffer) const {
+  const uint64_t buffer0 = buffer[0];
+  const uint64_t buffer1 = buffer[1];
+  const uint64_t buffer2 = buffer[2];
+  const uint64_t buffer3 = buffer[3];
+  const uint64_t buffer4 = buffer[4];
+  const uint64_t buffer5 = buffer[5];
+  const uint64_t buffer6 = buffer[6];
+  const uint64_t buffer7 = buffer[7];
   if (endian_ == ENDIANNESS_LITTLE) {
     return buffer0 | buffer1 << 8 | buffer2 << 16 | buffer3 << 24 |
       buffer4 << 32 | buffer5 << 40 | buffer6 << 48 | buffer7 << 56;
@@ -84,9 +84,9 @@ inline uint64 ByteReader::ReadEightBytes(const uint8_t *buffer) const {
 // information, plus one bit saying whether the number continues or
 // not.
 
-inline uint64 ByteReader::ReadUnsignedLEB128(const uint8_t *buffer,
+inline uint64_t ByteReader::ReadUnsignedLEB128(const uint8_t *buffer,
                                              size_t* len) const {
-  uint64 result = 0;
+  uint64_t result = 0;
   size_t num_read = 0;
   unsigned int shift = 0;
   uint8_t byte;
@@ -95,7 +95,7 @@ inline uint64 ByteReader::ReadUnsignedLEB128(const uint8_t *buffer,
     byte = *buffer++;
     num_read++;
 
-    result |= (static_cast<uint64>(byte & 0x7f)) << shift;
+    result |= (static_cast<uint64_t>(byte & 0x7f)) << shift;
 
     shift += 7;
 
@@ -109,9 +109,9 @@ inline uint64 ByteReader::ReadUnsignedLEB128(const uint8_t *buffer,
 // Read a signed LEB128 number.  These are like regular LEB128
 // numbers, except the last byte may have a sign bit set.
 
-inline int64 ByteReader::ReadSignedLEB128(const uint8_t *buffer,
+inline int64_t ByteReader::ReadSignedLEB128(const uint8_t *buffer,
                                           size_t* len) const {
-  int64 result = 0;
+  int64_t result = 0;
   unsigned int shift = 0;
   size_t num_read = 0;
   uint8_t byte;
@@ -119,44 +119,44 @@ inline int64 ByteReader::ReadSignedLEB128(const uint8_t *buffer,
   do {
       byte = *buffer++;
       num_read++;
-      result |= (static_cast<uint64>(byte & 0x7f) << shift);
+      result |= (static_cast<uint64_t>(byte & 0x7f) << shift);
       shift += 7;
   } while (byte & 0x80);
 
   if ((shift < 8 * sizeof (result)) && (byte & 0x40))
-    result |= -((static_cast<int64>(1)) << shift);
+    result |= -((static_cast<int64_t>(1)) << shift);
   *len = num_read;
   return result;
 }
 
-inline uint64 ByteReader::ReadOffset(const uint8_t *buffer) const {
+inline uint64_t ByteReader::ReadOffset(const uint8_t *buffer) const {
   assert(this->offset_reader_);
   return (this->*offset_reader_)(buffer);
 }
 
-inline uint64 ByteReader::ReadAddress(const uint8_t *buffer) const {
+inline uint64_t ByteReader::ReadAddress(const uint8_t *buffer) const {
   assert(this->address_reader_);
   return (this->*address_reader_)(buffer);
 }
 
-inline void ByteReader::SetCFIDataBase(uint64 section_base,
+inline void ByteReader::SetCFIDataBase(uint64_t section_base,
                                        const uint8_t *buffer_base) {
   section_base_ = section_base;
   buffer_base_ = buffer_base;
   have_section_base_ = true;
 }
 
-inline void ByteReader::SetTextBase(uint64 text_base) {
+inline void ByteReader::SetTextBase(uint64_t text_base) {
   text_base_ = text_base;
   have_text_base_ = true;
 }
 
-inline void ByteReader::SetDataBase(uint64 data_base) {
+inline void ByteReader::SetDataBase(uint64_t data_base) {
   data_base_ = data_base;
   have_data_base_ = true;
 }
 
-inline void ByteReader::SetFunctionBase(uint64 function_base) {
+inline void ByteReader::SetFunctionBase(uint64_t function_base) {
   function_base_ = function_base;
   have_function_base_ = true;
 }
diff --git a/src/common/dwarf/bytereader.cc b/src/common/dwarf/bytereader.cc
index 14b43adb..0b27dd58 100644
--- a/src/common/dwarf/bytereader.cc
+++ b/src/common/dwarf/bytereader.cc
@@ -43,7 +43,7 @@ ByteReader::ByteReader(enum Endianness endian)
 
 ByteReader::~ByteReader() { }
 
-void ByteReader::SetOffsetSize(uint8 size) {
+void ByteReader::SetOffsetSize(uint8_t size) {
   offset_size_ = size;
   assert(size == 4 || size == 8);
   if (size == 4) {
@@ -53,7 +53,7 @@ void ByteReader::SetOffsetSize(uint8 size) {
   }
 }
 
-void ByteReader::SetAddressSize(uint8 size) {
+void ByteReader::SetAddressSize(uint8_t size) {
   address_size_ = size;
   assert(size == 4 || size == 8);
   if (size == 4) {
@@ -63,8 +63,8 @@ void ByteReader::SetAddressSize(uint8 size) {
   }
 }
 
-uint64 ByteReader::ReadInitialLength(const uint8_t *start, size_t* len) {
-  const uint64 initial_length = ReadFourBytes(start);
+uint64_t ByteReader::ReadInitialLength(const uint8_t *start, size_t* len) {
+  const uint64_t initial_length = ReadFourBytes(start);
   start += 4;
 
   // In DWARF2/3, if the initial length is all 1 bits, then the offset
@@ -101,7 +101,7 @@ bool ByteReader::UsableEncoding(DwarfPointerEncoding encoding) const {
   }
 }
 
-uint64 ByteReader::ReadEncodedPointer(const uint8_t *buffer,
+uint64_t ByteReader::ReadEncodedPointer(const uint8_t *buffer,
                                       DwarfPointerEncoding encoding,
                                       size_t *len) const {
   // UsableEncoding doesn't approve of DW_EH_PE_omit, so we shouldn't
@@ -124,11 +124,11 @@ uint64 ByteReader::ReadEncodedPointer(const uint8_t *buffer,
 
     // First, find the offset to START from the closest prior aligned
     // address.
-    uint64 skew = section_base_ & (AddressSize() - 1);
+    uint64_t skew = section_base_ & (AddressSize() - 1);
     // Now find the offset from that aligned address to buffer.
-    uint64 offset = skew + (buffer - buffer_base_);
+    uint64_t offset = skew + (buffer - buffer_base_);
     // Round up to the next boundary.
-    uint64 aligned = (offset + AddressSize() - 1) & -AddressSize();
+    uint64_t aligned = (offset + AddressSize() - 1) & -AddressSize();
     // Convert back to a pointer.
     const uint8_t *aligned_buffer = buffer_base_ + (aligned - skew);
     // Finally, store the length and actually fetch the pointer.
@@ -138,7 +138,7 @@ uint64 ByteReader::ReadEncodedPointer(const uint8_t *buffer,
 
   // Extract the value first, ignoring whether it's a pointer or an
   // offset relative to some base.
-  uint64 offset;
+  uint64_t offset;
   switch (encoding & 0x0f) {
     case DW_EH_PE_absptr:
       // DW_EH_PE_absptr is weird, as it is used as a meaningful value for
@@ -202,7 +202,7 @@ uint64 ByteReader::ReadEncodedPointer(const uint8_t *buffer,
   }
 
   // Find the appropriate base address.
-  uint64 base;
+  uint64_t base;
   switch (encoding & 0x70) {
     case DW_EH_PE_absptr:
       base = 0;
@@ -232,13 +232,13 @@ uint64 ByteReader::ReadEncodedPointer(const uint8_t *buffer,
       abort();
   }
 
-  uint64 pointer = base + offset;
+  uint64_t pointer = base + offset;
 
   // Remove inappropriate upper bits.
   if (AddressSize() == 4)
     pointer = pointer & 0xffffffff;
   else
-    assert(AddressSize() == sizeof(uint64));
+    assert(AddressSize() == sizeof(uint64_t));
 
   return pointer;
 }
diff --git a/src/common/dwarf/bytereader.h b/src/common/dwarf/bytereader.h
index 59d43034..2b37a12d 100644
--- a/src/common/dwarf/bytereader.h
+++ b/src/common/dwarf/bytereader.h
@@ -62,22 +62,22 @@ class ByteReader {
 
   // Read a single byte from BUFFER and return it as an unsigned 8 bit
   // number.
-  uint8 ReadOneByte(const uint8_t *buffer) const;
+  uint8_t ReadOneByte(const uint8_t *buffer) const;
 
   // Read two bytes from BUFFER and return them as an unsigned 16 bit
   // number, using this ByteReader's endianness.
-  uint16 ReadTwoBytes(const uint8_t *buffer) const;
+  uint16_t ReadTwoBytes(const uint8_t *buffer) const;
 
   // Read four bytes from BUFFER and return them as an unsigned 32 bit
   // number, using this ByteReader's endianness. This function returns
-  // a uint64 so that it is compatible with ReadAddress and
+  // a uint64_t so that it is compatible with ReadAddress and
   // ReadOffset. The number it returns will never be outside the range
   // of an unsigned 32 bit integer.
-  uint64 ReadFourBytes(const uint8_t *buffer) const;
+  uint64_t ReadFourBytes(const uint8_t *buffer) const;
 
   // Read eight bytes from BUFFER and return them as an unsigned 64
   // bit number, using this ByteReader's endianness.
-  uint64 ReadEightBytes(const uint8_t *buffer) const;
+  uint64_t ReadEightBytes(const uint8_t *buffer) const;
 
   // Read an unsigned LEB128 (Little Endian Base 128) number from
   // BUFFER and return it as an unsigned 64 bit integer. Set LEN to
@@ -96,7 +96,7 @@ class ByteReader {
   // In other words, we break VALUE into groups of seven bits, put
   // them in little-endian order, and then write them as eight-bit
   // bytes with the high bit on all but the last.
-  uint64 ReadUnsignedLEB128(const uint8_t *buffer, size_t *len) const;
+  uint64_t ReadUnsignedLEB128(const uint8_t *buffer, size_t *len) const;
 
   // Read a signed LEB128 number from BUFFER and return it as an
   // signed 64 bit integer. Set LEN to the number of bytes read.
@@ -115,7 +115,7 @@ class ByteReader {
   // In other words, we break VALUE into groups of seven bits, put
   // them in little-endian order, and then write them as eight-bit
   // bytes with the high bit on all but the last.
-  int64 ReadSignedLEB128(const uint8_t *buffer, size_t *len) const;
+  int64_t ReadSignedLEB128(const uint8_t *buffer, size_t *len) const;
 
   // Indicate that addresses on this architecture are SIZE bytes long. SIZE
   // must be either 4 or 8. (DWARF allows addresses to be any number of
@@ -129,16 +129,16 @@ class ByteReader {
   // frame information doesn't indicate its address size (a shortcoming of
   // the spec); you must supply the appropriate size based on the
   // architecture of the target machine.
-  void SetAddressSize(uint8 size);
+  void SetAddressSize(uint8_t size);
 
   // Return the current address size, in bytes. This is either 4,
   // indicating 32-bit addresses, or 8, indicating 64-bit addresses.
-  uint8 AddressSize() const { return address_size_; }
+  uint8_t AddressSize() const { return address_size_; }
 
   // Read an address from BUFFER and return it as an unsigned 64 bit
   // integer, respecting this ByteReader's endianness and address size. You
   // must call SetAddressSize before calling this function.
-  uint64 ReadAddress(const uint8_t *buffer) const;
+  uint64_t ReadAddress(const uint8_t *buffer) const;
 
   // DWARF actually defines two slightly different formats: 32-bit DWARF
   // and 64-bit DWARF. This is *not* related to the size of registers or
@@ -175,26 +175,26 @@ class ByteReader {
   // - The 32-bit value 0xffffffff, followed by a 64-bit byte count,
   //   indicating that the data whose length is being measured uses
   //   the 64-bit DWARF format.
-  uint64 ReadInitialLength(const uint8_t *start, size_t *len);
+  uint64_t ReadInitialLength(const uint8_t *start, size_t *len);
 
   // Read an offset from BUFFER and return it as an unsigned 64 bit
   // integer, respecting the ByteReader's endianness. In 32-bit DWARF, the
   // offset is 4 bytes long; in 64-bit DWARF, the offset is eight bytes
   // long. You must call ReadInitialLength or SetOffsetSize before calling
   // this function; see the comments above for details.
-  uint64 ReadOffset(const uint8_t *buffer) const;
+  uint64_t ReadOffset(const uint8_t *buffer) const;
 
   // Return the current offset size, in bytes.
   // A return value of 4 indicates that we are reading 32-bit DWARF.
   // A return value of 8 indicates that we are reading 64-bit DWARF.
-  uint8 OffsetSize() const { return offset_size_; }
+  uint8_t OffsetSize() const { return offset_size_; }
 
   // Indicate that section offsets and lengths are SIZE bytes long. SIZE
   // must be either 4 (meaning 32-bit DWARF) or 8 (meaning 64-bit DWARF).
   // Usually, you should not call this function yourself; instead, let a
   // call to ReadInitialLength establish the data's offset size
   // automatically.
-  void SetOffsetSize(uint8 size);
+  void SetOffsetSize(uint8_t size);
 
   // The Linux C++ ABI uses a variant of DWARF call frame information
   // for exception handling. This data is included in the program's
@@ -237,24 +237,24 @@ class ByteReader {
   // is BUFFER_BASE. This allows us to find the address that a given
   // byte in our buffer would have when loaded into the program the
   // data describes. We need this to resolve DW_EH_PE_pcrel pointers.
-  void SetCFIDataBase(uint64 section_base, const uint8_t *buffer_base);
+  void SetCFIDataBase(uint64_t section_base, const uint8_t *buffer_base);
 
   // Indicate that the base address of the program's ".text" section
   // is TEXT_BASE. We need this to resolve DW_EH_PE_textrel pointers.
-  void SetTextBase(uint64 text_base);
+  void SetTextBase(uint64_t text_base);
 
   // Indicate that the base address for DW_EH_PE_datarel pointers is
   // DATA_BASE. The proper value depends on the ABI; it is usually the
   // address of the global offset table, held in a designated register in
   // position-independent code. You will need to look at the startup code
   // for the target system to be sure. I tried; my eyes bled.
-  void SetDataBase(uint64 data_base);
+  void SetDataBase(uint64_t data_base);
 
   // Indicate that the base address for the FDE we are processing is
   // FUNCTION_BASE. This is the start address of DW_EH_PE_funcrel
   // pointers. (This encoding does not seem to be used by the GNU
   // toolchain.)
-  void SetFunctionBase(uint64 function_base);
+  void SetFunctionBase(uint64_t function_base);
 
   // Indicate that we are no longer processing any FDE, so any use of
   // a DW_EH_PE_funcrel encoding is an error.
@@ -276,7 +276,7 @@ class ByteReader {
   // base address this reader hasn't been given, so you should check
   // with ValidEncoding and UsableEncoding first if you would rather
   // die in a more helpful way.
-  uint64 ReadEncodedPointer(const uint8_t *buffer,
+  uint64_t ReadEncodedPointer(const uint8_t *buffer,
                             DwarfPointerEncoding encoding,
                             size_t *len) const;
 
@@ -284,7 +284,7 @@ class ByteReader {
  private:
 
   // Function pointer type for our address and offset readers.
-  typedef uint64 (ByteReader::*AddressReader)(const uint8_t *) const;
+  typedef uint64_t (ByteReader::*AddressReader)(const uint8_t *) const;
 
   // Read an offset from BUFFER and return it as an unsigned 64 bit
   // integer.  DWARF2/3 define offsets as either 4 or 8 bytes,
@@ -300,13 +300,13 @@ class ByteReader {
   AddressReader address_reader_;
 
   Endianness endian_;
-  uint8 address_size_;
-  uint8 offset_size_;
+  uint8_t address_size_;
+  uint8_t offset_size_;
 
   // Base addresses for Linux C++ exception handling data's encoded pointers.
   bool have_section_base_, have_text_base_, have_data_base_;
   bool have_function_base_;
-  uint64 section_base_, text_base_, data_base_, function_base_;
+  uint64_t section_base_, text_base_, data_base_, function_base_;
   const uint8_t *buffer_base_;
 };
 
diff --git a/src/common/dwarf/dwarf2diehandler.cc b/src/common/dwarf/dwarf2diehandler.cc
index 94542b5e..63845018 100644
--- a/src/common/dwarf/dwarf2diehandler.cc
+++ b/src/common/dwarf/dwarf2diehandler.cc
@@ -50,15 +50,15 @@ DIEDispatcher::~DIEDispatcher() {
   }
 }
 
-bool DIEDispatcher::StartCompilationUnit(uint64 offset, uint8 address_size,
-                                         uint8 offset_size, uint64 cu_length,
-                                         uint8 dwarf_version) {
+bool DIEDispatcher::StartCompilationUnit(uint64_t offset, uint8_t address_size,
+                                         uint8_t offset_size, uint64_t cu_length,
+                                         uint8_t dwarf_version) {
   return root_handler_->StartCompilationUnit(offset, address_size,
                                              offset_size, cu_length,
                                              dwarf_version);
 }
 
-bool DIEDispatcher::StartDIE(uint64 offset, enum DwarfTag tag) {
+bool DIEDispatcher::StartDIE(uint64_t offset, enum DwarfTag tag) {
   // The stack entry for the parent of this DIE, if there is one.
   HandlerStack *parent = die_handlers_.empty() ? NULL : &die_handlers_.top();
 
@@ -113,7 +113,7 @@ bool DIEDispatcher::StartDIE(uint64 offset, enum DwarfTag tag) {
   return handler != NULL;
 }
 
-void DIEDispatcher::EndDIE(uint64 offset) {
+void DIEDispatcher::EndDIE(uint64_t offset) {
   assert(!die_handlers_.empty());
   HandlerStack *entry = &die_handlers_.top();
   if (entry->handler_) {
@@ -135,48 +135,48 @@ void DIEDispatcher::EndDIE(uint64 offset) {
   die_handlers_.pop();
 }
 
-void DIEDispatcher::ProcessAttributeUnsigned(uint64 offset,
+void DIEDispatcher::ProcessAttributeUnsigned(uint64_t offset,
                                              enum DwarfAttribute attr,
                                              enum DwarfForm form,
-                                             uint64 data) {
+                                             uint64_t data) {
   HandlerStack &current = die_handlers_.top();
   // This had better be an attribute of the DIE we were meant to handle.
   assert(offset == current.offset_);
   current.handler_->ProcessAttributeUnsigned(attr, form, data);
 }
 
-void DIEDispatcher::ProcessAttributeSigned(uint64 offset,
+void DIEDispatcher::ProcessAttributeSigned(uint64_t offset,
                                            enum DwarfAttribute attr,
                                            enum DwarfForm form,
-                                           int64 data) {
+                                           int64_t data) {
   HandlerStack &current = die_handlers_.top();
   // This had better be an attribute of the DIE we were meant to handle.
   assert(offset == current.offset_);
   current.handler_->ProcessAttributeSigned(attr, form, data);
 }
 
-void DIEDispatcher::ProcessAttributeReference(uint64 offset,
+void DIEDispatcher::ProcessAttributeReference(uint64_t offset,
                                               enum DwarfAttribute attr,
                                               enum DwarfForm form,
-                                              uint64 data) {
+                                              uint64_t data) {
   HandlerStack &current = die_handlers_.top();
   // This had better be an attribute of the DIE we were meant to handle.
   assert(offset == current.offset_);
   current.handler_->ProcessAttributeReference(attr, form, data);
 }
 
-void DIEDispatcher::ProcessAttributeBuffer(uint64 offset,
+void DIEDispatcher::ProcessAttributeBuffer(uint64_t offset,
                                            enum DwarfAttribute attr,
                                            enum DwarfForm form,
                                            const uint8_t *data,
-                                           uint64 len) {
+                                           uint64_t len) {
   HandlerStack &current = die_handlers_.top();
   // This had better be an attribute of the DIE we were meant to handle.
   assert(offset == current.offset_);
   current.handler_->ProcessAttributeBuffer(attr, form, data, len);
 }
 
-void DIEDispatcher::ProcessAttributeString(uint64 offset,
+void DIEDispatcher::ProcessAttributeString(uint64_t offset,
                                            enum DwarfAttribute attr,
                                            enum DwarfForm form,
                                            const string& data) {
@@ -186,10 +186,10 @@ void DIEDispatcher::ProcessAttributeString(uint64 offset,
   current.handler_->ProcessAttributeString(attr, form, data);
 }
 
-void DIEDispatcher::ProcessAttributeSignature(uint64 offset,
+void DIEDispatcher::ProcessAttributeSignature(uint64_t offset,
                                               enum DwarfAttribute attr,
                                               enum DwarfForm form,
-                                              uint64 signature) {
+                                              uint64_t signature) {
   HandlerStack &current = die_handlers_.top();
   // This had better be an attribute of the DIE we were meant to handle.
   assert(offset == current.offset_);
diff --git a/src/common/dwarf/dwarf2diehandler.h b/src/common/dwarf/dwarf2diehandler.h
index a1e589a8..871ba436 100644
--- a/src/common/dwarf/dwarf2diehandler.h
+++ b/src/common/dwarf/dwarf2diehandler.h
@@ -199,23 +199,23 @@ class DIEHandler {
   // The default definitions ignore the values they are passed.
   virtual void ProcessAttributeUnsigned(enum DwarfAttribute attr,
                                         enum DwarfForm form,
-                                        uint64 data) { }
+                                        uint64_t data) { }
   virtual void ProcessAttributeSigned(enum DwarfAttribute attr,
                                       enum DwarfForm form,
-                                      int64 data) { }
+                                      int64_t data) { }
   virtual void ProcessAttributeReference(enum DwarfAttribute attr,
                                          enum DwarfForm form,
-                                         uint64 data) { }
+                                         uint64_t data) { }
   virtual void ProcessAttributeBuffer(enum DwarfAttribute attr,
                                       enum DwarfForm form,
                                       const uint8_t *data,
-                                      uint64 len) { }
+                                      uint64_t len) { }
   virtual void ProcessAttributeString(enum DwarfAttribute attr,
                                       enum DwarfForm form,
                                       const string& data) { }
   virtual void ProcessAttributeSignature(enum DwarfAttribute attr,
                                          enum DwarfForm form,
-                                         uint64 signture) { }
+                                         uint64_t signture) { }
 
   // Once we have reported all the DIE's attributes' values, we call
   // this member function.  If it returns false, we skip all the DIE's
@@ -244,7 +244,7 @@ class DIEHandler {
   // it is.
   //
   // The default definition skips all children.
-  virtual DIEHandler *FindChildHandler(uint64 offset, enum DwarfTag tag) {
+  virtual DIEHandler *FindChildHandler(uint64_t offset, enum DwarfTag tag) {
     return NULL;
   }
 
@@ -268,9 +268,9 @@ class RootDIEHandler: public DIEHandler {
   // returns false.  So the root DIE handler is actually also
   // responsible for handling the compilation unit metadata.
   // The default definition always visits the compilation unit.
-  virtual bool StartCompilationUnit(uint64 offset, uint8 address_size,
-                                    uint8 offset_size, uint64 cu_length,
-                                    uint8 dwarf_version) { return true; }
+  virtual bool StartCompilationUnit(uint64_t offset, uint8_t address_size,
+                                    uint8_t offset_size, uint64_t cu_length,
+                                    uint8_t dwarf_version) { return true; }
 
   // For the root DIE handler only, we pass the offset, tag and
   // attributes of the compilation unit's root DIE.  This is the only
@@ -280,7 +280,7 @@ class RootDIEHandler: public DIEHandler {
   // unit.
   //
   // The default definition elects to visit the root DIE.
-  virtual bool StartRootDIE(uint64 offset, enum DwarfTag tag) { return true; }
+  virtual bool StartRootDIE(uint64_t offset, enum DwarfTag tag) { return true; }
 };
 
 class DIEDispatcher: public Dwarf2Handler {
@@ -292,36 +292,36 @@ class DIEDispatcher: public Dwarf2Handler {
   // Destroying a DIEDispatcher destroys all active handler objects
   // except the root handler.
   ~DIEDispatcher();
-  bool StartCompilationUnit(uint64 offset, uint8 address_size,
-                            uint8 offset_size, uint64 cu_length,
-                            uint8 dwarf_version);
-  bool StartDIE(uint64 offset, enum DwarfTag tag);
-  void ProcessAttributeUnsigned(uint64 offset,
+  bool StartCompilationUnit(uint64_t offset, uint8_t address_size,
+                            uint8_t offset_size, uint64_t cu_length,
+                            uint8_t dwarf_version);
+  bool StartDIE(uint64_t offset, enum DwarfTag tag);
+  void ProcessAttributeUnsigned(uint64_t offset,
                                 enum DwarfAttribute attr,
                                 enum DwarfForm form,
-                                uint64 data);
-  void ProcessAttributeSigned(uint64 offset,
+                                uint64_t data);
+  void ProcessAttributeSigned(uint64_t offset,
                               enum DwarfAttribute attr,
                               enum DwarfForm form,
-                              int64 data);
-  void ProcessAttributeReference(uint64 offset,
+                              int64_t data);
+  void ProcessAttributeReference(uint64_t offset,
                                  enum DwarfAttribute attr,
                                  enum DwarfForm form,
-                                 uint64 data);
-  void ProcessAttributeBuffer(uint64 offset,
+                                 uint64_t data);
+  void ProcessAttributeBuffer(uint64_t offset,
                               enum DwarfAttribute attr,
                               enum DwarfForm form,
                               const uint8_t *data,
-                              uint64 len);
-  void ProcessAttributeString(uint64 offset,
+                              uint64_t len);
+  void ProcessAttributeString(uint64_t offset,
                               enum DwarfAttribute attr,
                               enum DwarfForm form,
                               const string &data);
-  void ProcessAttributeSignature(uint64 offset,
+  void ProcessAttributeSignature(uint64_t offset,
                                  enum DwarfAttribute attr,
                                  enum DwarfForm form,
-                                 uint64 signature);
-  void EndDIE(uint64 offset);
+                                 uint64_t signature);
+  void EndDIE(uint64_t offset);
 
  private:
 
@@ -331,7 +331,7 @@ class DIEDispatcher: public Dwarf2Handler {
   // makes it easier to see that the code is correct.
   struct HandlerStack {
     // The offset of the DIE for this handler stack entry.
-    uint64 offset_;
+    uint64_t offset_;
 
     // The handler object interested in this DIE's attributes and
     // children.  If NULL, we're not interested in either.
diff --git a/src/common/dwarf/dwarf2reader.cc b/src/common/dwarf/dwarf2reader.cc
index 3e6a3e89..e615fc4b 100644
--- a/src/common/dwarf/dwarf2reader.cc
+++ b/src/common/dwarf/dwarf2reader.cc
@@ -54,7 +54,7 @@
 namespace dwarf2reader {
 
 CompilationUnit::CompilationUnit(const string& path,
-                                 const SectionMap& sections, uint64 offset,
+                                 const SectionMap& sections, uint64_t offset,
                                  ByteReader* reader, Dwarf2Handler* handler)
     : path_(path), offset_from_section_start_(offset), reader_(reader),
       sections_(sections), handler_(handler), abbrevs_(),
@@ -74,10 +74,10 @@ CompilationUnit::CompilationUnit(const string& path,
 // processing the original compilation unit.
 
 void CompilationUnit::SetSplitDwarf(const uint8_t* addr_buffer,
-                                    uint64 addr_buffer_length,
-                                    uint64 addr_base,
-                                    uint64 ranges_base,
-                                    uint64 dwo_id) {
+                                    uint64_t addr_buffer_length,
+                                    uint64_t addr_base,
+                                    uint64_t ranges_base,
+                                    uint64_t dwo_id) {
   is_split_dwarf_ = true;
   addr_buffer_ = addr_buffer;
   addr_buffer_length_ = addr_buffer_length;
@@ -116,13 +116,13 @@ void CompilationUnit::ReadAbbrevs() {
                                       header_.abbrev_offset;
   const uint8_t *abbrevptr = abbrev_start;
 #ifndef NDEBUG
-  const uint64 abbrev_length = iter->second.second - header_.abbrev_offset;
+  const uint64_t abbrev_length = iter->second.second - header_.abbrev_offset;
 #endif
 
   while (1) {
     CompilationUnit::Abbrev abbrev;
     size_t len;
-    const uint64 number = reader_->ReadUnsignedLEB128(abbrevptr, &len);
+    const uint64_t number = reader_->ReadUnsignedLEB128(abbrevptr, &len);
 
     if (number == 0)
       break;
@@ -130,7 +130,7 @@ void CompilationUnit::ReadAbbrevs() {
     abbrevptr += len;
 
     assert(abbrevptr < abbrev_start + abbrev_length);
-    const uint64 tag = reader_->ReadUnsignedLEB128(abbrevptr, &len);
+    const uint64_t tag = reader_->ReadUnsignedLEB128(abbrevptr, &len);
     abbrevptr += len;
     abbrev.tag = static_cast<enum DwarfTag>(tag);
 
@@ -141,11 +141,11 @@ void CompilationUnit::ReadAbbrevs() {
     assert(abbrevptr < abbrev_start + abbrev_length);
 
     while (1) {
-      const uint64 nametemp = reader_->ReadUnsignedLEB128(abbrevptr, &len);
+      const uint64_t nametemp = reader_->ReadUnsignedLEB128(abbrevptr, &len);
       abbrevptr += len;
 
       assert(abbrevptr < abbrev_start + abbrev_length);
-      const uint64 formtemp = reader_->ReadUnsignedLEB128(abbrevptr, &len);
+      const uint64_t formtemp = reader_->ReadUnsignedLEB128(abbrevptr, &len);
       abbrevptr += len;
       if (nametemp == 0 && formtemp == 0)
         break;
@@ -232,7 +232,7 @@ const uint8_t *CompilationUnit::SkipAttribute(const uint8_t *start,
       return start + 4 + reader_->ReadFourBytes(start);
     case DW_FORM_block:
     case DW_FORM_exprloc: {
-      uint64 size = reader_->ReadUnsignedLEB128(start, &len);
+      uint64_t size = reader_->ReadUnsignedLEB128(start, &len);
       return start + size + len;
     }
     case DW_FORM_strp:
@@ -253,7 +253,7 @@ void CompilationUnit::ReadHeader() {
   size_t initial_length_size;
 
   assert(headerptr + 4 < buffer_ + buffer_length_);
-  const uint64 initial_length
+  const uint64_t initial_length
     = reader_->ReadInitialLength(headerptr, &initial_length_size);
   headerptr += initial_length_size;
   header_.length = initial_length;
@@ -282,7 +282,7 @@ void CompilationUnit::ReadHeader() {
         buffer_ + buffer_length_);
 }
 
-uint64 CompilationUnit::Start() {
+uint64_t CompilationUnit::Start() {
   // First get the debug_info section.  ".debug_info" is the name
   // recommended in the DWARF spec, and used on Linux; "__debug_info"
   // is the name used in Mac OS X Mach-O files.
@@ -301,7 +301,7 @@ uint64 CompilationUnit::Start() {
   // Figure out the real length from the end of the initial length to
   // the end of the compilation unit, since that is the value we
   // return.
-  uint64 ourlength = header_.length;
+  uint64_t ourlength = header_.length;
   if (reader_->OffsetSize() == 8)
     ourlength += 12;
   else
@@ -361,7 +361,7 @@ uint64 CompilationUnit::Start() {
 // ProcessAttribute
 // This is all boring data manipulation and calling of the handler.
 const uint8_t *CompilationUnit::ProcessAttribute(
-    uint64 dieoffset, const uint8_t *start, enum DwarfAttribute attr,
+    uint64_t dieoffset, const uint8_t *start, enum DwarfAttribute attr,
     enum DwarfForm form) {
   size_t len;
 
@@ -463,26 +463,26 @@ const uint8_t *CompilationUnit::ProcessAttribute(
       return start + 8;
 
     case DW_FORM_block1: {
-      uint64 datalen = reader_->ReadOneByte(start);
+      uint64_t datalen = reader_->ReadOneByte(start);
       handler_->ProcessAttributeBuffer(dieoffset, attr, form, start + 1,
                                        datalen);
       return start + 1 + datalen;
     }
     case DW_FORM_block2: {
-      uint64 datalen = reader_->ReadTwoBytes(start);
+      uint64_t datalen = reader_->ReadTwoBytes(start);
       handler_->ProcessAttributeBuffer(dieoffset, attr, form, start + 2,
                                        datalen);
       return start + 2 + datalen;
     }
     case DW_FORM_block4: {
-      uint64 datalen = reader_->ReadFourBytes(start);
+      uint64_t datalen = reader_->ReadFourBytes(start);
       handler_->ProcessAttributeBuffer(dieoffset, attr, form, start + 4,
                                        datalen);
       return start + 4 + datalen;
     }
     case DW_FORM_block:
     case DW_FORM_exprloc: {
-      uint64 datalen = reader_->ReadUnsignedLEB128(start, &len);
+      uint64_t datalen = reader_->ReadUnsignedLEB128(start, &len);
       handler_->ProcessAttributeBuffer(dieoffset, attr, form, start + len,
                                        datalen);
       return start + datalen + len;
@@ -490,7 +490,7 @@ const uint8_t *CompilationUnit::ProcessAttribute(
     case DW_FORM_strp: {
       assert(string_buffer_ != NULL);
 
-      const uint64 offset = reader_->ReadOffset(start);
+      const uint64_t offset = reader_->ReadOffset(start);
       assert(string_buffer_ + offset < string_buffer_ + string_buffer_length_);
 
       const char *str = reinterpret_cast<const char *>(string_buffer_ + offset);
@@ -499,10 +499,10 @@ const uint8_t *CompilationUnit::ProcessAttribute(
     }
 
     case DW_FORM_GNU_str_index: {
-      uint64 str_index = reader_->ReadUnsignedLEB128(start, &len);
+      uint64_t str_index = reader_->ReadUnsignedLEB128(start, &len);
       const uint8_t* offset_ptr =
           str_offsets_buffer_ + str_index * reader_->OffsetSize();
-      const uint64 offset = reader_->ReadOffset(offset_ptr);
+      const uint64_t offset = reader_->ReadOffset(offset_ptr);
       if (offset >= string_buffer_length_) {
         return NULL;
       }
@@ -513,7 +513,7 @@ const uint8_t *CompilationUnit::ProcessAttribute(
       break;
     }
     case DW_FORM_GNU_addr_index: {
-      uint64 addr_index = reader_->ReadUnsignedLEB128(start, &len);
+      uint64_t addr_index = reader_->ReadUnsignedLEB128(start, &len);
       const uint8_t* addr_ptr =
           addr_buffer_ + addr_base_ + addr_index * reader_->AddressSize();
       ProcessAttributeUnsigned(dieoffset, attr, form,
@@ -525,7 +525,7 @@ const uint8_t *CompilationUnit::ProcessAttribute(
   return NULL;
 }
 
-const uint8_t *CompilationUnit::ProcessDIE(uint64 dieoffset,
+const uint8_t *CompilationUnit::ProcessDIE(uint64_t dieoffset,
                                            const uint8_t *start,
                                            const Abbrev& abbrev) {
   for (AttributeList::const_iterator i = abbrev.attributes.begin();
@@ -561,14 +561,14 @@ void CompilationUnit::ProcessDIEs() {
   else
     lengthstart += 4;
 
-  std::stack<uint64> die_stack;
+  std::stack<uint64_t> die_stack;
   
   while (dieptr < (lengthstart + header_.length)) {
     // We give the user the absolute offset from the beginning of
     // debug_info, since they need it to deal with ref_addr forms.
-    uint64 absolute_offset = (dieptr - buffer_) + offset_from_section_start_;
+    uint64_t absolute_offset = (dieptr - buffer_) + offset_from_section_start_;
 
-    uint64 abbrev_num = reader_->ReadUnsignedLEB128(dieptr, &len);
+    uint64_t abbrev_num = reader_->ReadUnsignedLEB128(dieptr, &len);
 
     dieptr += len;
 
@@ -578,7 +578,7 @@ void CompilationUnit::ProcessDIEs() {
       if (die_stack.size() == 0)
         // If it is padding, then we are done with the compilation unit's DIEs.
         return;
-      const uint64 offset = die_stack.top();
+      const uint64_t offset = die_stack.top();
       die_stack.pop();
       handler_->EndDIE(offset);
       continue;
@@ -724,24 +724,24 @@ void DwpReader::Initialize() {
   if (version_ == 1) {
     nslots_ = byte_reader_.ReadFourBytes(
         reinterpret_cast<const uint8_t *>(cu_index_)
-        + 3 * sizeof(uint32));
-    phash_ = cu_index_ + 4 * sizeof(uint32);
-    pindex_ = phash_ + nslots_ * sizeof(uint64);
-    shndx_pool_ = pindex_ + nslots_ * sizeof(uint32);
+        + 3 * sizeof(uint32_t));
+    phash_ = cu_index_ + 4 * sizeof(uint32_t);
+    pindex_ = phash_ + nslots_ * sizeof(uint64_t);
+    shndx_pool_ = pindex_ + nslots_ * sizeof(uint32_t);
     if (shndx_pool_ >= cu_index_ + cu_index_size_) {
       version_ = 0;
     }
   } else if (version_ == 2) {
     ncolumns_ = byte_reader_.ReadFourBytes(
-        reinterpret_cast<const uint8_t *>(cu_index_) + sizeof(uint32));
+        reinterpret_cast<const uint8_t *>(cu_index_) + sizeof(uint32_t));
     nunits_ = byte_reader_.ReadFourBytes(
-        reinterpret_cast<const uint8_t *>(cu_index_) + 2 * sizeof(uint32));
+        reinterpret_cast<const uint8_t *>(cu_index_) + 2 * sizeof(uint32_t));
     nslots_ = byte_reader_.ReadFourBytes(
-        reinterpret_cast<const uint8_t *>(cu_index_) + 3 * sizeof(uint32));
-    phash_ = cu_index_ + 4 * sizeof(uint32);
-    pindex_ = phash_ + nslots_ * sizeof(uint64);
-    offset_table_ = pindex_ + nslots_ * sizeof(uint32);
-    size_table_ = offset_table_ + ncolumns_ * (nunits_ + 1) * sizeof(uint32);
+        reinterpret_cast<const uint8_t *>(cu_index_) + 3 * sizeof(uint32_t));
+    phash_ = cu_index_ + 4 * sizeof(uint32_t);
+    pindex_ = phash_ + nslots_ * sizeof(uint64_t);
+    offset_table_ = pindex_ + nslots_ * sizeof(uint32_t);
+    size_table_ = offset_table_ + ncolumns_ * (nunits_ + 1) * sizeof(uint32_t);
     abbrev_data_ = elf_reader_->GetSectionByName(".debug_abbrev.dwo",
                                                  &abbrev_size_);
     info_data_ = elf_reader_->GetSectionByName(".debug_info.dwo", &info_size_);
@@ -753,7 +753,7 @@ void DwpReader::Initialize() {
   }
 }
 
-void DwpReader::ReadDebugSectionsForCU(uint64 dwo_id,
+void DwpReader::ReadDebugSectionsForCU(uint64_t dwo_id,
                                        SectionMap* sections) {
   if (version_ == 1) {
     int slot = LookupCU(dwo_id);
@@ -766,8 +766,8 @@ void DwpReader::ReadDebugSectionsForCU(uint64 dwo_id,
     // for the CU whose dwo_id we are looking for.
     int index = byte_reader_.ReadFourBytes(
         reinterpret_cast<const uint8_t *>(pindex_)
-        + slot * sizeof(uint32));
-    const char* shndx_list = shndx_pool_ + index * sizeof(uint32);
+        + slot * sizeof(uint32_t));
+    const char* shndx_list = shndx_pool_ + index * sizeof(uint32_t);
     for (;;) {
       if (shndx_list >= cu_index_ + cu_index_size_) {
         version_ = 0;
@@ -775,7 +775,7 @@ void DwpReader::ReadDebugSectionsForCU(uint64 dwo_id,
       }
       unsigned int shndx = byte_reader_.ReadFourBytes(
           reinterpret_cast<const uint8_t *>(shndx_list));
-      shndx_list += sizeof(uint32);
+      shndx_list += sizeof(uint32_t);
       if (shndx == 0)
         break;
       const char* section_name = elf_reader_->GetSectionName(shndx);
@@ -810,7 +810,7 @@ void DwpReader::ReadDebugSectionsForCU(uint64 dwo_id,
         std::make_pair(reinterpret_cast<const uint8_t *> (string_buffer_),
                        string_buffer_size_)));
   } else if (version_ == 2) {
-    uint32 index = LookupCUv2(dwo_id);
+    uint32_t index = LookupCUv2(dwo_id);
     if (index == 0) {
       return;
     }
@@ -823,22 +823,22 @@ void DwpReader::ReadDebugSectionsForCU(uint64 dwo_id,
     // with row 1.
     const char* id_row = offset_table_;
     const char* offset_row = offset_table_
-                             + index * ncolumns_ * sizeof(uint32);
+                             + index * ncolumns_ * sizeof(uint32_t);
     const char* size_row =
-        size_table_ + (index - 1) * ncolumns_ * sizeof(uint32);
-    if (size_row + ncolumns_ * sizeof(uint32) > cu_index_ + cu_index_size_) {
+        size_table_ + (index - 1) * ncolumns_ * sizeof(uint32_t);
+    if (size_row + ncolumns_ * sizeof(uint32_t) > cu_index_ + cu_index_size_) {
       version_ = 0;
       return;
     }
     for (unsigned int col = 0u; col < ncolumns_; ++col) {
-      uint32 section_id =
+      uint32_t section_id =
           byte_reader_.ReadFourBytes(reinterpret_cast<const uint8_t *>(id_row)
-                                     + col * sizeof(uint32));
-      uint32 offset = byte_reader_.ReadFourBytes(
+                                     + col * sizeof(uint32_t));
+      uint32_t offset = byte_reader_.ReadFourBytes(
           reinterpret_cast<const uint8_t *>(offset_row)
-          + col * sizeof(uint32));
-      uint32 size = byte_reader_.ReadFourBytes(
-          reinterpret_cast<const uint8_t *>(size_row) + col * sizeof(uint32));
+          + col * sizeof(uint32_t));
+      uint32_t size = byte_reader_.ReadFourBytes(
+          reinterpret_cast<const uint8_t *>(size_row) + col * sizeof(uint32_t));
       if (section_id == DW_SECT_ABBREV) {
         sections->insert(std::make_pair(
             ".debug_abbrev",
@@ -863,17 +863,17 @@ void DwpReader::ReadDebugSectionsForCU(uint64 dwo_id,
   }
 }
 
-int DwpReader::LookupCU(uint64 dwo_id) {
-  uint32 slot = static_cast<uint32>(dwo_id) & (nslots_ - 1);
-  uint64 probe = byte_reader_.ReadEightBytes(
-      reinterpret_cast<const uint8_t *>(phash_) + slot * sizeof(uint64));
+int DwpReader::LookupCU(uint64_t dwo_id) {
+  uint32_t slot = static_cast<uint32_t>(dwo_id) & (nslots_ - 1);
+  uint64_t probe = byte_reader_.ReadEightBytes(
+      reinterpret_cast<const uint8_t *>(phash_) + slot * sizeof(uint64_t));
   if (probe != 0 && probe != dwo_id) {
-    uint32 secondary_hash =
-        (static_cast<uint32>(dwo_id >> 32) & (nslots_ - 1)) | 1;
+    uint32_t secondary_hash =
+        (static_cast<uint32_t>(dwo_id >> 32) & (nslots_ - 1)) | 1;
     do {
       slot = (slot + secondary_hash) & (nslots_ - 1);
       probe = byte_reader_.ReadEightBytes(
-          reinterpret_cast<const uint8_t *>(phash_) + slot * sizeof(uint64));
+          reinterpret_cast<const uint8_t *>(phash_) + slot * sizeof(uint64_t));
     } while (probe != 0 && probe != dwo_id);
   }
   if (probe == 0)
@@ -881,27 +881,27 @@ int DwpReader::LookupCU(uint64 dwo_id) {
   return slot;
 }
 
-uint32 DwpReader::LookupCUv2(uint64 dwo_id) {
-  uint32 slot = static_cast<uint32>(dwo_id) & (nslots_ - 1);
-  uint64 probe = byte_reader_.ReadEightBytes(
-      reinterpret_cast<const uint8_t *>(phash_) + slot * sizeof(uint64));
-  uint32 index = byte_reader_.ReadFourBytes(
-      reinterpret_cast<const uint8_t *>(pindex_) + slot * sizeof(uint32));
+uint32_t DwpReader::LookupCUv2(uint64_t dwo_id) {
+  uint32_t slot = static_cast<uint32_t>(dwo_id) & (nslots_ - 1);
+  uint64_t probe = byte_reader_.ReadEightBytes(
+      reinterpret_cast<const uint8_t *>(phash_) + slot * sizeof(uint64_t));
+  uint32_t index = byte_reader_.ReadFourBytes(
+      reinterpret_cast<const uint8_t *>(pindex_) + slot * sizeof(uint32_t));
   if (index != 0 && probe != dwo_id) {
-    uint32 secondary_hash =
-        (static_cast<uint32>(dwo_id >> 32) & (nslots_ - 1)) | 1;
+    uint32_t secondary_hash =
+        (static_cast<uint32_t>(dwo_id >> 32) & (nslots_ - 1)) | 1;
     do {
       slot = (slot + secondary_hash) & (nslots_ - 1);
       probe = byte_reader_.ReadEightBytes(
-          reinterpret_cast<const uint8_t *>(phash_) + slot * sizeof(uint64));
+          reinterpret_cast<const uint8_t *>(phash_) + slot * sizeof(uint64_t));
       index = byte_reader_.ReadFourBytes(
-          reinterpret_cast<const uint8_t *>(pindex_) + slot * sizeof(uint32));
+          reinterpret_cast<const uint8_t *>(pindex_) + slot * sizeof(uint32_t));
     } while (index != 0 && probe != dwo_id);
   }
   return index;
 }
 
-LineInfo::LineInfo(const uint8_t *buffer, uint64 buffer_length,
+LineInfo::LineInfo(const uint8_t *buffer, uint64_t buffer_length,
                    ByteReader* reader, LineInfoHandler* handler):
     handler_(handler), reader_(reader), buffer_(buffer) {
 #ifndef NDEBUG
@@ -910,7 +910,7 @@ LineInfo::LineInfo(const uint8_t *buffer, uint64 buffer_length,
   header_.std_opcode_lengths = NULL;
 }
 
-uint64 LineInfo::Start() {
+uint64_t LineInfo::Start() {
   ReadHeader();
   ReadLines();
   return after_header_ - buffer_;
@@ -922,7 +922,7 @@ void LineInfo::ReadHeader() {
   const uint8_t *lineptr = buffer_;
   size_t initial_length_size;
 
-  const uint64 initial_length
+  const uint64_t initial_length
     = reader_->ReadInitialLength(lineptr, &initial_length_size);
 
   lineptr += initial_length_size;
@@ -943,7 +943,7 @@ void LineInfo::ReadHeader() {
   lineptr += 1;
 
   if (header_.version >= 4) {
-    __attribute__((unused)) uint8 max_ops_per_insn =
+    __attribute__((unused)) uint8_t max_ops_per_insn =
         reader_->ReadOneByte(lineptr);
     ++lineptr;
     assert(max_ops_per_insn == 1);
@@ -952,7 +952,7 @@ void LineInfo::ReadHeader() {
   header_.default_is_stmt = reader_->ReadOneByte(lineptr);
   lineptr += 1;
 
-  header_.line_base = *reinterpret_cast<const int8*>(lineptr);
+  header_.line_base = *reinterpret_cast<const int8_t*>(lineptr);
   lineptr += 1;
 
   header_.line_range = reader_->ReadOneByte(lineptr);
@@ -971,7 +971,7 @@ void LineInfo::ReadHeader() {
 
   // It is legal for the directory entry table to be empty.
   if (*lineptr) {
-    uint32 dirindex = 1;
+    uint32_t dirindex = 1;
     while (*lineptr) {
       const char *dirname = reinterpret_cast<const char *>(lineptr);
       handler_->DefineDir(dirname, dirindex);
@@ -983,21 +983,21 @@ void LineInfo::ReadHeader() {
 
   // It is also legal for the file entry table to be empty.
   if (*lineptr) {
-    uint32 fileindex = 1;
+    uint32_t fileindex = 1;
     size_t len;
     while (*lineptr) {
       const char *filename = reinterpret_cast<const char *>(lineptr);
       lineptr += strlen(filename) + 1;
 
-      uint64 dirindex = reader_->ReadUnsignedLEB128(lineptr, &len);
+      uint64_t dirindex = reader_->ReadUnsignedLEB128(lineptr, &len);
       lineptr += len;
 
-      uint64 mod_time = reader_->ReadUnsignedLEB128(lineptr, &len);
+      uint64_t mod_time = reader_->ReadUnsignedLEB128(lineptr, &len);
       lineptr += len;
 
-      uint64 filelength = reader_->ReadUnsignedLEB128(lineptr, &len);
+      uint64_t filelength = reader_->ReadUnsignedLEB128(lineptr, &len);
       lineptr += len;
-      handler_->DefineFile(filename, fileindex, static_cast<uint32>(dirindex), 
+      handler_->DefineFile(filename, fileindex, static_cast<uint32_t>(dirindex), 
                            mod_time, filelength);
       fileindex++;
     }
@@ -1018,7 +1018,7 @@ bool LineInfo::ProcessOneOpcode(ByteReader* reader,
                                 bool *lsm_passes_pc) {
   size_t oplen = 0;
   size_t templen;
-  uint8 opcode = reader->ReadOneByte(start);
+  uint8_t opcode = reader->ReadOneByte(start);
   oplen++;
   start++;
 
@@ -1026,9 +1026,9 @@ bool LineInfo::ProcessOneOpcode(ByteReader* reader,
   // opcode. Most line programs consist mainly of special opcodes.
   if (opcode >= header.opcode_base) {
     opcode -= header.opcode_base;
-    const int64 advance_address = (opcode / header.line_range)
+    const int64_t advance_address = (opcode / header.line_range)
                                   * header.min_insn_length;
-    const int32 advance_line = (opcode % header.line_range)
+    const int32_t advance_line = (opcode % header.line_range)
                                + header.line_base;
 
     // Check if the lsm passes "pc". If so, mark it as passed.
@@ -1053,7 +1053,7 @@ bool LineInfo::ProcessOneOpcode(ByteReader* reader,
     }
 
     case DW_LNS_advance_pc: {
-      uint64 advance_address = reader->ReadUnsignedLEB128(start, &templen);
+      uint64_t advance_address = reader->ReadUnsignedLEB128(start, &templen);
       oplen += templen;
 
       // Check if the lsm passes "pc". If so, mark it as passed.
@@ -1066,9 +1066,9 @@ bool LineInfo::ProcessOneOpcode(ByteReader* reader,
     }
       break;
     case DW_LNS_advance_line: {
-      const int64 advance_line = reader->ReadSignedLEB128(start, &templen);
+      const int64_t advance_line = reader->ReadSignedLEB128(start, &templen);
       oplen += templen;
-      lsm->line_num += static_cast<int32>(advance_line);
+      lsm->line_num += static_cast<int32_t>(advance_line);
 
       // With gcc 4.2.1, we can get the line_no here for the first time
       // since DW_LNS_advance_line is called after DW_LNE_set_address is
@@ -1080,15 +1080,15 @@ bool LineInfo::ProcessOneOpcode(ByteReader* reader,
     }
       break;
     case DW_LNS_set_file: {
-      const uint64 fileno = reader->ReadUnsignedLEB128(start, &templen);
+      const uint64_t fileno = reader->ReadUnsignedLEB128(start, &templen);
       oplen += templen;
-      lsm->file_num = static_cast<uint32>(fileno);
+      lsm->file_num = static_cast<uint32_t>(fileno);
     }
       break;
     case DW_LNS_set_column: {
-      const uint64 colno = reader->ReadUnsignedLEB128(start, &templen);
+      const uint64_t colno = reader->ReadUnsignedLEB128(start, &templen);
       oplen += templen;
-      lsm->column_num = static_cast<uint32>(colno);
+      lsm->column_num = static_cast<uint32_t>(colno);
     }
       break;
     case DW_LNS_negate_stmt: {
@@ -1100,7 +1100,7 @@ bool LineInfo::ProcessOneOpcode(ByteReader* reader,
     }
       break;
     case DW_LNS_fixed_advance_pc: {
-      const uint16 advance_address = reader->ReadTwoBytes(start);
+      const uint16_t advance_address = reader->ReadTwoBytes(start);
       oplen += 2;
 
       // Check if the lsm passes "pc". If so, mark it as passed.
@@ -1113,7 +1113,7 @@ bool LineInfo::ProcessOneOpcode(ByteReader* reader,
     }
       break;
     case DW_LNS_const_add_pc: {
-      const int64 advance_address = header.min_insn_length
+      const int64_t advance_address = header.min_insn_length
                                     * ((255 - header.opcode_base)
                                        / header.line_range);
 
@@ -1127,12 +1127,12 @@ bool LineInfo::ProcessOneOpcode(ByteReader* reader,
     }
       break;
     case DW_LNS_extended_op: {
-      const uint64 extended_op_len = reader->ReadUnsignedLEB128(start,
+      const uint64_t extended_op_len = reader->ReadUnsignedLEB128(start,
                                                                 &templen);
       start += templen;
       oplen += templen + extended_op_len;
 
-      const uint64 extended_op = reader->ReadOneByte(start);
+      const uint64_t extended_op = reader->ReadOneByte(start);
       start++;
 
       switch (extended_op) {
@@ -1147,7 +1147,7 @@ bool LineInfo::ProcessOneOpcode(ByteReader* reader,
           // DW_LNE_set_address is called before DW_LNS_advance_line is
           // called.  So we do not check if the lsm passes "pc" here.  See
           // also the comment in DW_LNS_advance_line.
-          uint64 address = reader->ReadAddress(start);
+          uint64_t address = reader->ReadAddress(start);
           lsm->address = address;
         }
           break;
@@ -1157,19 +1157,19 @@ bool LineInfo::ProcessOneOpcode(ByteReader* reader,
           templen = strlen(filename) + 1;
           start += templen;
 
-          uint64 dirindex = reader->ReadUnsignedLEB128(start, &templen);
+          uint64_t dirindex = reader->ReadUnsignedLEB128(start, &templen);
           oplen += templen;
 
-          const uint64 mod_time = reader->ReadUnsignedLEB128(start,
+          const uint64_t mod_time = reader->ReadUnsignedLEB128(start,
                                                              &templen);
           oplen += templen;
 
-          const uint64 filelength = reader->ReadUnsignedLEB128(start,
+          const uint64_t filelength = reader->ReadUnsignedLEB128(start,
                                                                &templen);
           oplen += templen;
 
           if (handler) {
-            handler->DefineFile(filename, -1, static_cast<uint32>(dirindex), 
+            handler->DefineFile(filename, -1, static_cast<uint32_t>(dirindex), 
                                 mod_time, filelength);
           }
         }
@@ -1217,8 +1217,8 @@ void LineInfo::ReadLines() {
   // from the next address. So we report a line only when we get the
   // next line's address, or the end-of-sequence address.
   bool have_pending_line = false;
-  uint64 pending_address = 0;
-  uint32 pending_file_num = 0, pending_line_num = 0, pending_column_num = 0;
+  uint64_t pending_address = 0;
+  uint32_t pending_file_num = 0, pending_line_num = 0, pending_column_num = 0;
 
   while (lineptr < lengthstart + header_.total_length) {
     size_t oplength;
@@ -1247,15 +1247,15 @@ void LineInfo::ReadLines() {
   after_header_ = lengthstart + header_.total_length;
 }
 
-RangeListReader::RangeListReader(const uint8_t *buffer, uint64 size,
+RangeListReader::RangeListReader(const uint8_t *buffer, uint64_t size,
                                  ByteReader *reader, RangeListHandler *handler)
     : buffer_(buffer), size_(size), reader_(reader), handler_(handler) { }
 
-bool RangeListReader::ReadRangeList(uint64 offset) {
-  const uint64 max_address =
+bool RangeListReader::ReadRangeList(uint64_t offset) {
+  const uint64_t max_address =
     (reader_->AddressSize() == 4) ? 0xffffffffUL
                                   : 0xffffffffffffffffULL;
-  const uint64 entry_size = reader_->AddressSize() * 2;
+  const uint64_t entry_size = reader_->AddressSize() * 2;
   bool list_end = false;
 
   do {
@@ -1263,8 +1263,8 @@ bool RangeListReader::ReadRangeList(uint64 offset) {
       return false; // Invalid range detected
     }
 
-    uint64 start_address = reader_->ReadAddress(buffer_ + offset);
-    uint64 end_address =
+    uint64_t start_address = reader_->ReadAddress(buffer_ + offset);
+    uint64_t end_address =
       reader_->ReadAddress(buffer_ + offset + reader_->AddressSize());
 
     if (start_address == max_address) { // Base address selection
@@ -1305,7 +1305,7 @@ class CallFrameInfo::Rule {
   // the canonical frame address. Return what the HANDLER member function
   // returned.
   virtual bool Handle(Handler *handler,
-                      uint64 address, int reg) const = 0;
+                      uint64_t address, int reg) const = 0;
 
   // Equality on rules. We use these to decide which rules we need
   // to report after a DW_CFA_restore_state instruction.
@@ -1330,7 +1330,7 @@ class CallFrameInfo::UndefinedRule: public CallFrameInfo::Rule {
  public:
   UndefinedRule() { }
   ~UndefinedRule() { }
-  bool Handle(Handler *handler, uint64 address, int reg) const {
+  bool Handle(Handler *handler, uint64_t address, int reg) const {
     return handler->UndefinedRule(address, reg);
   }
   bool operator==(const Rule &rhs) const {
@@ -1347,7 +1347,7 @@ class CallFrameInfo::SameValueRule: public CallFrameInfo::Rule {
  public:
   SameValueRule() { }
   ~SameValueRule() { }
-  bool Handle(Handler *handler, uint64 address, int reg) const {
+  bool Handle(Handler *handler, uint64_t address, int reg) const {
     return handler->SameValueRule(address, reg);
   }
   bool operator==(const Rule &rhs) const {
@@ -1366,7 +1366,7 @@ class CallFrameInfo::OffsetRule: public CallFrameInfo::Rule {
   OffsetRule(int base_register, long offset)
       : base_register_(base_register), offset_(offset) { }
   ~OffsetRule() { }
-  bool Handle(Handler *handler, uint64 address, int reg) const {
+  bool Handle(Handler *handler, uint64_t address, int reg) const {
     return handler->OffsetRule(address, reg, base_register_, offset_);
   }
   bool operator==(const Rule &rhs) const {
@@ -1395,7 +1395,7 @@ class CallFrameInfo::ValOffsetRule: public CallFrameInfo::Rule {
   ValOffsetRule(int base_register, long offset)
       : base_register_(base_register), offset_(offset) { }
   ~ValOffsetRule() { }
-  bool Handle(Handler *handler, uint64 address, int reg) const {
+  bool Handle(Handler *handler, uint64_t address, int reg) const {
     return handler->ValOffsetRule(address, reg, base_register_, offset_);
   }
   bool operator==(const Rule &rhs) const {
@@ -1420,7 +1420,7 @@ class CallFrameInfo::RegisterRule: public CallFrameInfo::Rule {
   explicit RegisterRule(int register_number)
       : register_number_(register_number) { }
   ~RegisterRule() { }
-  bool Handle(Handler *handler, uint64 address, int reg) const {
+  bool Handle(Handler *handler, uint64_t address, int reg) const {
     return handler->RegisterRule(address, reg, register_number_);
   }
   bool operator==(const Rule &rhs) const {
@@ -1440,7 +1440,7 @@ class CallFrameInfo::ExpressionRule: public CallFrameInfo::Rule {
   explicit ExpressionRule(const string &expression)
       : expression_(expression) { }
   ~ExpressionRule() { }
-  bool Handle(Handler *handler, uint64 address, int reg) const {
+  bool Handle(Handler *handler, uint64_t address, int reg) const {
     return handler->ExpressionRule(address, reg, expression_);
   }
   bool operator==(const Rule &rhs) const {
@@ -1460,7 +1460,7 @@ class CallFrameInfo::ValExpressionRule: public CallFrameInfo::Rule {
   explicit ValExpressionRule(const string &expression)
       : expression_(expression) { }
   ~ValExpressionRule() { }
-  bool Handle(Handler *handler, uint64 address, int reg) const {
+  bool Handle(Handler *handler, uint64_t address, int reg) const {
     return handler->ValExpressionRule(address, reg, expression_);
   }
   bool operator==(const Rule &rhs) const {
@@ -1504,7 +1504,7 @@ class CallFrameInfo::RuleMap {
   // this RuleMap to NEW_RULES at ADDRESS. We use this to implement
   // DW_CFA_restore_state, where lots of rules can change simultaneously.
   // Return true if all handlers returned true; otherwise, return false.
-  bool HandleTransitionTo(Handler *handler, uint64 address,
+  bool HandleTransitionTo(Handler *handler, uint64_t address,
                           const RuleMap &new_rules) const;
 
  private:
@@ -1552,7 +1552,7 @@ void CallFrameInfo::RuleMap::SetRegisterRule(int reg, Rule *rule) {
 
 bool CallFrameInfo::RuleMap::HandleTransitionTo(
     Handler *handler,
-    uint64 address,
+    uint64_t address,
     const RuleMap &new_rules) const {
   // Transition from cfa_rule_ to new_rules.cfa_rule_.
   if (cfa_rule_ && new_rules.cfa_rule_) {
@@ -1634,7 +1634,7 @@ class CallFrameInfo::State {
   // Create a call frame information interpreter state with the given
   // reporter, reader, handler, and initial call frame info address.
   State(ByteReader *reader, Handler *handler, Reporter *reporter,
-        uint64 address)
+        uint64_t address)
       : reader_(reader), handler_(handler), reporter_(reporter),
         address_(address), entry_(NULL), cursor_(NULL) { }
 
@@ -1651,7 +1651,7 @@ class CallFrameInfo::State {
   // The operands of a CFI instruction, for ParseOperands.
   struct Operands {
     unsigned register_number;  // A register number.
-    uint64 offset;             // An offset or address.
+    uint64_t offset;             // An offset or address.
     long signed_offset;        // A signed offset.
     string expression;         // A DWARF expression.
   };
@@ -1717,7 +1717,7 @@ class CallFrameInfo::State {
 
   // Return the section offset of the instruction at cursor. For use
   // in error messages.
-  uint64 CursorOffset() { return entry_->offset + (cursor_ - entry_->start); }
+  uint64_t CursorOffset() { return entry_->offset + (cursor_ - entry_->start); }
 
   // Report that entry_ is incomplete, and return false. For brevity.
   bool ReportIncomplete() {
@@ -1735,7 +1735,7 @@ class CallFrameInfo::State {
   Reporter *reporter_;
 
   // The code address to which the next instruction in the stream applies.
-  uint64 address_;
+  uint64_t address_;
 
   // The entry whose instructions we are currently processing. This is
   // first a CIE, and then an FDE.
@@ -2205,7 +2205,7 @@ bool CallFrameInfo::ReadEntryPrologue(const uint8_t *cursor, Entry *entry) {
 
   // Read the initial length. This sets reader_'s offset size.
   size_t length_size;
-  uint64 length = reader_->ReadInitialLength(cursor, &length_size);
+  uint64_t length = reader_->ReadInitialLength(cursor, &length_size);
   if (length_size > size_t(buffer_end - cursor))
     return ReportIncomplete(entry);
   cursor += length_size;
@@ -2357,7 +2357,7 @@ bool CallFrameInfo::ReadCIEFields(CIE *cie) {
   // a ULEB128 in version 3.
   if (cie->version == 1) {
     if (cursor >= cie->end) return ReportIncomplete(cie);
-    cie->return_address_register = uint8(*cursor++);
+    cie->return_address_register = uint8_t(*cursor++);
   } else {
     cie->return_address_register = reader_->ReadUnsignedLEB128(cursor, &len);
     if (size_t(cie->end - cursor) < len) return ReportIncomplete(cie);
@@ -2683,7 +2683,7 @@ bool CallFrameInfo::ReportIncomplete(Entry *entry) {
   return false;
 }
 
-void CallFrameInfo::Reporter::Incomplete(uint64 offset,
+void CallFrameInfo::Reporter::Incomplete(uint64_t offset,
                                          CallFrameInfo::EntryKind kind) {
   fprintf(stderr,
           "%s: CFI %s at offset 0x%llx in '%s': entry ends early\n",
@@ -2691,29 +2691,29 @@ void CallFrameInfo::Reporter::Incomplete(uint64 offset,
           section_.c_str());
 }
 
-void CallFrameInfo::Reporter::EarlyEHTerminator(uint64 offset) {
+void CallFrameInfo::Reporter::EarlyEHTerminator(uint64_t offset) {
   fprintf(stderr,
           "%s: CFI at offset 0x%llx in '%s': saw end-of-data marker"
           " before end of section contents\n",
           filename_.c_str(), offset, section_.c_str());
 }
 
-void CallFrameInfo::Reporter::CIEPointerOutOfRange(uint64 offset,
-                                                   uint64 cie_offset) {
+void CallFrameInfo::Reporter::CIEPointerOutOfRange(uint64_t offset,
+                                                   uint64_t cie_offset) {
   fprintf(stderr,
           "%s: CFI frame description entry at offset 0x%llx in '%s':"
           " CIE pointer is out of range: 0x%llx\n",
           filename_.c_str(), offset, section_.c_str(), cie_offset);
 }
 
-void CallFrameInfo::Reporter::BadCIEId(uint64 offset, uint64 cie_offset) {
+void CallFrameInfo::Reporter::BadCIEId(uint64_t offset, uint64_t cie_offset) {
   fprintf(stderr,
           "%s: CFI frame description entry at offset 0x%llx in '%s':"
           " CIE pointer does not point to a CIE: 0x%llx\n",
           filename_.c_str(), offset, section_.c_str(), cie_offset);
 }
 
-void CallFrameInfo::Reporter::UnexpectedAddressSize(uint64 offset,
+void CallFrameInfo::Reporter::UnexpectedAddressSize(uint64_t offset,
                                                     uint8_t address_size) {
   fprintf(stderr,
           "%s: CFI frame description entry at offset 0x%llx in '%s':"
@@ -2721,7 +2721,7 @@ void CallFrameInfo::Reporter::UnexpectedAddressSize(uint64 offset,
           filename_.c_str(), offset, section_.c_str(), address_size);
 }
 
-void CallFrameInfo::Reporter::UnexpectedSegmentSize(uint64 offset,
+void CallFrameInfo::Reporter::UnexpectedSegmentSize(uint64_t offset,
                                                     uint8_t segment_size) {
   fprintf(stderr,
           "%s: CFI frame description entry at offset 0x%llx in '%s':"
@@ -2729,14 +2729,14 @@ void CallFrameInfo::Reporter::UnexpectedSegmentSize(uint64 offset,
           filename_.c_str(), offset, section_.c_str(), segment_size);
 }
 
-void CallFrameInfo::Reporter::UnrecognizedVersion(uint64 offset, int version) {
+void CallFrameInfo::Reporter::UnrecognizedVersion(uint64_t offset, int version) {
   fprintf(stderr,
           "%s: CFI frame description entry at offset 0x%llx in '%s':"
           " CIE specifies unrecognized version: %d\n",
           filename_.c_str(), offset, section_.c_str(), version);
 }
 
-void CallFrameInfo::Reporter::UnrecognizedAugmentation(uint64 offset,
+void CallFrameInfo::Reporter::UnrecognizedAugmentation(uint64_t offset,
                                                        const string &aug) {
   fprintf(stderr,
           "%s: CFI frame description entry at offset 0x%llx in '%s':"
@@ -2744,16 +2744,16 @@ void CallFrameInfo::Reporter::UnrecognizedAugmentation(uint64 offset,
           filename_.c_str(), offset, section_.c_str(), aug.c_str());
 }
 
-void CallFrameInfo::Reporter::InvalidPointerEncoding(uint64 offset,
-                                                     uint8 encoding) {
+void CallFrameInfo::Reporter::InvalidPointerEncoding(uint64_t offset,
+                                                     uint8_t encoding) {
   fprintf(stderr,
           "%s: CFI common information entry at offset 0x%llx in '%s':"
           " 'z' augmentation specifies invalid pointer encoding: 0x%02x\n",
           filename_.c_str(), offset, section_.c_str(), encoding);
 }
 
-void CallFrameInfo::Reporter::UnusablePointerEncoding(uint64 offset,
-                                                      uint8 encoding) {
+void CallFrameInfo::Reporter::UnusablePointerEncoding(uint64_t offset,
+                                                      uint8_t encoding) {
   fprintf(stderr,
           "%s: CFI common information entry at offset 0x%llx in '%s':"
           " 'z' augmentation specifies a pointer encoding for which"
@@ -2761,7 +2761,7 @@ void CallFrameInfo::Reporter::UnusablePointerEncoding(uint64 offset,
           filename_.c_str(), offset, section_.c_str(), encoding);
 }
 
-void CallFrameInfo::Reporter::RestoreInCIE(uint64 offset, uint64 insn_offset) {
+void CallFrameInfo::Reporter::RestoreInCIE(uint64_t offset, uint64_t insn_offset) {
   fprintf(stderr,
           "%s: CFI common information entry at offset 0x%llx in '%s':"
           " the DW_CFA_restore instruction at offset 0x%llx"
@@ -2769,9 +2769,9 @@ void CallFrameInfo::Reporter::RestoreInCIE(uint64 offset, uint64 insn_offset) {
           filename_.c_str(), offset, section_.c_str(), insn_offset);
 }
 
-void CallFrameInfo::Reporter::BadInstruction(uint64 offset,
+void CallFrameInfo::Reporter::BadInstruction(uint64_t offset,
                                              CallFrameInfo::EntryKind kind,
-                                             uint64 insn_offset) {
+                                             uint64_t insn_offset) {
   fprintf(stderr,
           "%s: CFI %s at offset 0x%llx in section '%s':"
           " the instruction at offset 0x%llx is unrecognized\n",
@@ -2779,9 +2779,9 @@ void CallFrameInfo::Reporter::BadInstruction(uint64 offset,
           offset, section_.c_str(), insn_offset);
 }
 
-void CallFrameInfo::Reporter::NoCFARule(uint64 offset,
+void CallFrameInfo::Reporter::NoCFARule(uint64_t offset,
                                         CallFrameInfo::EntryKind kind,
-                                        uint64 insn_offset) {
+                                        uint64_t insn_offset) {
   fprintf(stderr,
           "%s: CFI %s at offset 0x%llx in section '%s':"
           " the instruction at offset 0x%llx assumes that a CFA rule has"
@@ -2790,9 +2790,9 @@ void CallFrameInfo::Reporter::NoCFARule(uint64 offset,
           section_.c_str(), insn_offset);
 }
 
-void CallFrameInfo::Reporter::EmptyStateStack(uint64 offset,
+void CallFrameInfo::Reporter::EmptyStateStack(uint64_t offset,
                                               CallFrameInfo::EntryKind kind,
-                                              uint64 insn_offset) {
+                                              uint64_t insn_offset) {
   fprintf(stderr,
           "%s: CFI %s at offset 0x%llx in section '%s':"
           " the DW_CFA_restore_state instruction at offset 0x%llx"
@@ -2801,9 +2801,9 @@ void CallFrameInfo::Reporter::EmptyStateStack(uint64 offset,
           section_.c_str(), insn_offset);
 }
 
-void CallFrameInfo::Reporter::ClearingCFARule(uint64 offset,
+void CallFrameInfo::Reporter::ClearingCFARule(uint64_t offset,
                                               CallFrameInfo::EntryKind kind,
-                                              uint64 insn_offset) {
+                                              uint64_t insn_offset) {
   fprintf(stderr,
           "%s: CFI %s at offset 0x%llx in section '%s':"
           " the DW_CFA_restore_state instruction at offset 0x%llx"
diff --git a/src/common/dwarf/dwarf2reader.h b/src/common/dwarf/dwarf2reader.h
index 902d9ef1..0b194c17 100644
--- a/src/common/dwarf/dwarf2reader.h
+++ b/src/common/dwarf/dwarf2reader.h
@@ -63,21 +63,21 @@ class DwpReader;
 
 // This maps from a string naming a section to a pair containing a
 // the data for the section, and the size of the section.
-typedef std::map<string, std::pair<const uint8_t *, uint64> > SectionMap;
+typedef std::map<string, std::pair<const uint8_t *, uint64_t> > SectionMap;
 typedef std::list<std::pair<enum DwarfAttribute, enum DwarfForm> >
     AttributeList;
 typedef AttributeList::iterator AttributeIterator;
 typedef AttributeList::const_iterator ConstAttributeIterator;
 
 struct LineInfoHeader {
-  uint64 total_length;
-  uint16 version;
-  uint64 prologue_length;
-  uint8 min_insn_length; // insn stands for instructin
+  uint64_t total_length;
+  uint16_t version;
+  uint64_t prologue_length;
+  uint8_t min_insn_length; // insn stands for instructin
   bool default_is_stmt; // stmt stands for statement
-  int8 line_base;
-  uint8 line_range;
-  uint8 opcode_base;
+  int8_t line_base;
+  uint8_t line_range;
+  uint8_t opcode_base;
   // Use a pointer so that signalsafe_addr2line is able to use this structure
   // without heap allocation problem.
   std::vector<unsigned char> *std_opcode_lengths;
@@ -90,7 +90,7 @@ class LineInfo {
   // to the beginning and length of the line information to read.
   // Reader is a ByteReader class that has the endianness set
   // properly.
-  LineInfo(const uint8_t *buffer_, uint64 buffer_length,
+  LineInfo(const uint8_t *buffer_, uint64_t buffer_length,
            ByteReader* reader, LineInfoHandler* handler);
 
   virtual ~LineInfo() {
@@ -102,7 +102,7 @@ class LineInfo {
   // Start processing line info, and calling callbacks in the handler.
   // Consumes the line number information for a single compilation unit.
   // Returns the number of bytes processed.
-  uint64 Start();
+  uint64_t Start();
 
   // Process a single line info opcode at START using the state
   // machine at LSM.  Return true if we should define a line using the
@@ -146,7 +146,7 @@ class LineInfo {
   // the end of the line information header.
   const uint8_t *buffer_;
 #ifndef NDEBUG
-  uint64 buffer_length_;
+  uint64_t buffer_length_;
 #endif
   const uint8_t *after_header_;
 };
@@ -164,7 +164,7 @@ class LineInfoHandler {
 
   // Called when we define a directory.  NAME is the directory name,
   // DIR_NUM is the directory number
-  virtual void DefineDir(const string& name, uint32 dir_num) { }
+  virtual void DefineDir(const string& name, uint32_t dir_num) { }
 
   // Called when we define a filename. NAME is the filename, FILE_NUM
   // is the file number which is -1 if the file index is the next
@@ -173,9 +173,9 @@ class LineInfoHandler {
   // directory index for the directory name of this file, MOD_TIME is
   // the modification time of the file, and LENGTH is the length of
   // the file
-  virtual void DefineFile(const string& name, int32 file_num,
-                          uint32 dir_num, uint64 mod_time,
-                          uint64 length) { }
+  virtual void DefineFile(const string& name, int32_t file_num,
+                          uint32_t dir_num, uint64_t mod_time,
+                          uint64_t length) { }
 
   // Called when the line info reader has a new line, address pair
   // ready for us. ADDRESS is the address of the code, LENGTH is the
@@ -183,8 +183,8 @@ class LineInfoHandler {
   // containing the code, LINE_NUM is the line number in that file for
   // the code, and COLUMN_NUM is the column number the code starts at,
   // if we know it (0 otherwise).
-  virtual void AddLine(uint64 address, uint64 length,
-                       uint32 file_num, uint32 line_num, uint32 column_num) { }
+  virtual void AddLine(uint64_t address, uint64_t length,
+                       uint32_t file_num, uint32_t line_num, uint32_t column_num) { }
 };
 
 class RangeListHandler {
@@ -194,10 +194,10 @@ class RangeListHandler {
   virtual ~RangeListHandler() { }
 
   // Add a range.
-  virtual void AddRange(uint64 begin, uint64 end) { };
+  virtual void AddRange(uint64_t begin, uint64_t end) { };
 
   // A new base address must be set for computing the ranges' addresses.
-  virtual void SetBaseAddress(uint64 base_address) { };
+  virtual void SetBaseAddress(uint64_t base_address) { };
 
   // Finish processing the range list.
   virtual void Finish() { };
@@ -205,14 +205,14 @@ class RangeListHandler {
 
 class RangeListReader {
  public:
-  RangeListReader(const uint8_t *buffer, uint64 size, ByteReader *reader,
+  RangeListReader(const uint8_t *buffer, uint64_t size, ByteReader *reader,
                   RangeListHandler *handler);
 
-  bool ReadRangeList(uint64 offset);
+  bool ReadRangeList(uint64_t offset);
 
  private:
   const uint8_t *buffer_;
-  uint64 size_;
+  uint64_t size_;
   ByteReader* reader_;
   RangeListHandler *handler_;
 };
@@ -230,9 +230,9 @@ class Dwarf2Handler {
   // Start to process a compilation unit at OFFSET from the beginning of the
   // .debug_info section. Return false if you would like to skip this
   // compilation unit.
-  virtual bool StartCompilationUnit(uint64 offset, uint8 address_size,
-                                    uint8 offset_size, uint64 cu_length,
-                                    uint8 dwarf_version) { return false; }
+  virtual bool StartCompilationUnit(uint64_t offset, uint8_t address_size,
+                                    uint8_t offset_size, uint64_t cu_length,
+                                    uint8_t dwarf_version) { return false; }
 
   // When processing a skeleton compilation unit, resulting from a split
   // DWARF compilation, once the skeleton debug info has been read,
@@ -244,40 +244,40 @@ class Dwarf2Handler {
   // Start to process a split compilation unit at OFFSET from the beginning of
   // the debug_info section in the .dwp/.dwo file.  Return false if you would
   // like to skip this compilation unit.
-  virtual bool StartSplitCompilationUnit(uint64 offset,
-                                         uint64 cu_length) { return false; }
+  virtual bool StartSplitCompilationUnit(uint64_t offset,
+                                         uint64_t cu_length) { return false; }
 
   // Start to process a DIE at OFFSET from the beginning of the .debug_info
   // section. Return false if you would like to skip this DIE.
-  virtual bool StartDIE(uint64 offset, enum DwarfTag tag) { return false; }
+  virtual bool StartDIE(uint64_t offset, enum DwarfTag tag) { return false; }
 
   // Called when we have an attribute with unsigned data to give to our
   // handler. The attribute is for the DIE at OFFSET from the beginning of the
   // .debug_info section. Its name is ATTR, its form is FORM, and its value is
   // DATA.
-  virtual void ProcessAttributeUnsigned(uint64 offset,
+  virtual void ProcessAttributeUnsigned(uint64_t offset,
                                         enum DwarfAttribute attr,
                                         enum DwarfForm form,
-                                        uint64 data) { }
+                                        uint64_t data) { }
 
   // Called when we have an attribute with signed data to give to our handler.
   // The attribute is for the DIE at OFFSET from the beginning of the
   // .debug_info section. Its name is ATTR, its form is FORM, and its value is
   // DATA.
-  virtual void ProcessAttributeSigned(uint64 offset,
+  virtual void ProcessAttributeSigned(uint64_t offset,
                                       enum DwarfAttribute attr,
                                       enum DwarfForm form,
-                                      int64 data) { }
+                                      int64_t data) { }
 
   // Called when we have an attribute whose value is a reference to
   // another DIE. The attribute belongs to the DIE at OFFSET from the
   // beginning of the .debug_info section. Its name is ATTR, its form
   // is FORM, and the offset of the DIE being referred to from the
   // beginning of the .debug_info section is DATA.
-  virtual void ProcessAttributeReference(uint64 offset,
+  virtual void ProcessAttributeReference(uint64_t offset,
                                          enum DwarfAttribute attr,
                                          enum DwarfForm form,
-                                         uint64 data) { }
+                                         uint64_t data) { }
 
   // Called when we have an attribute with a buffer of data to give to our
   // handler. The attribute is for the DIE at OFFSET from the beginning of the
@@ -285,17 +285,17 @@ class Dwarf2Handler {
   // the buffer's contents, and its length in bytes is LENGTH. The buffer is
   // owned by the caller, not the callee, and may not persist for very long.
   // If you want the data to be available later, it needs to be copied.
-  virtual void ProcessAttributeBuffer(uint64 offset,
+  virtual void ProcessAttributeBuffer(uint64_t offset,
                                       enum DwarfAttribute attr,
                                       enum DwarfForm form,
                                       const uint8_t *data,
-                                      uint64 len) { }
+                                      uint64_t len) { }
 
   // Called when we have an attribute with string data to give to our handler.
   // The attribute is for the DIE at OFFSET from the beginning of the
   // .debug_info section. Its name is ATTR, its form is FORM, and its value is
   // DATA.
-  virtual void ProcessAttributeString(uint64 offset,
+  virtual void ProcessAttributeString(uint64_t offset,
                                       enum DwarfAttribute attr,
                                       enum DwarfForm form,
                                       const string& data) { }
@@ -304,16 +304,16 @@ class Dwarf2Handler {
   // of a type unit in the .debug_types section. OFFSET is the offset of
   // the DIE whose attribute we're reporting. ATTR and FORM are the
   // attribute's name and form. SIGNATURE is the type unit's signature.
-  virtual void ProcessAttributeSignature(uint64 offset,
+  virtual void ProcessAttributeSignature(uint64_t offset,
                                          enum DwarfAttribute attr,
                                          enum DwarfForm form,
-                                         uint64 signature) { }
+                                         uint64_t signature) { }
 
   // Called when finished processing the DIE at OFFSET.
   // Because DWARF2/3 specifies a tree of DIEs, you may get starts
   // before ends of the previous DIE, as we process children before
   // ending the parent.
-  virtual void EndDIE(uint64 offset) { }
+  virtual void EndDIE(uint64_t offset) { }
 
 };
 
@@ -358,8 +358,8 @@ class CompilationUnit {
   // Initialize a compilation unit.  This requires a map of sections,
   // the offset of this compilation unit in the .debug_info section, a
   // ByteReader, and a Dwarf2Handler class to call callbacks in.
-  CompilationUnit(const string& path, const SectionMap& sections, uint64 offset,
-                  ByteReader* reader, Dwarf2Handler* handler);
+  CompilationUnit(const string& path, const SectionMap& sections,
+                  uint64_t offset, ByteReader* reader, Dwarf2Handler* handler);
   virtual ~CompilationUnit() {
     if (abbrevs_) delete abbrevs_;
   }
@@ -370,8 +370,8 @@ class CompilationUnit {
   // compilation unit.  We also inherit the Dwarf2Handler from
   // the executable file, and call it as if we were still
   // processing the original compilation unit.
-  void SetSplitDwarf(const uint8_t* addr_buffer, uint64 addr_buffer_length,
-                     uint64 addr_base, uint64 ranges_base, uint64 dwo_id);
+  void SetSplitDwarf(const uint8_t* addr_buffer, uint64_t addr_buffer_length,
+                     uint64_t addr_base, uint64_t ranges_base, uint64_t dwo_id);
 
   // Begin reading a Dwarf2 compilation unit, and calling the
   // callbacks in the Dwarf2Handler
@@ -380,7 +380,7 @@ class CompilationUnit {
   // headers. This plus the starting offset passed to the constructor
   // is the offset of the end of the compilation unit --- and the
   // start of the next compilation unit, if there is one.
-  uint64 Start();
+  uint64_t Start();
 
  private:
 
@@ -388,7 +388,7 @@ class CompilationUnit {
   // The abbreviation tells how to read a DWARF2/3 DIE, and consist of a
   // tag and a list of attributes, as well as the data form of each attribute.
   struct Abbrev {
-    uint64 number;
+    uint64_t number;
     enum DwarfTag tag;
     bool has_children;
     AttributeList attributes;
@@ -398,10 +398,10 @@ class CompilationUnit {
   // in the actual file, as the one in the file may have a 32 bit or
   // 64 bit length.
   struct CompilationUnitHeader {
-    uint64 length;
-    uint16 version;
-    uint64 abbrev_offset;
-    uint8 address_size;
+    uint64_t length;
+    uint16_t version;
+    uint64_t abbrev_offset;
+    uint8_t address_size;
   } header_;
 
   // Reads the DWARF2/3 header for this compilation unit.
@@ -412,13 +412,13 @@ class CompilationUnit {
 
   // Processes a single DIE for this compilation unit and return a new
   // pointer just past the end of it
-  const uint8_t *ProcessDIE(uint64 dieoffset,
+  const uint8_t *ProcessDIE(uint64_t dieoffset,
                             const uint8_t *start,
                             const Abbrev& abbrev);
 
   // Processes a single attribute and return a new pointer just past the
   // end of it
-  const uint8_t *ProcessAttribute(uint64 dieoffset,
+  const uint8_t *ProcessAttribute(uint64_t dieoffset,
                                   const uint8_t *start,
                                   enum DwarfAttribute attr,
                                   enum DwarfForm form);
@@ -429,10 +429,10 @@ class CompilationUnit {
   // FORM, and the actual data of the attribute is in DATA.
   // If we see a DW_AT_GNU_dwo_id attribute, save the value so that
   // we can find the debug info in a .dwo or .dwp file.
-  void ProcessAttributeUnsigned(uint64 offset,
+  void ProcessAttributeUnsigned(uint64_t offset,
                                 enum DwarfAttribute attr,
                                 enum DwarfForm form,
-                                uint64 data) {
+                                uint64_t data) {
     if (attr == DW_AT_GNU_dwo_id) {
       dwo_id_ = data;
     }
@@ -455,10 +455,10 @@ class CompilationUnit {
   // our handler.  The attribute is for the DIE at OFFSET from the
   // beginning of compilation unit, has a name of ATTR, a form of
   // FORM, and the actual data of the attribute is in DATA.
-  void ProcessAttributeSigned(uint64 offset,
+  void ProcessAttributeSigned(uint64_t offset,
                               enum DwarfAttribute attr,
                               enum DwarfForm form,
-                              int64 data) {
+                              int64_t data) {
     handler_->ProcessAttributeSigned(offset, attr, form, data);
   }
 
@@ -467,11 +467,11 @@ class CompilationUnit {
   // beginning of compilation unit, has a name of ATTR, a form of
   // FORM, and the actual data of the attribute is in DATA, and the
   // length of the buffer is LENGTH.
-  void ProcessAttributeBuffer(uint64 offset,
+  void ProcessAttributeBuffer(uint64_t offset,
                               enum DwarfAttribute attr,
                               enum DwarfForm form,
                               const uint8_t* data,
-                              uint64 len) {
+                              uint64_t len) {
     handler_->ProcessAttributeBuffer(offset, attr, form, data, len);
   }
 
@@ -481,7 +481,7 @@ class CompilationUnit {
   // FORM, and the actual data of the attribute is in DATA.
   // If we see a DW_AT_GNU_dwo_name attribute, save the value so
   // that we can find the debug info in a .dwo or .dwp file.
-  void ProcessAttributeString(uint64 offset,
+  void ProcessAttributeString(uint64_t offset,
                               enum DwarfAttribute attr,
                               enum DwarfForm form,
                               const char* data) {
@@ -513,13 +513,13 @@ class CompilationUnit {
 
   // Offset from section start is the offset of this compilation unit
   // from the beginning of the .debug_info section.
-  uint64 offset_from_section_start_;
+  uint64_t offset_from_section_start_;
 
   // buffer is the buffer for our CU, starting at .debug_info + offset
   // passed in from constructor.
   // after_header points to right after the compilation unit header.
   const uint8_t *buffer_;
-  uint64 buffer_length_;
+  uint64_t buffer_length_;
   const uint8_t *after_header_;
 
   // The associated ByteReader that handles endianness issues for us
@@ -540,17 +540,17 @@ class CompilationUnit {
   // This is here to avoid doing a section lookup for strings in
   // ProcessAttribute, which is in the hot path for DWARF2 reading.
   const uint8_t *string_buffer_;
-  uint64 string_buffer_length_;
+  uint64_t string_buffer_length_;
 
   // String offsets section buffer and length, if we have a string offsets
   // section (.debug_str_offsets or .debug_str_offsets.dwo).
   const uint8_t* str_offsets_buffer_;
-  uint64 str_offsets_buffer_length_;
+  uint64_t str_offsets_buffer_length_;
 
   // Address section buffer and length, if we have an address section
   // (.debug_addr).
   const uint8_t* addr_buffer_;
-  uint64 addr_buffer_length_;
+  uint64_t addr_buffer_length_;
 
   // Flag indicating whether this compilation unit is part of a .dwo
   // or .dwp file.  If true, we are reading this unit because a
@@ -562,20 +562,20 @@ class CompilationUnit {
   bool is_split_dwarf_;
 
   // The value of the DW_AT_GNU_dwo_id attribute, if any.
-  uint64 dwo_id_;
+  uint64_t dwo_id_;
 
   // The value of the DW_AT_GNU_dwo_name attribute, if any.
   const char* dwo_name_;
 
   // If this is a split DWARF CU, the value of the DW_AT_GNU_dwo_id attribute
   // from the skeleton CU.
-  uint64 skeleton_dwo_id_;
+  uint64_t skeleton_dwo_id_;
 
   // The value of the DW_AT_GNU_ranges_base attribute, if any.
-  uint64 ranges_base_;
+  uint64_t ranges_base_;
 
   // The value of the DW_AT_GNU_addr_base attribute, if any.
-  uint64 addr_base_;
+  uint64_t addr_base_;
 
   // True if we have already looked for a .dwp file.
   bool have_checked_for_dwp_;
@@ -613,16 +613,16 @@ class DwpReader {
   void Initialize();
 
   // Read the debug sections for the given dwo_id.
-  void ReadDebugSectionsForCU(uint64 dwo_id, SectionMap* sections);
+  void ReadDebugSectionsForCU(uint64_t dwo_id, SectionMap* sections);
 
  private:
   // Search a v1 hash table for "dwo_id".  Returns the slot index
   // where the dwo_id was found, or -1 if it was not found.
-  int LookupCU(uint64 dwo_id);
+  int LookupCU(uint64_t dwo_id);
 
   // Search a v2 hash table for "dwo_id".  Returns the row index
   // in the offsets and sizes tables, or 0 if it was not found.
-  uint32 LookupCUv2(uint64 dwo_id);
+  uint32_t LookupCUv2(uint64_t dwo_id);
 
   // The ELF reader for the .dwp file.
   ElfReader* elf_reader_;
@@ -957,7 +957,7 @@ class CallFrameInfo {
 
     // For both DWARF CFI and .eh_frame sections, this is the CIE id in a
     // CIE, and the offset of the associated CIE in an FDE.
-    uint64 id;
+    uint64_t id;
 
     // The CIE that applies to this entry, if we've parsed it. If this is a
     // CIE, then this field points to this structure.
@@ -966,9 +966,9 @@ class CallFrameInfo {
 
   // A common information entry (CIE).
   struct CIE: public Entry {
-    uint8 version;                      // CFI data version number
+    uint8_t version;                      // CFI data version number
     string augmentation;                // vendor format extension markers
-    uint64 code_alignment_factor;       // scale for code address adjustments 
+    uint64_t code_alignment_factor;       // scale for code address adjustments 
     int data_alignment_factor;          // scale for stack pointer adjustments
     unsigned return_address_register;   // which register holds the return addr
 
@@ -992,7 +992,7 @@ class CallFrameInfo {
     // If has_z_personality is true, this is the address of the personality
     // routine --- or, if personality_encoding & DW_EH_PE_indirect, the
     // address where the personality routine's address is stored.
-    uint64 personality_address;
+    uint64_t personality_address;
 
     // This is the encoding used for addresses in the FDE header and
     // in DW_CFA_set_loc instructions. This is always valid, whether
@@ -1002,19 +1002,19 @@ class CallFrameInfo {
 
     // These were only introduced in DWARF4, so will not be set in older
     // versions.
-    uint8 address_size;
-    uint8 segment_size;
+    uint8_t address_size;
+    uint8_t segment_size;
   };
 
   // A frame description entry (FDE).
   struct FDE: public Entry {
-    uint64 address;                     // start address of described code
-    uint64 size;                        // size of described code, in bytes
+    uint64_t address;                     // start address of described code
+    uint64_t size;                        // size of described code, in bytes
 
     // If cie->has_z_lsda is true, then this is the language-specific data
     // area's address --- or its address's address, if cie->lsda_encoding
     // has the DW_EH_PE_indirect bit set.
-    uint64 lsda_address;
+    uint64_t lsda_address;
   };
 
   // Internal use.
@@ -1105,8 +1105,8 @@ class CallFrameInfo::Handler {
   // to the handler explicitly; instead, if the handler elects to
   // process a given FDE, the parser reiterates the appropriate CIE's
   // contents at the beginning of the FDE's rules.
-  virtual bool Entry(size_t offset, uint64 address, uint64 length,
-                     uint8 version, const string &augmentation,
+  virtual bool Entry(size_t offset, uint64_t address, uint64_t length,
+                     uint8_t version, const string &augmentation,
                      unsigned return_address) = 0;
 
   // When the Entry function returns true, the parser calls these
@@ -1128,21 +1128,21 @@ class CallFrameInfo::Handler {
   // computation. All other REG values will be positive.
 
   // At ADDRESS, register REG's value is not recoverable.
-  virtual bool UndefinedRule(uint64 address, int reg) = 0;
+  virtual bool UndefinedRule(uint64_t address, int reg) = 0;
 
   // At ADDRESS, register REG's value is the same as that it had in
   // the caller.
-  virtual bool SameValueRule(uint64 address, int reg) = 0;
+  virtual bool SameValueRule(uint64_t address, int reg) = 0;
 
   // At ADDRESS, register REG has been saved at offset OFFSET from
   // BASE_REGISTER.
-  virtual bool OffsetRule(uint64 address, int reg,
+  virtual bool OffsetRule(uint64_t address, int reg,
                           int base_register, long offset) = 0;
 
   // At ADDRESS, the caller's value of register REG is the current
   // value of BASE_REGISTER plus OFFSET. (This rule doesn't provide an
   // address at which the register's value is saved.)
-  virtual bool ValOffsetRule(uint64 address, int reg,
+  virtual bool ValOffsetRule(uint64_t address, int reg,
                              int base_register, long offset) = 0;
 
   // At ADDRESS, register REG has been saved in BASE_REGISTER. This differs
@@ -1150,17 +1150,17 @@ class CallFrameInfo::Handler {
   // BASE_REGISTER is the "home" for REG's saved value: if you want to
   // assign to a variable whose home is REG in the calling frame, you
   // should put the value in BASE_REGISTER.
-  virtual bool RegisterRule(uint64 address, int reg, int base_register) = 0;
+  virtual bool RegisterRule(uint64_t address, int reg, int base_register) = 0;
 
   // At ADDRESS, the DWARF expression EXPRESSION yields the address at
   // which REG was saved.
-  virtual bool ExpressionRule(uint64 address, int reg,
+  virtual bool ExpressionRule(uint64_t address, int reg,
                               const string &expression) = 0;
 
   // At ADDRESS, the DWARF expression EXPRESSION yields the caller's
   // value for REG. (This rule doesn't provide an address at which the
   // register's value is saved.)
-  virtual bool ValExpressionRule(uint64 address, int reg,
+  virtual bool ValExpressionRule(uint64_t address, int reg,
                                  const string &expression) = 0;
 
   // Indicate that the rules for the address range reported by the
@@ -1201,7 +1201,7 @@ class CallFrameInfo::Handler {
   // which the routine's address is stored. The default definition for
   // this handler function simply returns true, allowing parsing of
   // the entry to continue.
-  virtual bool PersonalityRoutine(uint64 address, bool indirect) {
+  virtual bool PersonalityRoutine(uint64_t address, bool indirect) {
     return true;
   }
 
@@ -1210,7 +1210,7 @@ class CallFrameInfo::Handler {
   // which the area's address is stored. The default definition for
   // this handler function simply returns true, allowing parsing of
   // the entry to continue.
-  virtual bool LanguageSpecificDataArea(uint64 address, bool indirect) {
+  virtual bool LanguageSpecificDataArea(uint64_t address, bool indirect) {
     return true;
   }
 
@@ -1246,77 +1246,77 @@ class CallFrameInfo::Reporter {
   // The CFI entry at OFFSET ends too early to be well-formed. KIND
   // indicates what kind of entry it is; KIND can be kUnknown if we
   // haven't parsed enough of the entry to tell yet.
-  virtual void Incomplete(uint64 offset, CallFrameInfo::EntryKind kind);
+  virtual void Incomplete(uint64_t offset, CallFrameInfo::EntryKind kind);
 
   // The .eh_frame data has a four-byte zero at OFFSET where the next
   // entry's length would be; this is a terminator. However, the buffer
   // length as given to the CallFrameInfo constructor says there should be
   // more data.
-  virtual void EarlyEHTerminator(uint64 offset);
+  virtual void EarlyEHTerminator(uint64_t offset);
 
   // The FDE at OFFSET refers to the CIE at CIE_OFFSET, but the
   // section is not that large.
-  virtual void CIEPointerOutOfRange(uint64 offset, uint64 cie_offset);
+  virtual void CIEPointerOutOfRange(uint64_t offset, uint64_t cie_offset);
 
   // The FDE at OFFSET refers to the CIE at CIE_OFFSET, but the entry
   // there is not a CIE.
-  virtual void BadCIEId(uint64 offset, uint64 cie_offset);
+  virtual void BadCIEId(uint64_t offset, uint64_t cie_offset);
 
   // The FDE at OFFSET refers to a CIE with an address size we don't know how
   // to handle.
-  virtual void UnexpectedAddressSize(uint64 offset, uint8_t address_size);
+  virtual void UnexpectedAddressSize(uint64_t offset, uint8_t address_size);
 
   // The FDE at OFFSET refers to a CIE with an segment descriptor size we
   // don't know how to handle.
-  virtual void UnexpectedSegmentSize(uint64 offset, uint8_t segment_size);
+  virtual void UnexpectedSegmentSize(uint64_t offset, uint8_t segment_size);
 
   // The FDE at OFFSET refers to a CIE with version number VERSION,
   // which we don't recognize. We cannot parse DWARF CFI if it uses
   // a version number we don't recognize.
-  virtual void UnrecognizedVersion(uint64 offset, int version);
+  virtual void UnrecognizedVersion(uint64_t offset, int version);
 
   // The FDE at OFFSET refers to a CIE with augmentation AUGMENTATION,
   // which we don't recognize. We cannot parse DWARF CFI if it uses
   // augmentations we don't recognize.
-  virtual void UnrecognizedAugmentation(uint64 offset,
+  virtual void UnrecognizedAugmentation(uint64_t offset,
                                         const string &augmentation);
 
   // The pointer encoding ENCODING, specified by the CIE at OFFSET, is not
   // a valid encoding.
-  virtual void InvalidPointerEncoding(uint64 offset, uint8 encoding);
+  virtual void InvalidPointerEncoding(uint64_t offset, uint8_t encoding);
 
   // The pointer encoding ENCODING, specified by the CIE at OFFSET, depends
   // on a base address which has not been supplied.
-  virtual void UnusablePointerEncoding(uint64 offset, uint8 encoding);
+  virtual void UnusablePointerEncoding(uint64_t offset, uint8_t encoding);
 
   // The CIE at OFFSET contains a DW_CFA_restore instruction at
   // INSN_OFFSET, which may not appear in a CIE.
-  virtual void RestoreInCIE(uint64 offset, uint64 insn_offset);
+  virtual void RestoreInCIE(uint64_t offset, uint64_t insn_offset);
 
   // The entry at OFFSET, of kind KIND, has an unrecognized
   // instruction at INSN_OFFSET.
-  virtual void BadInstruction(uint64 offset, CallFrameInfo::EntryKind kind,
-                              uint64 insn_offset);
+  virtual void BadInstruction(uint64_t offset, CallFrameInfo::EntryKind kind,
+                              uint64_t insn_offset);
 
   // The instruction at INSN_OFFSET in the entry at OFFSET, of kind
   // KIND, establishes a rule that cites the CFA, but we have not
   // established a CFA rule yet.
-  virtual void NoCFARule(uint64 offset, CallFrameInfo::EntryKind kind, 
-                         uint64 insn_offset);
+  virtual void NoCFARule(uint64_t offset, CallFrameInfo::EntryKind kind, 
+                         uint64_t insn_offset);
 
   // The instruction at INSN_OFFSET in the entry at OFFSET, of kind
   // KIND, is a DW_CFA_restore_state instruction, but the stack of
   // saved states is empty.
-  virtual void EmptyStateStack(uint64 offset, CallFrameInfo::EntryKind kind, 
-                               uint64 insn_offset);
+  virtual void EmptyStateStack(uint64_t offset, CallFrameInfo::EntryKind kind, 
+                               uint64_t insn_offset);
 
   // The DW_CFA_remember_state instruction at INSN_OFFSET in the entry
   // at OFFSET, of kind KIND, would restore a state that has no CFA
   // rule, whereas the current state does have a CFA rule. This is
   // bogus input, which the CallFrameInfo::Handler interface doesn't
   // (and shouldn't) have any way to report.
-  virtual void ClearingCFARule(uint64 offset, CallFrameInfo::EntryKind kind, 
-                               uint64 insn_offset);
+  virtual void ClearingCFARule(uint64_t offset, CallFrameInfo::EntryKind kind, 
+                               uint64_t insn_offset);
 
  protected:
   // The name of the file whose CFI we're reading.
diff --git a/src/common/dwarf/dwarf2reader_cfi_unittest.cc b/src/common/dwarf/dwarf2reader_cfi_unittest.cc
index 35d4f340..5df6d8f0 100644
--- a/src/common/dwarf/dwarf2reader_cfi_unittest.cc
+++ b/src/common/dwarf/dwarf2reader_cfi_unittest.cc
@@ -99,23 +99,23 @@ void WriteELFFrameSection(const char *filename, const char *section_name,
 
 class MockCallFrameInfoHandler: public CallFrameInfo::Handler {
  public:
-  MOCK_METHOD6(Entry, bool(size_t offset, uint64 address, uint64 length,
-                           uint8 version, const string &augmentation,
+  MOCK_METHOD6(Entry, bool(size_t offset, uint64_t address, uint64_t length,
+                           uint8_t version, const string &augmentation,
                            unsigned return_address));
-  MOCK_METHOD2(UndefinedRule, bool(uint64 address, int reg));
-  MOCK_METHOD2(SameValueRule, bool(uint64 address, int reg));
-  MOCK_METHOD4(OffsetRule, bool(uint64 address, int reg, int base_register,
+  MOCK_METHOD2(UndefinedRule, bool(uint64_t address, int reg));
+  MOCK_METHOD2(SameValueRule, bool(uint64_t address, int reg));
+  MOCK_METHOD4(OffsetRule, bool(uint64_t address, int reg, int base_register,
                                 long offset));
-  MOCK_METHOD4(ValOffsetRule, bool(uint64 address, int reg, int base_register,
+  MOCK_METHOD4(ValOffsetRule, bool(uint64_t address, int reg, int base_register,
                                    long offset));
-  MOCK_METHOD3(RegisterRule, bool(uint64 address, int reg, int base_register));
-  MOCK_METHOD3(ExpressionRule, bool(uint64 address, int reg,
+  MOCK_METHOD3(RegisterRule, bool(uint64_t address, int reg, int base_register));
+  MOCK_METHOD3(ExpressionRule, bool(uint64_t address, int reg,
                                     const string &expression));
-  MOCK_METHOD3(ValExpressionRule, bool(uint64 address, int reg,
+  MOCK_METHOD3(ValExpressionRule, bool(uint64_t address, int reg,
                                        const string &expression));
   MOCK_METHOD0(End, bool());
-  MOCK_METHOD2(PersonalityRoutine, bool(uint64 address, bool indirect));
-  MOCK_METHOD2(LanguageSpecificDataArea, bool(uint64 address, bool indirect));
+  MOCK_METHOD2(PersonalityRoutine, bool(uint64_t address, bool indirect));
+  MOCK_METHOD2(LanguageSpecificDataArea, bool(uint64_t address, bool indirect));
   MOCK_METHOD0(SignalHandler, bool());
 };
 
@@ -806,13 +806,13 @@ struct CFIInsnFixture: public CFIFixture {
 
   Label cie_label;
   Sequence s;
-  uint64 code_factor;
+  uint64_t code_factor;
   int data_factor;
   unsigned return_register;
   unsigned version;
   unsigned cfa_base_register;
   int cfa_offset;
-  uint64 fde_start, fde_size;
+  uint64_t fde_start, fde_size;
 };
 
 class CFIInsn: public CFIInsnFixture, public Test { };
@@ -1448,7 +1448,7 @@ TEST_F(CFIInsn, DW_CFA_remember_and_restore_state) {
       .D8(dwarf2reader::DW_CFA_restore_state)
       .FinishEntry();
 
-  uint64 addr = fde_start;
+  uint64_t addr = fde_start;
 
   // Expect the incoming rules to be reported.
   EXPECT_CALL(handler, OffsetRule(addr, 2, kCFARegister, 0x9806 * data_factor))
diff --git a/src/common/dwarf/dwarf2reader_die_unittest.cc b/src/common/dwarf/dwarf2reader_die_unittest.cc
index 71418eb8..c7031a3a 100644
--- a/src/common/dwarf/dwarf2reader_die_unittest.cc
+++ b/src/common/dwarf/dwarf2reader_die_unittest.cc
@@ -73,36 +73,37 @@ using testing::_;
 
 class MockDwarf2Handler: public Dwarf2Handler {
  public:
-  MOCK_METHOD5(StartCompilationUnit, bool(uint64 offset, uint8 address_size,
-                                          uint8 offset_size, uint64 cu_length,
-                                          uint8 dwarf_version));
-  MOCK_METHOD2(StartDIE, bool(uint64 offset, enum DwarfTag tag));
-  MOCK_METHOD4(ProcessAttributeUnsigned, void(uint64 offset,
+  MOCK_METHOD5(StartCompilationUnit, bool(uint64_t offset, uint8_t address_size,
+                                          uint8_t offset_size,
+                                          uint64_t cu_length,
+                                          uint8_t dwarf_version));
+  MOCK_METHOD2(StartDIE, bool(uint64_t offset, enum DwarfTag tag));
+  MOCK_METHOD4(ProcessAttributeUnsigned, void(uint64_t offset,
                                               DwarfAttribute attr,
                                               enum DwarfForm form,
-                                              uint64 data));
-  MOCK_METHOD4(ProcessAttributeSigned, void(uint64 offset,
+                                              uint64_t data));
+  MOCK_METHOD4(ProcessAttributeSigned, void(uint64_t offset,
                                             enum DwarfAttribute attr,
                                             enum DwarfForm form,
                                             int64 data));
-  MOCK_METHOD4(ProcessAttributeReference, void(uint64 offset,
+  MOCK_METHOD4(ProcessAttributeReference, void(uint64_t offset,
                                                enum DwarfAttribute attr,
                                                enum DwarfForm form,
-                                               uint64 data));
-  MOCK_METHOD5(ProcessAttributeBuffer, void(uint64 offset,
+                                               uint64_t data));
+  MOCK_METHOD5(ProcessAttributeBuffer, void(uint64_t offset,
                                             enum DwarfAttribute attr,
                                             enum DwarfForm form,
                                             const uint8_t *data,
-                                            uint64 len));
-  MOCK_METHOD4(ProcessAttributeString, void(uint64 offset,
+                                            uint64_t len));
+  MOCK_METHOD4(ProcessAttributeString, void(uint64_t offset,
                                             enum DwarfAttribute attr,
                                             enum DwarfForm form,
                                             const string& data));
-  MOCK_METHOD4(ProcessAttributeSignature, void(uint64 offset,
+  MOCK_METHOD4(ProcessAttributeSignature, void(uint64_t offset,
                                                DwarfAttribute attr,
                                                enum DwarfForm form,
-                                               uint64 signature));
-  MOCK_METHOD1(EndDIE, void(uint64 offset));
+                                               uint64_t signature));
+  MOCK_METHOD1(EndDIE, void(uint64_t offset));
 };
 
 struct DIEFixture {
@@ -256,7 +257,7 @@ struct DwarfFormsFixture: public DIEFixture {
   // containing one childless DIE of the given tag, in the sequence s. Stop
   // just before the expectations.
   void ExpectBeginCompilationUnit(const DwarfHeaderParams &params,
-                                  DwarfTag tag, uint64 offset=0) {
+                                  DwarfTag tag, uint64_t offset=0) {
     EXPECT_CALL(handler,
                 StartCompilationUnit(offset, params.address_size,
                                      params.format_size, _,
@@ -274,7 +275,8 @@ struct DwarfFormsFixture: public DIEFixture {
         .WillOnce(Return());
   }
 
-  void ParseCompilationUnit(const DwarfHeaderParams &params, uint64 offset=0) {
+  void ParseCompilationUnit(const DwarfHeaderParams &params,
+                            uint64_t offset=0) {
     ByteReader byte_reader(params.endianness == kLittleEndian ?
                            ENDIANNESS_LITTLE : ENDIANNESS_BIG);
     CompilationUnit parser("", MakeSectionMap(), offset, &byte_reader, &handler);
diff --git a/src/common/dwarf/elf_reader.cc b/src/common/dwarf/elf_reader.cc
index 7dc46fd2..1b665213 100644
--- a/src/common/dwarf/elf_reader.cc
+++ b/src/common/dwarf/elf_reader.cc
@@ -446,8 +446,8 @@ class ElfReaderImpl {
   /*
   void GetSymbolPositions(SymbolMap *symbols,
                           typename ElfArch::Word section_type,
-                          uint64 mem_offset,
-                          uint64 file_offset) {
+                          uint64_t mem_offset,
+                          uint64_t file_offset) {
     // This map is used to filter out "nested" functions.
     // See comment below.
     AddrToSymMap addr_to_sym_map;
@@ -472,20 +472,20 @@ class ElfReaderImpl {
 
         // Adjust for difference between where we expected to mmap
         // this section, and where it was actually mmapped.
-        const int64 expected_base = hdr.sh_addr - hdr.sh_offset;
-        const int64 real_base = mem_offset - file_offset;
-        const int64 adjust = real_base - expected_base;
+        const int64_t expected_base = hdr.sh_addr - hdr.sh_offset;
+        const int64_t real_base = mem_offset - file_offset;
+        const int64_t adjust = real_base - expected_base;
 
-        uint64 start = sym->st_value + adjust;
+        uint64_t start = sym->st_value + adjust;
 
         // Adjust function symbols for PowerPC64 by dereferencing and adjusting
         // the function descriptor to get the function address.
         if (header_.e_machine == EM_PPC64 && ElfArch::Type(sym) == STT_FUNC) {
-          const uint64 opd_addr =
+          const uint64_t opd_addr =
               AdjustPPC64FunctionDescriptorSymbolValue(sym->st_value);
           // Only adjust the returned value if the function address was found.
           if (opd_addr != sym->st_value) {
-            const int64 adjust_function_symbols =
+            const int64_t adjust_function_symbols =
                 real_base - base_for_text_;
             start = opd_addr + adjust_function_symbols;
           }
@@ -530,8 +530,8 @@ class ElfReaderImpl {
                        curr->first, curr->second->st_size);
     typename AddrToSymMap::iterator prev = curr++;
     for (; curr != addr_to_sym_map.end(); ++curr) {
-      const uint64 prev_addr = prev->first;
-      const uint64 curr_addr = curr->first;
+      const uint64_t prev_addr = prev->first;
+      const uint64_t curr_addr = curr->first;
       const typename ElfArch::Sym *const prev_sym = prev->second;
       const typename ElfArch::Sym *const curr_sym = curr->second;
       if (prev_addr + prev_sym->st_size <= curr_addr ||
@@ -777,7 +777,7 @@ class ElfReaderImpl {
   // segments are present. This is the address an ELF image was linked
   // (by static linker) to be loaded at. Usually (but not always) 0 for
   // shared libraries and position-independent executables.
-  uint64 VaddrOfFirstLoadSegment() const {
+  uint64_t VaddrOfFirstLoadSegment() const {
     // Relocatable objects (of type ET_REL) do not have LOAD segments.
     if (header_.e_type == ET_REL) {
       return 0;
@@ -816,7 +816,7 @@ class ElfReaderImpl {
   }
 
  private:
-  typedef vector<pair<uint64, const typename ElfArch::Sym *> > AddrToSymMap;
+  typedef vector<pair<uint64_t, const typename ElfArch::Sym *> > AddrToSymMap;
 
   static bool AddrToSymSorter(const typename AddrToSymMap::value_type& lhs,
                               const typename AddrToSymMap::value_type& rhs) {
@@ -935,12 +935,12 @@ class ElfReaderImpl {
 
   // Given the "value" of a function descriptor return the address of the
   // function (i.e. the dereferenced value). Otherwise return "value".
-  uint64 AdjustPPC64FunctionDescriptorSymbolValue(uint64 value) {
+  uint64_t AdjustPPC64FunctionDescriptorSymbolValue(uint64_t value) {
     if (opd_section_ != NULL &&
         opd_info_.addr <= value &&
         value < opd_info_.addr + opd_info_.size) {
-      uint64 offset = value - opd_info_.addr;
-      return (*reinterpret_cast<const uint64*>(opd_section_ + offset));
+      uint64_t offset = value - opd_info_.addr;
+      return (*reinterpret_cast<const uint64_t*>(opd_section_ + offset));
     }
     return value;
   }
@@ -1001,7 +1001,7 @@ class ElfReaderImpl {
   // .opd section and are dereferenced to find the function address.
   ElfReader::SectionInfo opd_info_;
   const char *opd_section_;  // Must be checked for NULL before use.
-  int64 base_for_text_;
+  int64_t base_for_text_;
 
   // Read PLT-related sections for the current architecture.
   bool plts_supported_;
@@ -1014,7 +1014,7 @@ class ElfReaderImpl {
 
   // Maps a dynamic symbol index to a PLT offset.
   // The vector entry index is the dynamic symbol index.
-  std::vector<uint64> symbols_plt_offsets_;
+  std::vector<uint64_t> symbols_plt_offsets_;
 
   // Container for PLT function name strings. These strings are passed by
   // reference to SymbolSink::AddSymbol() so they need to be stored somewhere.
@@ -1087,8 +1087,8 @@ bool ElfReader::IsElf64File() const {
 
 /*
 void ElfReader::AddSymbols(SymbolMap *symbols,
-                           uint64 mem_offset, uint64 file_offset,
-                           uint64 length) {
+                           uint64_t mem_offset, uint64_t file_offset,
+                           uint64_t length) {
   if (fd_ < 0)
     return;
   // TODO(chatham): Actually use the information about file offset and
@@ -1138,7 +1138,7 @@ void ElfReader::VisitSymbols(ElfReader::SymbolSink *sink,
   }
 }
 
-uint64 ElfReader::VaddrOfFirstLoadSegment() {
+uint64_t ElfReader::VaddrOfFirstLoadSegment() {
   if (IsElf32File()) {
     return GetImpl32()->VaddrOfFirstLoadSegment();
   } else if (IsElf64File()) {
@@ -1159,7 +1159,7 @@ const char *ElfReader::GetSectionName(int shndx) {
   }
 }
 
-uint64 ElfReader::GetNumSections() {
+uint64_t ElfReader::GetNumSections() {
   if (IsElf32File()) {
     return GetImpl32()->GetNumSections();
   } else if (IsElf64File()) {
diff --git a/src/common/dwarf/elf_reader.h b/src/common/dwarf/elf_reader.h
index b1bb67a8..8eaa5aa9 100644
--- a/src/common/dwarf/elf_reader.h
+++ b/src/common/dwarf/elf_reader.h
@@ -63,13 +63,14 @@ class ElfReader {
   // file_offset - offset in the file where the mapping begins
   // length - length of the mapped segment
   void AddSymbols(SymbolMap *symbols,
-                  uint64 mem_offset, uint64 file_offset,
-                  uint64 length);
+                  uint64_t mem_offset, uint64_t file_offset,
+                  uint64_t length);
 
   class SymbolSink {
    public:
     virtual ~SymbolSink() {}
-    virtual void AddSymbol(const char *name, uint64 address, uint64 size) = 0;
+    virtual void AddSymbol(const char *name, uint64_t address,
+                           uint64_t size) = 0;
   };
 
   // Like AddSymbols above, but with no address correction.
@@ -90,14 +91,14 @@ class ElfReader {
   // segments are present. This is the address an ELF image was linked
   // (by static linker) to be loaded at. Usually (but not always) 0 for
   // shared libraries and position-independent executables.
-  uint64 VaddrOfFirstLoadSegment();
+  uint64_t VaddrOfFirstLoadSegment();
 
   // Return the name of section "shndx".  Returns NULL if the section
   // is not found.
   const char *GetSectionName(int shndx);
 
   // Return the number of sections in the given ELF file.
-  uint64 GetNumSections();
+  uint64_t GetNumSections();
 
   // Get section "shndx" from the given ELF file.  On success, return
   // the pointer to the section and store the size in "size".
@@ -118,15 +119,15 @@ class ElfReader {
   // here so that the many short macro names in <elf.h> don't have to be
   // added to our already cluttered namespace.
   struct SectionInfo {
-    uint32 type;                // Section type (SHT_xxx constant from elf.h).
-    uint64 flags;               // Section flags (SHF_xxx constants from elf.h).
-    uint64 addr;                // Section virtual address at execution.
-    uint64 offset;              // Section file offset.
-    uint64 size;                // Section size in bytes.
-    uint32 link;                // Link to another section.
-    uint32 info;                // Additional section information.
-    uint64 addralign;           // Section alignment.
-    uint64 entsize;             // Entry size if section holds a table.
+    uint32_t type;              // Section type (SHT_xxx constant from elf.h).
+    uint64_t flags;             // Section flags (SHF_xxx constants from elf.h).
+    uint64_t addr;              // Section virtual address at execution.
+    uint64_t offset;            // Section file offset.
+    uint64_t size;              // Section size in bytes.
+    uint32_t link;              // Link to another section.
+    uint32_t info;              // Additional section information.
+    uint64_t addralign;         // Section alignment.
+    uint64_t entsize;           // Entry size if section holds a table.
   };
   const char *GetSectionInfoByName(const string &section_name,
                                    SectionInfo *info);
diff --git a/src/common/dwarf/functioninfo.cc b/src/common/dwarf/functioninfo.cc
index ee198fc5..358a6eef 100644
--- a/src/common/dwarf/functioninfo.cc
+++ b/src/common/dwarf/functioninfo.cc
@@ -62,15 +62,15 @@ CULineInfoHandler::CULineInfoHandler(std::vector<SourceFileInfo>* files,
   files->push_back(s);
 }
 
-void CULineInfoHandler::DefineDir(const string& name, uint32 dir_num) {
+void CULineInfoHandler::DefineDir(const string& name, uint32_t dir_num) {
   // These should never come out of order, actually
   assert(dir_num == dirs_->size());
   dirs_->push_back(name);
 }
 
 void CULineInfoHandler::DefineFile(const string& name,
-                                   int32 file_num, uint32 dir_num,
-                                   uint64 mod_time, uint64 length) {
+                                   int32 file_num, uint32_t dir_num,
+                                   uint64_t mod_time, uint64_t length) {
   assert(dir_num >= 0);
   assert(dir_num < dirs_->size());
 
@@ -93,8 +93,9 @@ void CULineInfoHandler::DefineFile(const string& name,
   }
 }
 
-void CULineInfoHandler::AddLine(uint64 address, uint64 length, uint32 file_num,
-                                uint32 line_num, uint32 column_num) {
+void CULineInfoHandler::AddLine(uint64_t address, uint64_t length,
+                                uint32_t file_num, uint32_t line_num,
+                                uint32_t column_num) {
   if (file_num < files_->size()) {
     linemap_->insert(
         std::make_pair(address,
@@ -109,11 +110,11 @@ void CULineInfoHandler::AddLine(uint64 address, uint64 length, uint32 file_num,
   }
 }
 
-bool CUFunctionInfoHandler::StartCompilationUnit(uint64 offset,
-                                                 uint8 address_size,
-                                                 uint8 offset_size,
-                                                 uint64 cu_length,
-                                                 uint8 dwarf_version) {
+bool CUFunctionInfoHandler::StartCompilationUnit(uint64_t offset,
+                                                 uint8_t address_size,
+                                                 uint8_t offset_size,
+                                                 uint64_t cu_length,
+                                                 uint8_t dwarf_version) {
   current_compilation_unit_offset_ = offset;
   return true;
 }
@@ -123,7 +124,7 @@ bool CUFunctionInfoHandler::StartCompilationUnit(uint64 offset,
 // subroutines. For line info, the DW_AT_stmt_list lives in the
 // compile unit tag.
 
-bool CUFunctionInfoHandler::StartDIE(uint64 offset, enum DwarfTag tag) {
+bool CUFunctionInfoHandler::StartDIE(uint64_t offset, enum DwarfTag tag) {
   switch (tag) {
     case DW_TAG_subprogram:
     case DW_TAG_inlined_subroutine: {
@@ -146,7 +147,7 @@ bool CUFunctionInfoHandler::StartDIE(uint64 offset, enum DwarfTag tag) {
 
 // Only care about the name attribute for functions
 
-void CUFunctionInfoHandler::ProcessAttributeString(uint64 offset,
+void CUFunctionInfoHandler::ProcessAttributeString(uint64_t offset,
                                                    enum DwarfAttribute attr,
                                                    enum DwarfForm form,
                                                    const string &data) {
@@ -158,10 +159,10 @@ void CUFunctionInfoHandler::ProcessAttributeString(uint64 offset,
   }
 }
 
-void CUFunctionInfoHandler::ProcessAttributeUnsigned(uint64 offset,
+void CUFunctionInfoHandler::ProcessAttributeUnsigned(uint64_t offset,
                                                      enum DwarfAttribute attr,
                                                      enum DwarfForm form,
-                                                     uint64 data) {
+                                                     uint64_t data) {
   if (attr == DW_AT_stmt_list) {
     SectionMap::const_iterator iter = sections_.find("__debug_line");
     assert(iter != sections_.end());
@@ -193,10 +194,10 @@ void CUFunctionInfoHandler::ProcessAttributeUnsigned(uint64 offset,
   }
 }
 
-void CUFunctionInfoHandler::ProcessAttributeReference(uint64 offset,
+void CUFunctionInfoHandler::ProcessAttributeReference(uint64_t offset,
                                                       enum DwarfAttribute attr,
                                                       enum DwarfForm form,
-                                                      uint64 data) {
+                                                      uint64_t data) {
   if (current_function_info_) {
     switch (attr) {
       case DW_AT_specification: {
@@ -225,7 +226,7 @@ void CUFunctionInfoHandler::ProcessAttributeReference(uint64 offset,
   }
 }
 
-void CUFunctionInfoHandler::EndDIE(uint64 offset) {
+void CUFunctionInfoHandler::EndDIE(uint64_t offset) {
   if (current_function_info_ && current_function_info_->lowpc)
     address_to_funcinfo_->insert(std::make_pair(current_function_info_->lowpc,
                                                 current_function_info_));
diff --git a/src/common/dwarf/functioninfo.h b/src/common/dwarf/functioninfo.h
index 9efae6d4..5c733c6d 100644
--- a/src/common/dwarf/functioninfo.h
+++ b/src/common/dwarf/functioninfo.h
@@ -53,20 +53,20 @@ struct FunctionInfo {
   // File containing this function
   string file;
   // Line number for start of function.
-  uint32 line;
+  uint32_t line;
   // Beginning address for this function
-  uint64 lowpc;
+  uint64_t lowpc;
   // End address for this function.
-  uint64 highpc;
+  uint64_t highpc;
   // Ranges offset
-  uint64 ranges;
+  uint64_t ranges;
 };
 
 struct SourceFileInfo {
   // Name of the source file name
   string name;
   // Low address of source file name
-  uint64 lowpc;
+  uint64_t lowpc;
 };
 
 typedef std::map<uint64, FunctionInfo*> FunctionMap;
@@ -86,12 +86,12 @@ class CULineInfoHandler: public LineInfoHandler {
 
   // Called when we define a directory.  We just place NAME into dirs_
   // at position DIR_NUM.
-  virtual void DefineDir(const string& name, uint32 dir_num);
+  virtual void DefineDir(const string& name, uint32_t dir_num);
 
   // Called when we define a filename.  We just place
   // concat(dirs_[DIR_NUM], NAME) into files_ at position FILE_NUM.
   virtual void DefineFile(const string& name, int32 file_num,
-                          uint32 dir_num, uint64 mod_time, uint64 length);
+                          uint32_t dir_num, uint64_t mod_time, uint64_t length);
 
 
   // Called when the line info reader has a new line, address pair
@@ -100,8 +100,9 @@ class CULineInfoHandler: public LineInfoHandler {
   // containing the code, LINE_NUM is the line number in that file for
   // the code, and COLUMN_NUM is the column number the code starts at,
   // if we know it (0 otherwise).
-  virtual void AddLine(uint64 address, uint64 length,
-                       uint32 file_num, uint32 line_num, uint32 column_num);
+  virtual void AddLine(uint64_t address, uint64_t length,
+                       uint32_t file_num, uint32_t line_num,
+                       uint32_t column_num);
 
  private:
   LineMap* linemap_;
@@ -131,38 +132,38 @@ class CUFunctionInfoHandler: public Dwarf2Handler {
   // .debug_info section.  We want to see all compilation units, so we
   // always return true.
 
-  virtual bool StartCompilationUnit(uint64 offset, uint8 address_size,
-                                    uint8 offset_size, uint64 cu_length,
-                                    uint8 dwarf_version);
+  virtual bool StartCompilationUnit(uint64_t offset, uint8_t address_size,
+                                    uint8_t offset_size, uint64_t cu_length,
+                                    uint8_t dwarf_version);
 
   // Start to process a DIE at OFFSET from the beginning of the
   // .debug_info section.  We only care about function related DIE's.
-  virtual bool StartDIE(uint64 offset, enum DwarfTag tag);
+  virtual bool StartDIE(uint64_t offset, enum DwarfTag tag);
 
   // Called when we have an attribute with unsigned data to give to
   // our handler.  The attribute is for the DIE at OFFSET from the
   // beginning of the .debug_info section, has a name of ATTR, a form of
   // FORM, and the actual data of the attribute is in DATA.
-  virtual void ProcessAttributeUnsigned(uint64 offset,
+  virtual void ProcessAttributeUnsigned(uint64_t offset,
                                         enum DwarfAttribute attr,
                                         enum DwarfForm form,
-                                        uint64 data);
+                                        uint64_t data);
 
   // Called when we have an attribute with a DIE reference to give to
   // our handler.  The attribute is for the DIE at OFFSET from the
   // beginning of the .debug_info section, has a name of ATTR, a form of
   // FORM, and the offset of the referenced DIE from the start of the
   // .debug_info section is in DATA.
-  virtual void ProcessAttributeReference(uint64 offset,
+  virtual void ProcessAttributeReference(uint64_t offset,
                                          enum DwarfAttribute attr,
                                          enum DwarfForm form,
-                                         uint64 data);
+                                         uint64_t data);
 
   // Called when we have an attribute with string data to give to
   // our handler.  The attribute is for the DIE at OFFSET from the
   // beginning of the .debug_info section, has a name of ATTR, a form of
   // FORM, and the actual data of the attribute is in DATA.
-  virtual void ProcessAttributeString(uint64 offset,
+  virtual void ProcessAttributeString(uint64_t offset,
                                       enum DwarfAttribute attr,
                                       enum DwarfForm form,
                                       const string& data);
@@ -171,7 +172,7 @@ class CUFunctionInfoHandler: public Dwarf2Handler {
   // Because DWARF2/3 specifies a tree of DIEs, you may get starts
   // before ends of the previous DIE, as we process children before
   // ending the parent.
-  virtual void EndDIE(uint64 offset);
+  virtual void EndDIE(uint64_t offset);
 
  private:
   std::vector<SourceFileInfo>* files_;
@@ -183,7 +184,7 @@ class CUFunctionInfoHandler: public Dwarf2Handler {
   const SectionMap& sections_;
   ByteReader* reader_;
   FunctionInfo* current_function_info_;
-  uint64 current_compilation_unit_offset_;
+  uint64_t current_compilation_unit_offset_;
 };
 
 }  // namespace dwarf2reader
diff --git a/src/common/dwarf/line_state_machine.h b/src/common/dwarf/line_state_machine.h
index 0ff72abc..fc301c76 100644
--- a/src/common/dwarf/line_state_machine.h
+++ b/src/common/dwarf/line_state_machine.h
@@ -46,10 +46,10 @@ struct LineStateMachine {
     end_sequence = false;
   }
 
-  uint32 file_num;
-  uint64 address;
-  uint32 line_num;
-  uint32 column_num;
+  uint32_t file_num;
+  uint64_t address;
+  uint32_t line_num;
+  uint32_t column_num;
   bool is_stmt;  // stmt means statement.
   bool basic_block;
   bool end_sequence;
diff --git a/src/common/dwarf/types.h b/src/common/dwarf/types.h
index 59dda316..23412d0e 100644
--- a/src/common/dwarf/types.h
+++ b/src/common/dwarf/types.h
@@ -35,16 +35,6 @@
 
 #include <stdint.h>
 
-typedef signed char         int8;
-typedef short               int16;
-typedef int                 int32;
-typedef long long           int64;
-
-typedef unsigned char      uint8;
-typedef unsigned short     uint16;
-typedef unsigned int       uint32;
-typedef unsigned long long uint64;
-
 typedef intptr_t           intptr;
 typedef uintptr_t          uintptr;