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>
diff --git a/src/common/dwarf/bytereader-inl.h b/src/common/dwarf/bytereader-inl.h
index 42c92f9..f4c068a 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 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::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 @@
// 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 @@
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 @@
// 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 @@
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 14b43ad..0b27dd5 100644
--- a/src/common/dwarf/bytereader.cc
+++ b/src/common/dwarf/bytereader.cc
@@ -43,7 +43,7 @@
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::SetAddressSize(uint8 size) {
+void ByteReader::SetAddressSize(uint8_t size) {
address_size_ = size;
assert(size == 4 || size == 8);
if (size == 4) {
@@ -63,8 +63,8 @@
}
}
-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 @@
}
}
-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 @@
// 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 @@
// 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 @@
}
// Find the appropriate base address.
- uint64 base;
+ uint64_t base;
switch (encoding & 0x70) {
case DW_EH_PE_absptr:
base = 0;
@@ -232,13 +232,13 @@
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 59d4303..2b37a12 100644
--- a/src/common/dwarf/bytereader.h
+++ b/src/common/dwarf/bytereader.h
@@ -62,22 +62,22 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// - 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 @@
// 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 @@
// 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 @@
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 @@
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 94542b5..6384501 100644
--- a/src/common/dwarf/dwarf2diehandler.cc
+++ b/src/common/dwarf/dwarf2diehandler.cc
@@ -50,15 +50,15 @@
}
}
-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 @@
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 @@
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 ¤t = 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 ¤t = 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 ¤t = 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 ¤t = 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 @@
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 ¤t = 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 a1e589a..871ba43 100644
--- a/src/common/dwarf/dwarf2diehandler.h
+++ b/src/common/dwarf/dwarf2diehandler.h
@@ -199,23 +199,23 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 3e6a3e8..e615fc4 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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
// 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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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::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 @@
// 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 @@
}
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 @@
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 @@
// 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 @@
}
}
-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 @@
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 @@
header_.std_opcode_lengths = NULL;
}
-uint64 LineInfo::Start() {
+uint64_t LineInfo::Start() {
ReadHeader();
ReadLines();
return after_header_ - buffer_;
@@ -922,7 +922,7 @@
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 @@
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 @@
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 @@
// 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 @@
// 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 *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 @@
// 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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
// 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 @@
// 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 @@
// 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 @@
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 @@
// 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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 902d9ef..0b194c1 100644
--- a/src/common/dwarf/dwarf2reader.h
+++ b/src/common/dwarf/dwarf2reader.h
@@ -63,21 +63,21 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
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 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
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 @@
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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 35d4f34..5df6d8f 100644
--- a/src/common/dwarf/dwarf2reader_cfi_unittest.cc
+++ b/src/common/dwarf/dwarf2reader_cfi_unittest.cc
@@ -99,23 +99,23 @@
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 @@
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 @@
.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 71418eb..c7031a3 100644
--- a/src/common/dwarf/dwarf2reader_die_unittest.cc
+++ b/src/common/dwarf/dwarf2reader_die_unittest.cc
@@ -73,36 +73,37 @@
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 @@
// containing one childless DIE of the given tag, in the sequence s. Stop
// just before the expectations.
void ExpectBeginCompilationUnit(const DwarfHeaderParams ¶ms,
- 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 @@
.WillOnce(Return());
}
- void ParseCompilationUnit(const DwarfHeaderParams ¶ms, uint64 offset=0) {
+ void ParseCompilationUnit(const DwarfHeaderParams ¶ms,
+ 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 7dc46fd..1b66521 100644
--- a/src/common/dwarf/elf_reader.cc
+++ b/src/common/dwarf/elf_reader.cc
@@ -446,8 +446,8 @@
/*
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 @@
// 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 @@
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 @@
// 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 @@
}
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 @@
// 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 @@
// .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 @@
// 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 @@
/*
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 @@
}
}
-uint64 ElfReader::VaddrOfFirstLoadSegment() {
+uint64_t ElfReader::VaddrOfFirstLoadSegment() {
if (IsElf32File()) {
return GetImpl32()->VaddrOfFirstLoadSegment();
} else if (IsElf64File()) {
@@ -1159,7 +1159,7 @@
}
}
-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 b1bb67a..8eaa5aa 100644
--- a/src/common/dwarf/elf_reader.h
+++ b/src/common/dwarf/elf_reader.h
@@ -63,13 +63,14 @@
// 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 @@
// 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 @@
// 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 §ion_name,
SectionInfo *info);
diff --git a/src/common/dwarf/functioninfo.cc b/src/common/dwarf/functioninfo.cc
index ee198fc..358a6ee 100644
--- a/src/common/dwarf/functioninfo.cc
+++ b/src/common/dwarf/functioninfo.cc
@@ -62,15 +62,15 @@
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::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 @@
}
}
-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 @@
// 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 @@
// 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::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::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::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 9efae6d..5c733c6 100644
--- a/src/common/dwarf/functioninfo.h
+++ b/src/common/dwarf/functioninfo.h
@@ -53,20 +53,20 @@
// 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 @@
// 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 @@
// 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 @@
// .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 @@
// 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 @@
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 0ff72ab..fc301c7 100644
--- a/src/common/dwarf/line_state_machine.h
+++ b/src/common/dwarf/line_state_machine.h
@@ -46,10 +46,10 @@
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 59dda31..23412d0 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;
diff --git a/src/common/dwarf_cfi_to_module.cc b/src/common/dwarf_cfi_to_module.cc
index bd298a2..3dd85ed 100644
--- a/src/common/dwarf_cfi_to_module.cc
+++ b/src/common/dwarf_cfi_to_module.cc
@@ -142,8 +142,8 @@
sizeof(kRegisterNames) / sizeof(kRegisterNames[0]));
}
-bool DwarfCFIToModule::Entry(size_t offset, uint64 address, uint64 length,
- uint8 version, const string &augmentation,
+bool DwarfCFIToModule::Entry(size_t offset, uint64_t address, uint64_t length,
+ uint8_t version, const string &augmentation,
unsigned return_address) {
assert(!entry_);
@@ -209,20 +209,20 @@
entry_->rule_changes[address][RegisterName(reg)] = shared_rule;
}
-bool DwarfCFIToModule::UndefinedRule(uint64 address, int reg) {
+bool DwarfCFIToModule::UndefinedRule(uint64_t address, int reg) {
reporter_->UndefinedNotSupported(entry_offset_, RegisterName(reg));
// Treat this as a non-fatal error.
return true;
}
-bool DwarfCFIToModule::SameValueRule(uint64 address, int reg) {
+bool DwarfCFIToModule::SameValueRule(uint64_t address, int reg) {
ostringstream s;
s << RegisterName(reg);
Record(address, reg, s.str());
return true;
}
-bool DwarfCFIToModule::OffsetRule(uint64 address, int reg,
+bool DwarfCFIToModule::OffsetRule(uint64_t address, int reg,
int base_register, long offset) {
ostringstream s;
s << RegisterName(base_register) << " " << offset << " + ^";
@@ -230,7 +230,7 @@
return true;
}
-bool DwarfCFIToModule::ValOffsetRule(uint64 address, int reg,
+bool DwarfCFIToModule::ValOffsetRule(uint64_t address, int reg,
int base_register, long offset) {
ostringstream s;
s << RegisterName(base_register) << " " << offset << " +";
@@ -238,7 +238,7 @@
return true;
}
-bool DwarfCFIToModule::RegisterRule(uint64 address, int reg,
+bool DwarfCFIToModule::RegisterRule(uint64_t address, int reg,
int base_register) {
ostringstream s;
s << RegisterName(base_register);
@@ -246,14 +246,14 @@
return true;
}
-bool DwarfCFIToModule::ExpressionRule(uint64 address, int reg,
+bool DwarfCFIToModule::ExpressionRule(uint64_t address, int reg,
const string &expression) {
reporter_->ExpressionsNotSupported(entry_offset_, RegisterName(reg));
// Treat this as a non-fatal error.
return true;
}
-bool DwarfCFIToModule::ValExpressionRule(uint64 address, int reg,
+bool DwarfCFIToModule::ValExpressionRule(uint64_t address, int reg,
const string &expression) {
reporter_->ExpressionsNotSupported(entry_offset_, RegisterName(reg));
// Treat this as a non-fatal error.
diff --git a/src/common/dwarf_cfi_to_module.h b/src/common/dwarf_cfi_to_module.h
index a5302e1..4d2db7e 100644
--- a/src/common/dwarf_cfi_to_module.h
+++ b/src/common/dwarf_cfi_to_module.h
@@ -137,19 +137,19 @@
}
virtual ~DwarfCFIToModule() { delete entry_; }
- 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);
- virtual bool UndefinedRule(uint64 address, int reg);
- virtual bool SameValueRule(uint64 address, int reg);
- virtual bool OffsetRule(uint64 address, int reg,
+ virtual bool UndefinedRule(uint64_t address, int reg);
+ virtual bool SameValueRule(uint64_t address, int reg);
+ virtual bool OffsetRule(uint64_t address, int reg,
int base_register, long offset);
- virtual bool ValOffsetRule(uint64 address, int reg,
+ virtual bool ValOffsetRule(uint64_t address, int reg,
int base_register, long offset);
- virtual bool RegisterRule(uint64 address, int reg, int base_register);
- virtual bool ExpressionRule(uint64 address, int reg,
+ virtual bool RegisterRule(uint64_t address, int reg, int base_register);
+ virtual bool ExpressionRule(uint64_t address, int reg,
const string &expression);
- virtual bool ValExpressionRule(uint64 address, int reg,
+ virtual bool ValExpressionRule(uint64_t address, int reg,
const string &expression);
virtual bool End();
diff --git a/src/common/dwarf_cfi_to_module_unittest.cc b/src/common/dwarf_cfi_to_module_unittest.cc
index 807d1b2..60a9a3e 100644
--- a/src/common/dwarf_cfi_to_module_unittest.cc
+++ b/src/common/dwarf_cfi_to_module_unittest.cc
@@ -125,7 +125,7 @@
EXPECT_EQ(entry_address, entries[0]->address);
EXPECT_EQ(entry_size, entries[0]->size);
}
- uint64 entry_address, entry_size;
+ uint64_t entry_address, entry_size;
unsigned return_reg;
};
diff --git a/src/common/dwarf_cu_to_module.cc b/src/common/dwarf_cu_to_module.cc
index 56399c3..161b9e1 100644
--- a/src/common/dwarf_cu_to_module.cc
+++ b/src/common/dwarf_cu_to_module.cc
@@ -95,7 +95,7 @@
string name;
};
-typedef map<uint64, AbstractOrigin> AbstractOriginByOffset;
+typedef map<uint64_t, AbstractOrigin> AbstractOriginByOffset;
// Data global to the DWARF-bearing file that is private to the
// DWARF-to-Module process.
@@ -140,7 +140,7 @@
}
void DwarfCUToModule::FileContext::AddSectionToSectionMap(
- const string& name, const uint8_t *contents, uint64 length) {
+ const string& name, const uint8_t *contents, uint64_t length) {
section_map_[name] = std::make_pair(contents, length);
}
@@ -159,7 +159,7 @@
}
bool DwarfCUToModule::FileContext::IsUnhandledInterCUReference(
- uint64 offset, uint64 compilation_unit_start) const {
+ uint64_t offset, uint64_t compilation_unit_start) const {
if (handle_inter_cu_refs_)
return false;
return offset < compilation_unit_start;
@@ -201,9 +201,9 @@
// Addresses covered by this CU. If high_pc_ is non-zero then the CU covers
// low_pc to high_pc, otherwise ranges is non-zero and low_pc represents
// the base address of the ranges covered by the CU.
- uint64 low_pc;
- uint64 high_pc;
- uint64 ranges;
+ uint64_t low_pc;
+ uint64_t high_pc;
+ uint64_t ranges;
// The functions defined in this compilation unit. We accumulate
// them here during parsing. Then, in DwarfCUToModule::Finish, we
@@ -241,7 +241,7 @@
// described by CU_CONTEXT, and whose immediate context is described
// by PARENT_CONTEXT.
GenericDIEHandler(CUContext *cu_context, DIEContext *parent_context,
- uint64 offset)
+ uint64_t offset)
: cu_context_(cu_context),
parent_context_(parent_context),
offset_(offset),
@@ -253,13 +253,13 @@
// handle DW_AT_declaration, or simply not override it.
void ProcessAttributeUnsigned(enum DwarfAttribute attr,
enum DwarfForm form,
- uint64 data);
+ uint64_t data);
// Derived classes' ProcessAttributeReference can defer to this to
// handle DW_AT_specification, or simply not override it.
void ProcessAttributeReference(enum DwarfAttribute attr,
enum DwarfForm form,
- uint64 data);
+ uint64_t data);
// Derived classes' ProcessAttributeReference can defer to this to
// handle DW_AT_specification, or simply not override it.
@@ -280,7 +280,7 @@
CUContext *cu_context_;
DIEContext *parent_context_;
- uint64 offset_;
+ uint64_t offset_;
// Place the name in the global set of strings. Even though this looks
// like a copy, all the major string implementations use reference
@@ -321,7 +321,7 @@
void DwarfCUToModule::GenericDIEHandler::ProcessAttributeUnsigned(
enum DwarfAttribute attr,
enum DwarfForm form,
- uint64 data) {
+ uint64_t data) {
switch (attr) {
case dwarf2reader::DW_AT_declaration: declaration_ = (data != 0); break;
default: break;
@@ -331,7 +331,7 @@
void DwarfCUToModule::GenericDIEHandler::ProcessAttributeReference(
enum DwarfAttribute attr,
enum DwarfForm form,
- uint64 data) {
+ uint64_t data) {
switch (attr) {
case dwarf2reader::DW_AT_specification: {
FileContext *file_context = cu_context_->file_context;
@@ -466,19 +466,19 @@
class DwarfCUToModule::FuncHandler: public GenericDIEHandler {
public:
FuncHandler(CUContext *cu_context, DIEContext *parent_context,
- uint64 offset)
+ uint64_t offset)
: GenericDIEHandler(cu_context, parent_context, offset),
low_pc_(0), high_pc_(0), high_pc_form_(dwarf2reader::DW_FORM_addr),
ranges_(0), abstract_origin_(NULL), inline_(false) { }
void ProcessAttributeUnsigned(enum DwarfAttribute attr,
enum DwarfForm form,
- uint64 data);
+ uint64_t data);
void ProcessAttributeSigned(enum DwarfAttribute attr,
enum DwarfForm form,
- int64 data);
+ int64_t data);
void ProcessAttributeReference(enum DwarfAttribute attr,
enum DwarfForm form,
- uint64 data);
+ uint64_t data);
bool EndAttributes();
void Finish();
@@ -487,9 +487,9 @@
// The fully-qualified name, as derived from name_attribute_,
// specification_, parent_context_. Computed in EndAttributes.
string name_;
- uint64 low_pc_, high_pc_; // DW_AT_low_pc, DW_AT_high_pc
+ uint64_t low_pc_, high_pc_; // DW_AT_low_pc, DW_AT_high_pc
DwarfForm high_pc_form_; // DW_AT_high_pc can be length or address.
- uint64 ranges_; // DW_AT_ranges
+ uint64_t ranges_; // DW_AT_ranges
const AbstractOrigin* abstract_origin_;
bool inline_;
};
@@ -497,7 +497,7 @@
void DwarfCUToModule::FuncHandler::ProcessAttributeUnsigned(
enum DwarfAttribute attr,
enum DwarfForm form,
- uint64 data) {
+ uint64_t data) {
switch (attr) {
// If this attribute is present at all --- even if its value is
// DW_INL_not_inlined --- then GCC may cite it as someone else's
@@ -522,7 +522,7 @@
void DwarfCUToModule::FuncHandler::ProcessAttributeSigned(
enum DwarfAttribute attr,
enum DwarfForm form,
- int64 data) {
+ int64_t data) {
switch (attr) {
// If this attribute is present at all --- even if its value is
// DW_INL_not_inlined --- then GCC may cite it as someone else's
@@ -537,7 +537,7 @@
void DwarfCUToModule::FuncHandler::ProcessAttributeReference(
enum DwarfAttribute attr,
enum DwarfForm form,
- uint64 data) {
+ uint64_t data) {
switch (attr) {
case dwarf2reader::DW_AT_abstract_origin: {
const AbstractOriginByOffset& origins =
@@ -568,8 +568,8 @@
}
static bool IsEmptyRange(const vector<Module::Range>& ranges) {
- uint64 size = accumulate(ranges.cbegin(), ranges.cend(), 0,
- [](uint64 total, Module::Range entry) {
+ uint64_t size = accumulate(ranges.cbegin(), ranges.cend(), 0,
+ [](uint64_t total, Module::Range entry) {
return total + entry.size;
}
);
@@ -663,10 +663,10 @@
class DwarfCUToModule::NamedScopeHandler: public GenericDIEHandler {
public:
NamedScopeHandler(CUContext *cu_context, DIEContext *parent_context,
- uint64 offset)
+ uint64_t offset)
: GenericDIEHandler(cu_context, parent_context, offset) { }
bool EndAttributes();
- DIEHandler *FindChildHandler(uint64 offset, enum DwarfTag tag);
+ DIEHandler *FindChildHandler(uint64_t offset, enum DwarfTag tag);
private:
DIEContext child_context_; // A context for our children.
@@ -678,7 +678,7 @@
}
dwarf2reader::DIEHandler *DwarfCUToModule::NamedScopeHandler::FindChildHandler(
- uint64 offset,
+ uint64_t offset,
enum DwarfTag tag) {
switch (tag) {
case dwarf2reader::DW_TAG_subprogram:
@@ -701,8 +701,8 @@
printed_cu_header_ = true;
}
-void DwarfCUToModule::WarningReporter::UnknownSpecification(uint64 offset,
- uint64 target) {
+void DwarfCUToModule::WarningReporter::UnknownSpecification(uint64_t offset,
+ uint64_t target) {
CUHeading();
fprintf(stderr, "%s: the DIE at offset 0x%llx has a DW_AT_specification"
" attribute referring to the DIE at offset 0x%llx, which was not"
@@ -710,8 +710,8 @@
filename_.c_str(), offset, target);
}
-void DwarfCUToModule::WarningReporter::UnknownAbstractOrigin(uint64 offset,
- uint64 target) {
+void DwarfCUToModule::WarningReporter::UnknownAbstractOrigin(uint64_t offset,
+ uint64_t target) {
CUHeading();
fprintf(stderr, "%s: the DIE at offset 0x%llx has a DW_AT_abstract_origin"
" attribute referring to the DIE at offset 0x%llx, which was not"
@@ -725,7 +725,7 @@
filename_.c_str(), name.c_str());
}
-void DwarfCUToModule::WarningReporter::BadLineInfoOffset(uint64 offset) {
+void DwarfCUToModule::WarningReporter::BadLineInfoOffset(uint64_t offset) {
CUHeading();
fprintf(stderr, "%s: warning: line number data offset beyond end"
" of '.debug_line' section\n",
@@ -760,7 +760,7 @@
line.file->name.c_str(), line.number, line.address);
}
-void DwarfCUToModule::WarningReporter::UnnamedFunction(uint64 offset) {
+void DwarfCUToModule::WarningReporter::UnnamedFunction(uint64_t offset) {
CUHeading();
fprintf(stderr, "%s: warning: function at offset 0x%llx has no name\n",
filename_.c_str(), offset);
@@ -773,7 +773,7 @@
}
void DwarfCUToModule::WarningReporter::UnhandledInterCUReference(
- uint64 offset, uint64 target) {
+ uint64_t offset, uint64_t target) {
CUHeading();
fprintf(stderr, "%s: warning: the DIE at offset 0x%llx has a "
"DW_FORM_ref_addr attribute with an inter-CU reference to "
@@ -781,7 +781,7 @@
filename_.c_str(), offset, target);
}
-void DwarfCUToModule::WarningReporter::MalformedRangeList(uint64 offset) {
+void DwarfCUToModule::WarningReporter::MalformedRangeList(uint64_t offset) {
CUHeading();
fprintf(stderr, "%s: warning: the range list at offset 0x%llx falls out of "
"the .debug_ranges section.\n",
@@ -809,7 +809,7 @@
void DwarfCUToModule::ProcessAttributeSigned(enum DwarfAttribute attr,
enum DwarfForm form,
- int64 data) {
+ int64_t data) {
switch (attr) {
case dwarf2reader::DW_AT_language: // source language of this CU
SetLanguage(static_cast<DwarfLanguage>(data));
@@ -821,7 +821,7 @@
void DwarfCUToModule::ProcessAttributeUnsigned(enum DwarfAttribute attr,
enum DwarfForm form,
- uint64 data) {
+ uint64_t data) {
switch (attr) {
case dwarf2reader::DW_AT_stmt_list: // Line number information.
has_source_line_info_ = true;
@@ -865,7 +865,7 @@
}
dwarf2reader::DIEHandler *DwarfCUToModule::FindChildHandler(
- uint64 offset,
+ uint64_t offset,
enum DwarfTag tag) {
switch (tag) {
case dwarf2reader::DW_TAG_subprogram:
@@ -925,7 +925,7 @@
}
}
-void DwarfCUToModule::ReadSourceLines(uint64 offset) {
+void DwarfCUToModule::ReadSourceLines(uint64_t offset) {
const dwarf2reader::SectionMap §ion_map
= cu_context_->file_context->section_map();
dwarf2reader::SectionMap::const_iterator map_entry
@@ -939,7 +939,7 @@
return;
}
const uint8_t *section_start = map_entry->second.first;
- uint64 section_length = map_entry->second.second;
+ uint64_t section_length = map_entry->second.second;
if (offset >= section_length) {
cu_context_->reporter->BadLineInfoOffset(offset);
return;
@@ -1226,15 +1226,15 @@
cu_context_->file_context->ClearSpecifications();
}
-bool DwarfCUToModule::StartCompilationUnit(uint64 offset,
- uint8 address_size,
- uint8 offset_size,
- uint64 cu_length,
- uint8 dwarf_version) {
+bool DwarfCUToModule::StartCompilationUnit(uint64_t offset,
+ uint8_t address_size,
+ uint8_t offset_size,
+ uint64_t cu_length,
+ uint8_t dwarf_version) {
return dwarf_version >= 2;
}
-bool DwarfCUToModule::StartRootDIE(uint64 offset, enum DwarfTag tag) {
+bool DwarfCUToModule::StartRootDIE(uint64_t offset, enum DwarfTag tag) {
// We don't deal with partial compilation units (the only other tag
// likely to be used for root DIE).
return tag == dwarf2reader::DW_TAG_compile_unit;
diff --git a/src/common/dwarf_cu_to_module.h b/src/common/dwarf_cu_to_module.h
index f73a3c9..2153bd9 100644
--- a/src/common/dwarf_cu_to_module.h
+++ b/src/common/dwarf_cu_to_module.h
@@ -87,7 +87,7 @@
// Add CONTENTS of size LENGTH to the section map as NAME.
void AddSectionToSectionMap(const string& name,
const uint8_t *contents,
- uint64 length);
+ uint64_t length);
// Clear the section map for testing.
void ClearSectionMapForTest();
@@ -103,8 +103,8 @@
// Given an OFFSET and a CU that starts at COMPILATION_UNIT_START, returns
// true if this is an inter-compilation unit reference that is not being
// handled.
- bool IsUnhandledInterCUReference(uint64 offset,
- uint64 compilation_unit_start) const;
+ bool IsUnhandledInterCUReference(uint64_t offset,
+ uint64_t compilation_unit_start) const;
// The name of this file, for use in error messages.
const string filename_;
@@ -135,7 +135,7 @@
// section, base_address holds the base PC the range list values are
// offsets off. Return false if the rangelist falls out of the
// .debug_ranges section.
- virtual bool ReadRanges(uint64 offset, Module::Address base_address,
+ virtual bool ReadRanges(uint64_t offset, Module::Address base_address,
vector<Module::Range>* ranges) = 0;
};
@@ -158,7 +158,7 @@
// mappings, given a pointer to some DWARF line number data
// PROGRAM, and an overestimate of its size. Add no zero-length
// lines to LINES.
- virtual void ReadProgram(const uint8_t *program, uint64 length,
+ virtual void ReadProgram(const uint8_t *program, uint64_t length,
Module *module, vector<Module::Line> *lines) = 0;
};
@@ -170,7 +170,7 @@
public:
// Warn about problems in the DWARF file FILENAME, in the
// compilation unit at OFFSET.
- WarningReporter(const string &filename, uint64 cu_offset)
+ WarningReporter(const string &filename, uint64_t cu_offset)
: filename_(filename), cu_offset_(cu_offset), printed_cu_header_(false),
printed_unpaired_header_(false),
uncovered_warnings_enabled_(false) { }
@@ -193,17 +193,17 @@
// A DW_AT_specification in the DIE at OFFSET refers to a DIE we
// haven't processed yet, or that wasn't marked as a declaration,
// at TARGET.
- virtual void UnknownSpecification(uint64 offset, uint64 target);
+ virtual void UnknownSpecification(uint64_t offset, uint64_t target);
// A DW_AT_abstract_origin in the DIE at OFFSET refers to a DIE we
// haven't processed yet, or that wasn't marked as inline, at TARGET.
- virtual void UnknownAbstractOrigin(uint64 offset, uint64 target);
+ virtual void UnknownAbstractOrigin(uint64_t offset, uint64_t target);
// We were unable to find the DWARF section named SECTION_NAME.
virtual void MissingSection(const string §ion_name);
// The CU's DW_AT_stmt_list offset OFFSET is bogus.
- virtual void BadLineInfoOffset(uint64 offset);
+ virtual void BadLineInfoOffset(uint64_t offset);
// FUNCTION includes code covered by no line number data.
virtual void UncoveredFunction(const Module::Function &function);
@@ -215,30 +215,30 @@
// The DW_TAG_subprogram DIE at OFFSET has no name specified directly
// in the DIE, nor via a DW_AT_specification or DW_AT_abstract_origin
// link.
- virtual void UnnamedFunction(uint64 offset);
+ virtual void UnnamedFunction(uint64_t offset);
// __cxa_demangle() failed to demangle INPUT.
virtual void DemangleError(const string &input);
// The DW_FORM_ref_addr at OFFSET to TARGET was not handled because
// FilePrivate did not retain the inter-CU specification data.
- virtual void UnhandledInterCUReference(uint64 offset, uint64 target);
+ virtual void UnhandledInterCUReference(uint64_t offset, uint64_t target);
// The DW_AT_ranges at offset is malformed (truncated or outside of the
// .debug_ranges section's bound).
- virtual void MalformedRangeList(uint64 offset);
+ virtual void MalformedRangeList(uint64_t offset);
// A DW_AT_ranges attribute was encountered but the no .debug_ranges
// section was found.
virtual void MissingRanges();
- uint64 cu_offset() const {
+ uint64_t cu_offset() const {
return cu_offset_;
}
protected:
const string filename_;
- const uint64 cu_offset_;
+ const uint64_t cu_offset_;
string cu_name_;
bool printed_cu_header_;
bool printed_unpaired_header_;
@@ -265,24 +265,24 @@
void ProcessAttributeSigned(enum DwarfAttribute attr,
enum DwarfForm form,
- int64 data);
+ int64_t data);
void ProcessAttributeUnsigned(enum DwarfAttribute attr,
enum DwarfForm form,
- uint64 data);
+ uint64_t data);
void ProcessAttributeString(enum DwarfAttribute attr,
enum DwarfForm form,
const string &data);
bool EndAttributes();
- DIEHandler *FindChildHandler(uint64 offset, enum DwarfTag tag);
+ DIEHandler *FindChildHandler(uint64_t offset, enum DwarfTag tag);
// Assign all our source Lines to the Functions that cover their
// addresses, and then add them to module_.
void Finish();
- bool StartCompilationUnit(uint64 offset, uint8 address_size,
- uint8 offset_size, uint64 cu_length,
- uint8 dwarf_version);
- bool StartRootDIE(uint64 offset, enum DwarfTag tag);
+ bool StartCompilationUnit(uint64_t offset, uint8_t address_size,
+ uint8_t offset_size, uint64_t cu_length,
+ uint8_t dwarf_version);
+ bool StartRootDIE(uint64_t offset, enum DwarfTag tag);
private:
// Used internally by the handler. Full definitions are in
@@ -295,7 +295,7 @@
class NamedScopeHandler;
// A map from section offsets to specifications.
- typedef map<uint64, Specification> SpecificationByOffset;
+ typedef map<uint64_t, Specification> SpecificationByOffset;
// Set this compilation unit's source language to LANGUAGE.
void SetLanguage(DwarfLanguage language);
@@ -304,7 +304,7 @@
// section. Record source files in module_, but record source lines
// in lines_; we apportion them to functions in
// AssignLinesToFunctions.
- void ReadSourceLines(uint64 offset);
+ void ReadSourceLines(uint64_t offset);
// Assign the lines in lines_ to the individual line lists of the
// functions in functions_. (DWARF line information maps an entire
@@ -332,7 +332,7 @@
// The offset of this compilation unit's line number information in
// the .debug_line section.
- uint64 source_line_offset_;
+ uint64_t source_line_offset_;
// The line numbers we have seen thus far. We accumulate these here
// during parsing. Then, in Finish, we call AssignLinesToFunctions
diff --git a/src/common/dwarf_cu_to_module_unittest.cc b/src/common/dwarf_cu_to_module_unittest.cc
index aef6922..ed1d7c9 100644
--- a/src/common/dwarf_cu_to_module_unittest.cc
+++ b/src/common/dwarf_cu_to_module_unittest.cc
@@ -67,24 +67,24 @@
class MockLineToModuleHandler: public DwarfCUToModule::LineToModuleHandler {
public:
MOCK_METHOD1(StartCompilationUnit, void(const string& compilation_dir));
- MOCK_METHOD4(ReadProgram, void(const uint8_t *program, uint64 length,
+ MOCK_METHOD4(ReadProgram, void(const uint8_t *program, uint64_t length,
Module *module, vector<Module::Line> *lines));
};
class MockWarningReporter: public DwarfCUToModule::WarningReporter {
public:
- MockWarningReporter(const string &filename, uint64 cu_offset)
+ MockWarningReporter(const string &filename, uint64_t cu_offset)
: DwarfCUToModule::WarningReporter(filename, cu_offset) { }
MOCK_METHOD1(SetCUName, void(const string &name));
- MOCK_METHOD2(UnknownSpecification, void(uint64 offset, uint64 target));
- MOCK_METHOD2(UnknownAbstractOrigin, void(uint64 offset, uint64 target));
+ MOCK_METHOD2(UnknownSpecification, void(uint64_t offset, uint64_t target));
+ MOCK_METHOD2(UnknownAbstractOrigin, void(uint64_t offset, uint64_t target));
MOCK_METHOD1(MissingSection, void(const string §ion_name));
- MOCK_METHOD1(BadLineInfoOffset, void(uint64 offset));
+ MOCK_METHOD1(BadLineInfoOffset, void(uint64_t offset));
MOCK_METHOD1(UncoveredFunction, void(const Module::Function &function));
MOCK_METHOD1(UncoveredLine, void(const Module::Line &line));
- MOCK_METHOD1(UnnamedFunction, void(uint64 offset));
+ MOCK_METHOD1(UnnamedFunction, void(uint64_t offset));
MOCK_METHOD1(DemangleError, void(const string &input));
- MOCK_METHOD2(UnhandledInterCUReference, void(uint64 offset, uint64 target));
+ MOCK_METHOD2(UnhandledInterCUReference, void(uint64_t offset, uint64_t target));
};
// A fixture class including all the objects needed to handle a
@@ -113,7 +113,7 @@
public:
explicit AppendLinesFunctor(
const vector<Module::Line> *lines) : lines_(lines) { }
- void operator()(const uint8_t *program, uint64 length,
+ void operator()(const uint8_t *program, uint64_t length,
Module *module, vector<Module::Line> *lines) {
lines->insert(lines->end(), lines_->begin(), lines_->end());
}
@@ -196,7 +196,7 @@
// not Finish. If NAME is non-zero, use it as the DW_AT_name
// attribute.
DIEHandler *StartSpecifiedDIE(DIEHandler *parent, DwarfTag tag,
- uint64 specification, const char *name = NULL);
+ uint64_t specification, const char *name = NULL);
// Define a function as a child of PARENT with the given name, address, and
// size. If high_pc_form is DW_FORM_addr then the DW_AT_high_pc attribute
@@ -211,7 +211,7 @@
// Create a declaration DIE as a child of PARENT with the given
// offset, tag and name. If NAME is the empty string, don't provide
// a DW_AT_name attribute. Call EndAttributes and Finish.
- void DeclarationDIE(DIEHandler *parent, uint64 offset,
+ void DeclarationDIE(DIEHandler *parent, uint64_t offset,
DwarfTag tag, const string &name,
const string &mangled_name);
@@ -221,15 +221,15 @@
// attribute. If SIZE is non-zero, record ADDRESS and SIZE as
// low_pc/high_pc attributes.
void DefinitionDIE(DIEHandler *parent, DwarfTag tag,
- uint64 specification, const string &name,
+ uint64_t specification, const string &name,
Module::Address address = 0, Module::Address size = 0);
// Create an inline DW_TAG_subprogram DIE as a child of PARENT. If
// SPECIFICATION is non-zero, then the DIE refers to the declaration DIE at
// offset SPECIFICATION as its specification. If Name is non-empty, pass it
// as the DW_AT_name attribute.
- void AbstractInstanceDIE(DIEHandler *parent, uint64 offset,
- DwarfInline type, uint64 specification,
+ void AbstractInstanceDIE(DIEHandler *parent, uint64_t offset,
+ DwarfInline type, uint64_t specification,
const string &name,
DwarfForm form = dwarf2reader::DW_FORM_data1);
@@ -237,7 +237,7 @@
// ORIGIN in its DW_AT_abstract_origin attribute. If NAME is the empty
// string, don't provide a DW_AT_name attribute.
void DefineInlineInstanceDIE(DIEHandler *parent, const string &name,
- uint64 origin, Module::Address address,
+ uint64_t origin, Module::Address address,
Module::Address size);
// The following Test* functions should be called after calling
@@ -409,7 +409,7 @@
DIEHandler *CUFixtureBase::StartSpecifiedDIE(DIEHandler *parent,
DwarfTag tag,
- uint64 specification,
+ uint64_t specification,
const char *name) {
dwarf2reader::DIEHandler *handler
= parent->FindChildHandler(0x8f4c783c0467c989ULL, tag);
@@ -466,7 +466,7 @@
delete func;
}
-void CUFixtureBase::DeclarationDIE(DIEHandler *parent, uint64 offset,
+void CUFixtureBase::DeclarationDIE(DIEHandler *parent, uint64_t offset,
DwarfTag tag,
const string &name,
const string &mangled_name) {
@@ -491,7 +491,7 @@
void CUFixtureBase::DefinitionDIE(DIEHandler *parent,
DwarfTag tag,
- uint64 specification,
+ uint64_t specification,
const string &name,
Module::Address address,
Module::Address size) {
@@ -519,9 +519,9 @@
}
void CUFixtureBase::AbstractInstanceDIE(DIEHandler *parent,
- uint64 offset,
+ uint64_t offset,
DwarfInline type,
- uint64 specification,
+ uint64_t specification,
const string &name,
DwarfForm form) {
dwarf2reader::DIEHandler *die
@@ -548,7 +548,7 @@
void CUFixtureBase::DefineInlineInstanceDIE(DIEHandler *parent,
const string &name,
- uint64 origin,
+ uint64_t origin,
Module::Address address,
Module::Address size) {
dwarf2reader::DIEHandler *func
diff --git a/src/common/dwarf_line_to_module.cc b/src/common/dwarf_line_to_module.cc
index 258b0b6..443d744 100644
--- a/src/common/dwarf_line_to_module.cc
+++ b/src/common/dwarf_line_to_module.cc
@@ -63,16 +63,16 @@
namespace google_breakpad {
-void DwarfLineToModule::DefineDir(const string &name, uint32 dir_num) {
+void DwarfLineToModule::DefineDir(const string &name, uint32_t dir_num) {
// Directory number zero is reserved to mean the compilation
// directory. Silently ignore attempts to redefine it.
if (dir_num != 0)
directories_[dir_num] = ExpandPath(name, compilation_dir_);
}
-void DwarfLineToModule::DefineFile(const string &name, int32 file_num,
- uint32 dir_num, uint64 mod_time,
- uint64 length) {
+void DwarfLineToModule::DefineFile(const string &name, int32_t file_num,
+ uint32_t dir_num, uint64_t mod_time,
+ uint64_t length) {
if (file_num == -1)
file_num = ++highest_file_number_;
else if (file_num > highest_file_number_)
@@ -103,9 +103,9 @@
files_[file_num] = module_->FindFile(full_name);
}
-void DwarfLineToModule::AddLine(uint64 address, uint64 length,
- uint32 file_num, uint32 line_num,
- uint32 column_num) {
+void DwarfLineToModule::AddLine(uint64_t address, uint64_t length,
+ uint32_t file_num, uint32_t line_num,
+ uint32_t column_num) {
if (length == 0)
return;
diff --git a/src/common/dwarf_line_to_module.h b/src/common/dwarf_line_to_module.h
index 1fdd4cb..f54ccaf 100644
--- a/src/common/dwarf_line_to_module.h
+++ b/src/common/dwarf_line_to_module.h
@@ -132,17 +132,17 @@
~DwarfLineToModule() { }
- void DefineDir(const string &name, uint32 dir_num);
- void DefineFile(const string &name, int32 file_num,
- uint32 dir_num, uint64 mod_time,
- uint64 length);
- void AddLine(uint64 address, uint64 length,
- uint32 file_num, uint32 line_num, uint32 column_num);
+ void DefineDir(const string &name, uint32_t dir_num);
+ void DefineFile(const string &name, int32_t file_num,
+ uint32_t dir_num, uint64_t mod_time,
+ uint64_t length);
+ void AddLine(uint64_t address, uint64_t length,
+ uint32_t file_num, uint32_t line_num, uint32_t column_num);
private:
- typedef std::map<uint32, string> DirectoryTable;
- typedef std::map<uint32, Module::File *> FileTable;
+ typedef std::map<uint32_t, string> DirectoryTable;
+ typedef std::map<uint32_t, Module::File *> FileTable;
// The module we're contributing debugging info to. Owned by our
// client.
@@ -171,12 +171,12 @@
// The highest file number we've seen so far, or -1 if we've seen
// none. Used for dynamically defined file numbers.
- int32 highest_file_number_;
+ int32_t highest_file_number_;
// This is the ending address of the last line we omitted, or zero if we
// didn't omit the previous line. It is zero before we have received any
// AddLine calls.
- uint64 omitted_line_end_;
+ uint64_t omitted_line_end_;
// True if we've warned about:
bool warned_bad_file_number_; // bad file numbers
diff --git a/src/common/dwarf_range_list_handler.cc b/src/common/dwarf_range_list_handler.cc
index 8733df3..cc9e39c 100644
--- a/src/common/dwarf_range_list_handler.cc
+++ b/src/common/dwarf_range_list_handler.cc
@@ -39,13 +39,13 @@
namespace google_breakpad {
-void DwarfRangeListHandler::AddRange(uint64 begin, uint64 end) {
+void DwarfRangeListHandler::AddRange(uint64_t begin, uint64_t end) {
Module::Range r(begin + base_address_, end - begin);
ranges_->push_back(r);
}
-void DwarfRangeListHandler::SetBaseAddress(uint64 base_address) {
+void DwarfRangeListHandler::SetBaseAddress(uint64_t base_address) {
base_address_ = base_address;
}
diff --git a/src/common/dwarf_range_list_handler.h b/src/common/dwarf_range_list_handler.h
index bd09968..83a3469 100644
--- a/src/common/dwarf_range_list_handler.h
+++ b/src/common/dwarf_range_list_handler.h
@@ -51,16 +51,16 @@
class DwarfRangeListHandler: public dwarf2reader::RangeListHandler {
public:
- DwarfRangeListHandler(uint64 base_address, vector<Module::Range> *ranges)
+ DwarfRangeListHandler(uint64_t base_address, vector<Module::Range> *ranges)
: base_address_(base_address), ranges_(ranges) { }
~DwarfRangeListHandler() { }
// Add a range to the list
- void AddRange(uint64 begin, uint64 end);
+ void AddRange(uint64_t begin, uint64_t end);
// Record the new base address and use it for the following entries
- void SetBaseAddress(uint64 base_address);
+ void SetBaseAddress(uint64_t base_address);
// Sort the ranges so that they are in ascending order of starting address
void Finish();
@@ -68,7 +68,7 @@
private:
// The current PC to add to every entry, this can be overridden by a special
// list entry
- uint64 base_address_;
+ uint64_t base_address_;
// The list of ranges to be populated
vector<Module::Range> *ranges_;
diff --git a/src/common/linux/dump_symbols.cc b/src/common/linux/dump_symbols.cc
index 0eea2b5..b7e77ab 100644
--- a/src/common/linux/dump_symbols.cc
+++ b/src/common/linux/dump_symbols.cc
@@ -232,11 +232,11 @@
// owned by a function) with the results.
class DumperRangesHandler : public DwarfCUToModule::RangesHandler {
public:
- DumperRangesHandler(const uint8_t *buffer, uint64 size,
+ DumperRangesHandler(const uint8_t *buffer, uint64_t size,
dwarf2reader::ByteReader* reader)
: buffer_(buffer), size_(size), reader_(reader) { }
- bool ReadRanges(uint64 offset, Module::Address base_address,
+ bool ReadRanges(uint64_t offset, Module::Address base_address,
vector<Module::Range>* ranges) {
DwarfRangeListHandler handler(base_address, ranges);
dwarf2reader::RangeListReader rangelist_reader(buffer_, size_, reader_,
@@ -247,7 +247,7 @@
private:
const uint8_t *buffer_;
- uint64 size_;
+ uint64_t size_;
dwarf2reader::ByteReader* reader_;
};
@@ -262,7 +262,7 @@
void StartCompilationUnit(const string& compilation_dir) {
compilation_dir_ = compilation_dir;
}
- void ReadProgram(const uint8_t *program, uint64 length,
+ void ReadProgram(const uint8_t *program, uint64_t length,
Module* module, std::vector<Module::Line>* lines) {
DwarfLineToModule handler(module, compilation_dir_, lines);
dwarf2reader::LineInfo parser(program, length, byte_reader_, &handler);
@@ -310,7 +310,7 @@
dwarf2reader::SectionMap::const_iterator ranges_entry =
file_context.section_map().find(".debug_ranges");
if (ranges_entry != file_context.section_map().end()) {
- const std::pair<const uint8_t *, uint64>& ranges_section =
+ const std::pair<const uint8_t *, uint64_t>& ranges_section =
ranges_entry->second;
ranges_handler.reset(
new DumperRangesHandler(ranges_section.first, ranges_section.second,
@@ -322,13 +322,13 @@
dwarf2reader::SectionMap::const_iterator debug_info_entry =
file_context.section_map().find(".debug_info");
assert(debug_info_entry != file_context.section_map().end());
- const std::pair<const uint8_t *, uint64>& debug_info_section =
+ const std::pair<const uint8_t *, uint64_t>& debug_info_section =
debug_info_entry->second;
// This should never have been called if the file doesn't have a
// .debug_info section.
assert(debug_info_section.first);
- uint64 debug_info_length = debug_info_section.second;
- for (uint64 offset = 0; offset < debug_info_length;) {
+ uint64_t debug_info_length = debug_info_section.second;
+ for (uint64_t offset = 0; offset < debug_info_length;) {
// Make a handler for the root DIE that populates MODULE with the
// data that was found.
DwarfCUToModule::WarningReporter reporter(dwarf_filename, offset);
diff --git a/src/common/mac/dump_syms.cc b/src/common/mac/dump_syms.cc
index 5ebe3d2..3fbedd9 100644
--- a/src/common/mac/dump_syms.cc
+++ b/src/common/mac/dump_syms.cc
@@ -311,11 +311,11 @@
class DumpSymbols::DumperRangesHandler:
public DwarfCUToModule::RangesHandler {
public:
- DumperRangesHandler(const uint8_t *buffer, uint64 size,
+ DumperRangesHandler(const uint8_t *buffer, uint64_t size,
dwarf2reader::ByteReader* reader)
: buffer_(buffer), size_(size), reader_(reader) { }
- bool ReadRanges(uint64 offset, Module::Address base_address,
+ bool ReadRanges(uint64_t offset, Module::Address base_address,
vector<Module::Range>* ranges) {
DwarfRangeListHandler handler(base_address, ranges);
dwarf2reader::RangeListReader rangelist_reader(buffer_, size_, reader_,
@@ -326,7 +326,7 @@
private:
const uint8_t *buffer_;
- uint64 size_;
+ uint64_t size_;
dwarf2reader::ByteReader* reader_;
};
@@ -344,7 +344,7 @@
compilation_dir_ = compilation_dir;
}
- void ReadProgram(const uint8_t *program, uint64 length,
+ void ReadProgram(const uint8_t *program, uint64_t length,
Module *module, vector<Module::Line> *lines) {
DwarfLineToModule handler(module, compilation_dir_, lines);
dwarf2reader::LineInfo parser(program, length, byte_reader_, &handler);
@@ -445,7 +445,7 @@
selected_object_name_.c_str());
return;
}
- const std::pair<const uint8_t*, uint64>& debug_info_section =
+ const std::pair<const uint8_t*, uint64_t>& debug_info_section =
debug_info_entry->second;
// Build a line-to-module loader for the root handler to use.
@@ -456,7 +456,7 @@
dwarf2reader::SectionMap::const_iterator ranges_entry =
file_context.section_map().find("__debug_ranges");
if (ranges_entry != file_context.section_map().end()) {
- const std::pair<const uint8_t *, uint64>& ranges_section =
+ const std::pair<const uint8_t *, uint64_t>& ranges_section =
ranges_entry->second;
ranges_handler.reset(
new DumperRangesHandler(ranges_section.first, ranges_section.second,
@@ -464,8 +464,8 @@
}
// Walk the __debug_info section, one compilation unit at a time.
- uint64 debug_info_length = debug_info_section.second;
- for (uint64 offset = 0; offset < debug_info_length;) {
+ uint64_t debug_info_length = debug_info_section.second;
+ for (uint64_t offset = 0; offset < debug_info_length;) {
// Make a handler for the root DIE that populates MODULE with the
// debug info.
DwarfCUToModule::WarningReporter reporter(selected_object_name_,
