1 files changed, 18 insertions, 13 deletions
diff --git a/3rdParty/Breakpad/src/common/dwarf/bytereader.h b/3rdParty/Breakpad/src/common/dwarf/bytereader.h
index e389427..59d4303 100644
--- a/3rdParty/Breakpad/src/common/dwarf/bytereader.h
+++ b/3rdParty/Breakpad/src/common/dwarf/bytereader.h
@@ -31,7 +31,10 @@
 #ifndef COMMON_DWARF_BYTEREADER_H__
 #define COMMON_DWARF_BYTEREADER_H__
 
+#include <stdint.h>
+
 #include <string>
+
 #include "common/dwarf/types.h"
 #include "common/dwarf/dwarf2enums.h"
 
@@ -59,22 +62,22 @@ class ByteReader {
 
   // Read a single byte from BUFFER and return it as an unsigned 8 bit
   // number.
-  uint8 ReadOneByte(const char* buffer) const;
+  uint8 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 char* buffer) const;
+  uint16 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
   // ReadOffset. The number it returns will never be outside the range
   // of an unsigned 32 bit integer.
-  uint64 ReadFourBytes(const char* buffer) const;
+  uint64 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 char* buffer) const;
+  uint64 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
@@ -93,7 +96,7 @@ class ByteReader {
   // In other words, we break VALUE into groups of seven bits, put
   // them in little-endian order, and then write them as eight-bit
   // bytes with the high bit on all but the last.
-  uint64 ReadUnsignedLEB128(const char* buffer, size_t* len) const;
+  uint64 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.
@@ -112,7 +115,7 @@ class ByteReader {
   // In other words, we break VALUE into groups of seven bits, put
   // them in little-endian order, and then write them as eight-bit
   // bytes with the high bit on all but the last.
-  int64 ReadSignedLEB128(const char* buffer, size_t* len) const;
+  int64 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
@@ -135,7 +138,7 @@ class ByteReader {
   // 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 char* buffer) const;
+  uint64 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
@@ -172,14 +175,14 @@ class ByteReader {
   // - The 32-bit value 0xffffffff, followed by a 64-bit byte count,
   //   indicating that the data whose length is being measured uses
   //   the 64-bit DWARF format.
-  uint64 ReadInitialLength(const char* start, size_t* len);
+  uint64 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 char* buffer) const;
+  uint64 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.
@@ -234,7 +237,7 @@ class ByteReader {
   // is BUFFER_BASE. This allows us to find the address that a given
   // byte in our buffer would have when loaded into the program the
   // data describes. We need this to resolve DW_EH_PE_pcrel pointers.
-  void SetCFIDataBase(uint64 section_base, const char *buffer_base);
+  void SetCFIDataBase(uint64 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.
@@ -273,13 +276,15 @@ class ByteReader {
   // base address this reader hasn't been given, so you should check
   // with ValidEncoding and UsableEncoding first if you would rather
   // die in a more helpful way.
-  uint64 ReadEncodedPointer(const char *buffer, DwarfPointerEncoding encoding,
+  uint64 ReadEncodedPointer(const uint8_t *buffer,
+                            DwarfPointerEncoding encoding,
                             size_t *len) const;
 
+  Endianness GetEndianness() const;
  private:
 
   // Function pointer type for our address and offset readers.
-  typedef uint64 (ByteReader::*AddressReader)(const char*) const;
+  typedef uint64 (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,
@@ -302,7 +307,7 @@ class ByteReader {
   bool have_section_base_, have_text_base_, have_data_base_;
   bool have_function_base_;
   uint64 section_base_, text_base_, data_base_, function_base_;
-  const char *buffer_base_;
+  const uint8_t *buffer_base_;
 };
 
 }  // namespace dwarf2reader