From aeffe1056f9ff6526d87a16ef55222899f5528f7 Mon Sep 17 00:00:00 2001 From: "ted.mielczarek@gmail.com" Date: Wed, 6 Mar 2013 14:04:42 +0000 Subject: Use stdint types everywhere R=mark at https://breakpad.appspot.com/535002/ git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@1121 4c0a9323-5329-0410-9bdc-e9ce6186880e --- src/common/dwarf/cfi_assembler.cc | 22 ++++---- src/common/dwarf/cfi_assembler.h | 44 ++++++++-------- src/common/dwarf/dwarf2reader_cfi_unittest.cc | 8 +-- src/common/dwarf/dwarf2reader_die_unittest.cc | 4 +- src/common/dwarf/dwarf2reader_test_common.h | 2 +- src/common/linux/guid_creator.cc | 16 +++--- src/common/linux/memory_mapped_file.cc | 2 +- src/common/mac/MachIPC.h | 8 +-- src/common/memory_range.h | 6 +-- src/common/memory_range_unittest.cc | 4 +- src/common/module.h | 2 +- src/common/solaris/dump_symbols.cc | 2 +- src/common/solaris/guid_creator.cc | 12 ++--- src/common/stabs_reader_unittest.cc | 6 +-- src/common/string_conversion.cc | 36 ++++++------- src/common/string_conversion.h | 10 ++-- src/common/test_assembler.cc | 50 +++++++++--------- src/common/test_assembler.h | 52 +++++++++---------- src/common/test_assembler_unittest.cc | 74 +++++++++++++-------------- 19 files changed, 180 insertions(+), 180 deletions(-) (limited to 'src/common') diff --git a/src/common/dwarf/cfi_assembler.cc b/src/common/dwarf/cfi_assembler.cc index a6a5aca6..dbc2efae 100644 --- a/src/common/dwarf/cfi_assembler.cc +++ b/src/common/dwarf/cfi_assembler.cc @@ -41,10 +41,10 @@ namespace google_breakpad { using dwarf2reader::DwarfPointerEncoding; -CFISection &CFISection::CIEHeader(u_int64_t code_alignment_factor, +CFISection &CFISection::CIEHeader(uint64_t code_alignment_factor, int data_alignment_factor, unsigned return_address_register, - u_int8_t version, + uint8_t version, const string &augmentation, bool dwarf64) { assert(!entry_length_); @@ -73,8 +73,8 @@ CFISection &CFISection::CIEHeader(u_int64_t code_alignment_factor, } CFISection &CFISection::FDEHeader(Label cie_pointer, - u_int64_t initial_location, - u_int64_t address_range, + uint64_t initial_location, + uint64_t address_range, bool dwarf64) { assert(!entry_length_); entry_length_ = new PendingLength(); @@ -117,7 +117,7 @@ CFISection &CFISection::FinishEntry() { return *this; } -CFISection &CFISection::EncodedPointer(u_int64_t address, +CFISection &CFISection::EncodedPointer(uint64_t address, DwarfPointerEncoding encoding, const EncodedPointerBases &bases) { // Omitted data is extremely easy to emit. @@ -131,7 +131,7 @@ CFISection &CFISection::EncodedPointer(u_int64_t address, // Find the base address to which this pointer is relative. The upper // nybble of the encoding specifies this. - u_int64_t base; + uint64_t base; switch (encoding & 0xf0) { case dwarf2reader::DW_EH_PE_absptr: base = 0; break; case dwarf2reader::DW_EH_PE_pcrel: base = bases.cfi + Size(); break; @@ -189,10 +189,10 @@ CFISection &CFISection::EncodedPointer(u_int64_t address, return *this; }; -const u_int32_t CFISection::kDwarf64InitialLengthMarker; -const u_int32_t CFISection::kDwarf32CIEIdentifier; -const u_int64_t CFISection::kDwarf64CIEIdentifier; -const u_int32_t CFISection::kEHFrame32CIEIdentifier; -const u_int64_t CFISection::kEHFrame64CIEIdentifier; +const uint32_t CFISection::kDwarf64InitialLengthMarker; +const uint32_t CFISection::kDwarf32CIEIdentifier; +const uint64_t CFISection::kDwarf64CIEIdentifier; +const uint32_t CFISection::kEHFrame32CIEIdentifier; +const uint64_t CFISection::kEHFrame64CIEIdentifier; } // namespace google_breakpad diff --git a/src/common/dwarf/cfi_assembler.h b/src/common/dwarf/cfi_assembler.h index 00ff6f06..227812b5 100644 --- a/src/common/dwarf/cfi_assembler.h +++ b/src/common/dwarf/cfi_assembler.h @@ -80,14 +80,14 @@ class CFISection: public Section { // The starting address of this CFI section in memory, for // DW_EH_PE_pcrel. DW_EH_PE_pcrel pointers may only be used in data // that has is loaded into the program's address space. - u_int64_t cfi; + uint64_t cfi; // The starting address of this file's .text section, for DW_EH_PE_textrel. - u_int64_t text; + uint64_t text; // The starting address of this file's .got or .eh_frame_hdr section, // for DW_EH_PE_datarel. - u_int64_t data; + uint64_t data; }; // Create a CFISection whose endianness is ENDIANNESS, and where @@ -133,10 +133,10 @@ class CFISection: public Section { // Before calling this function, you will typically want to use Mark // or Here to make a label to pass to FDEHeader that refers to this // CIE's position in the section. - CFISection &CIEHeader(u_int64_t code_alignment_factor, + CFISection &CIEHeader(uint64_t code_alignment_factor, int data_alignment_factor, unsigned return_address_register, - u_int8_t version = 3, + uint8_t version = 3, const string &augmentation = "", bool dwarf64 = false); @@ -151,8 +151,8 @@ class CFISection: public Section { // value.) Nor does it support .debug_frame sections longer than // 0xffffff00 bytes. CFISection &FDEHeader(Label cie_pointer, - u_int64_t initial_location, - u_int64_t address_range, + uint64_t initial_location, + uint64_t address_range, bool dwarf64 = false); // Note the current position as the end of the last CIE or FDE we @@ -171,7 +171,7 @@ class CFISection: public Section { // Append ADDRESS to this section, in the appropriate size and // endianness. Return a reference to this section. - CFISection &Address(u_int64_t address) { + CFISection &Address(uint64_t address) { Section::Append(endianness(), address_size_, address); return *this; } @@ -189,26 +189,26 @@ class CFISection: public Section { // // (C++ doesn't let me use default arguments here, because I want to // refer to members of *this in the default argument expression.) - CFISection &EncodedPointer(u_int64_t address) { + CFISection &EncodedPointer(uint64_t address) { return EncodedPointer(address, pointer_encoding_, encoded_pointer_bases_); } - CFISection &EncodedPointer(u_int64_t address, DwarfPointerEncoding encoding) { + CFISection &EncodedPointer(uint64_t address, DwarfPointerEncoding encoding) { return EncodedPointer(address, encoding, encoded_pointer_bases_); } - CFISection &EncodedPointer(u_int64_t address, DwarfPointerEncoding encoding, + CFISection &EncodedPointer(uint64_t address, DwarfPointerEncoding encoding, const EncodedPointerBases &bases); // Restate some member functions, to keep chaining working nicely. CFISection &Mark(Label *label) { Section::Mark(label); return *this; } - CFISection &D8(u_int8_t v) { Section::D8(v); return *this; } - CFISection &D16(u_int16_t v) { Section::D16(v); return *this; } + CFISection &D8(uint8_t v) { Section::D8(v); return *this; } + CFISection &D16(uint16_t v) { Section::D16(v); return *this; } CFISection &D16(Label v) { Section::D16(v); return *this; } - CFISection &D32(u_int32_t v) { Section::D32(v); return *this; } + CFISection &D32(uint32_t v) { Section::D32(v); return *this; } CFISection &D32(const Label &v) { Section::D32(v); return *this; } - CFISection &D64(u_int64_t v) { Section::D64(v); return *this; } + CFISection &D64(uint64_t v) { Section::D64(v); return *this; } CFISection &D64(const Label &v) { Section::D64(v); return *this; } CFISection &LEB128(long long v) { Section::LEB128(v); return *this; } - CFISection &ULEB128(u_int64_t v) { Section::ULEB128(v); return *this; } + CFISection &ULEB128(uint64_t v) { Section::ULEB128(v); return *this; } private: // A length value that we've appended to the section, but is not yet @@ -224,13 +224,13 @@ class CFISection: public Section { // If the first four bytes of an "initial length" are this constant, then // the data uses the 64-bit DWARF format, and the length itself is the // subsequent eight bytes. - static const u_int32_t kDwarf64InitialLengthMarker = 0xffffffffU; + static const uint32_t kDwarf64InitialLengthMarker = 0xffffffffU; // The CIE identifier for 32- and 64-bit DWARF CFI and .eh_frame data. - static const u_int32_t kDwarf32CIEIdentifier = ~(u_int32_t)0; - static const u_int64_t kDwarf64CIEIdentifier = ~(u_int64_t)0; - static const u_int32_t kEHFrame32CIEIdentifier = 0; - static const u_int64_t kEHFrame64CIEIdentifier = 0; + static const uint32_t kDwarf32CIEIdentifier = ~(uint32_t)0; + static const uint64_t kDwarf64CIEIdentifier = ~(uint64_t)0; + static const uint32_t kEHFrame32CIEIdentifier = 0; + static const uint64_t kEHFrame64CIEIdentifier = 0; // The size of a machine address for the data in this section. size_t address_size_; @@ -261,7 +261,7 @@ class CFISection: public Section { // If in_fde_ is true, this is its starting address. We use this for // emitting DW_EH_PE_funcrel pointers. - u_int64_t fde_start_address_; + uint64_t fde_start_address_; }; } // namespace google_breakpad diff --git a/src/common/dwarf/dwarf2reader_cfi_unittest.cc b/src/common/dwarf/dwarf2reader_cfi_unittest.cc index 7b794361..66c6198b 100644 --- a/src/common/dwarf/dwarf2reader_cfi_unittest.cc +++ b/src/common/dwarf/dwarf2reader_cfi_unittest.cc @@ -2326,14 +2326,14 @@ struct ELFSectionHeader { alignment(1), entry_size(0) { } Label name; unsigned int type; - u_int64_t flags; - u_int64_t address; + uint64_t flags; + uint64_t address; Label file_offset; Label file_size; unsigned int link; unsigned int info; - u_int64_t alignment; - u_int64_t entry_size; + uint64_t alignment; + uint64_t entry_size; }; void AppendSectionHeader(CFISection *table, const ELFSectionHeader &header) { diff --git a/src/common/dwarf/dwarf2reader_die_unittest.cc b/src/common/dwarf/dwarf2reader_die_unittest.cc index f8462a19..4e344369 100644 --- a/src/common/dwarf/dwarf2reader_die_unittest.cc +++ b/src/common/dwarf/dwarf2reader_die_unittest.cc @@ -289,7 +289,7 @@ TEST_P(DwarfForms, addr) { StartSingleAttributeDIE(GetParam(), dwarf2reader::DW_TAG_compile_unit, dwarf2reader::DW_AT_low_pc, dwarf2reader::DW_FORM_addr); - u_int64_t value; + uint64_t value; if (GetParam().address_size == 4) { value = 0xc8e9ffcc; info.D32(value); @@ -372,7 +372,7 @@ TEST_P(DwarfForms, sec_offset) { StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x1d971689, (DwarfAttribute) 0xa060bfd1, dwarf2reader::DW_FORM_sec_offset); - u_int64_t value; + uint64_t value; if (GetParam().format_size == 4) { value = 0xacc9c388; info.D32(value); diff --git a/src/common/dwarf/dwarf2reader_test_common.h b/src/common/dwarf/dwarf2reader_test_common.h index e46931a4..e91de906 100644 --- a/src/common/dwarf/dwarf2reader_test_common.h +++ b/src/common/dwarf/dwarf2reader_test_common.h @@ -97,7 +97,7 @@ class TestCompilationUnit: public google_breakpad::test_assembler::Section { // The offset of the point in the compilation unit header immediately // after the initial length field. - u_int64_t post_length_offset_; + uint64_t post_length_offset_; // The length of the compilation unit, not including the initial length field. Label length_; diff --git a/src/common/linux/guid_creator.cc b/src/common/linux/guid_creator.cc index 426f93a1..bfb308ee 100644 --- a/src/common/linux/guid_creator.cc +++ b/src/common/linux/guid_creator.cc @@ -46,14 +46,14 @@ // class GUIDGenerator { public: - static u_int32_t BytesToUInt32(const u_int8_t bytes[]) { - return ((u_int32_t) bytes[0] - | ((u_int32_t) bytes[1] << 8) - | ((u_int32_t) bytes[2] << 16) - | ((u_int32_t) bytes[3] << 24)); + static uint32_t BytesToUInt32(const uint8_t bytes[]) { + return ((uint32_t) bytes[0] + | ((uint32_t) bytes[1] << 8) + | ((uint32_t) bytes[2] << 16) + | ((uint32_t) bytes[3] << 24)); } - static void UInt32ToBytes(u_int8_t bytes[], u_int32_t n) { + static void UInt32ToBytes(uint8_t bytes[], uint32_t n) { bytes[0] = n & 0xff; bytes[1] = (n >> 8) & 0xff; bytes[2] = (n >> 16) & 0xff; @@ -63,8 +63,8 @@ class GUIDGenerator { static bool CreateGUID(GUID *guid) { InitOnce(); guid->data1 = random(); - guid->data2 = (u_int16_t)(random()); - guid->data3 = (u_int16_t)(random()); + guid->data2 = (uint16_t)(random()); + guid->data3 = (uint16_t)(random()); UInt32ToBytes(&guid->data4[0], random()); UInt32ToBytes(&guid->data4[4], random()); return true; diff --git a/src/common/linux/memory_mapped_file.cc b/src/common/linux/memory_mapped_file.cc index 47b7eb0b..853cce57 100644 --- a/src/common/linux/memory_mapped_file.cc +++ b/src/common/linux/memory_mapped_file.cc @@ -97,7 +97,7 @@ bool MemoryMappedFile::Map(const char* path) { void MemoryMappedFile::Unmap() { if (content_.data()) { - sys_munmap(const_cast(content_.data()), content_.length()); + sys_munmap(const_cast(content_.data()), content_.length()); content_.Set(NULL, 0); } } diff --git a/src/common/mac/MachIPC.h b/src/common/mac/MachIPC.h index 52bed590..8df9165b 100644 --- a/src/common/mac/MachIPC.h +++ b/src/common/mac/MachIPC.h @@ -164,11 +164,11 @@ class MachMessage { public: // The receiver of the message can retrieve the raw data this way - u_int8_t *GetData() { + uint8_t *GetData() { return GetDataLength() > 0 ? GetDataPacket()->data : NULL; } - u_int32_t GetDataLength() { + uint32_t GetDataLength() { return EndianU32_LtoN(GetDataPacket()->data_length); } @@ -210,7 +210,7 @@ class MachMessage { struct MessageDataPacket { int32_t id; // little-endian int32_t data_length; // little-endian - u_int8_t data[1]; // actual size limited by sizeof(MachMessage) + uint8_t data[1]; // actual size limited by sizeof(MachMessage) }; MessageDataPacket* GetDataPacket(); @@ -223,7 +223,7 @@ class MachMessage { mach_msg_header_t head; mach_msg_body_t body; - u_int8_t padding[1024]; // descriptors and data may be embedded here + uint8_t padding[1024]; // descriptors and data may be embedded here }; //============================================================================== diff --git a/src/common/memory_range.h b/src/common/memory_range.h index 86bd08c9..41dd2da6 100644 --- a/src/common/memory_range.h +++ b/src/common/memory_range.h @@ -67,7 +67,7 @@ class MemoryRange { // Sets this memory range to point to |data| and its length to |length|. void Set(const void* data, size_t length) { - data_ = reinterpret_cast(data); + data_ = reinterpret_cast(data); // Always set |length_| to zero if |data_| is NULL. length_ = data ? length : 0; } @@ -127,14 +127,14 @@ class MemoryRange { } // Returns a pointer to the beginning of this memory range. - const u_int8_t* data() const { return data_; } + const uint8_t* data() const { return data_; } // Returns the length, in bytes, of this memory range. size_t length() const { return length_; } private: // Pointer to the beginning of this memory range. - const u_int8_t* data_; + const uint8_t* data_; // Length, in bytes, of this memory range. size_t length_; diff --git a/src/common/memory_range_unittest.cc b/src/common/memory_range_unittest.cc index b13f45ca..f6cf8c8b 100644 --- a/src/common/memory_range_unittest.cc +++ b/src/common/memory_range_unittest.cc @@ -37,9 +37,9 @@ using testing::Message; namespace { -const u_int32_t kBuffer[10] = { 0 }; +const uint32_t kBuffer[10] = { 0 }; const size_t kBufferSize = sizeof(kBuffer); -const u_int8_t* kBufferPointer = reinterpret_cast(kBuffer); +const uint8_t* kBufferPointer = reinterpret_cast(kBuffer); // Test vectors for verifying Covers, GetData, and Subrange. const struct { diff --git a/src/common/module.h b/src/common/module.h index d58e8b78..cecab32f 100644 --- a/src/common/module.h +++ b/src/common/module.h @@ -60,7 +60,7 @@ using std::map; class Module { public: // The type of addresses and sizes in a symbol table. - typedef u_int64_t Address; + typedef uint64_t Address; struct File; struct Function; struct Line; diff --git a/src/common/solaris/dump_symbols.cc b/src/common/solaris/dump_symbols.cc index fb040265..168d0b28 100644 --- a/src/common/solaris/dump_symbols.cc +++ b/src/common/solaris/dump_symbols.cc @@ -156,7 +156,7 @@ const char *kStrtabName = ".strtab"; const int demangleLen = 20000; // Offset to the string table. -u_int64_t stringOffset = 0; +uint64_t stringOffset = 0; // Update the offset to the start of the string index of the next // object module for every N_ENDM stabs. diff --git a/src/common/solaris/guid_creator.cc b/src/common/solaris/guid_creator.cc index 70940259..c4d58e0a 100644 --- a/src/common/solaris/guid_creator.cc +++ b/src/common/solaris/guid_creator.cc @@ -53,10 +53,10 @@ class GUIDGenerator { bool CreateGUID(GUID *guid) const { guid->data1 = random(); - guid->data2 = (u_int16_t)(random()); - guid->data3 = (u_int16_t)(random()); - *reinterpret_cast(&guid->data4[0]) = random(); - *reinterpret_cast(&guid->data4[4]) = random(); + guid->data2 = (uint16_t)(random()); + guid->data3 = (uint16_t)(random()); + *reinterpret_cast(&guid->data4[0]) = random(); + *reinterpret_cast(&guid->data4[4]) = random(); return true; } }; @@ -74,8 +74,8 @@ bool GUIDToString(const GUID *guid, char *buf, int buf_len) { assert(buf_len > kGUIDStringLength); int num = snprintf(buf, buf_len, kGUIDFormatString, guid->data1, guid->data2, guid->data3, - *reinterpret_cast(&(guid->data4[0])), - *reinterpret_cast(&(guid->data4[4]))); + *reinterpret_cast(&(guid->data4[0])), + *reinterpret_cast(&(guid->data4[4]))); if (num != kGUIDStringLength) return false; diff --git a/src/common/stabs_reader_unittest.cc b/src/common/stabs_reader_unittest.cc index edcba724..a84da1c4 100644 --- a/src/common/stabs_reader_unittest.cc +++ b/src/common/stabs_reader_unittest.cc @@ -565,7 +565,7 @@ TEST_F(Stabs, OnePublicSymbol) { stabs.set_endianness(kLittleEndian); stabs.set_value_size(4); - const u_int32_t kExpectedAddress = 0x9000; + const uint32_t kExpectedAddress = 0x9000; const string kExpectedFunctionName("public_function"); stabs .Stab(N_SECT, 1, 0, kExpectedAddress, kExpectedFunctionName); @@ -584,9 +584,9 @@ TEST_F(Stabs, TwoPublicSymbols) { stabs.set_endianness(kLittleEndian); stabs.set_value_size(4); - const u_int32_t kExpectedAddress1 = 0xB0B0B0B0; + const uint32_t kExpectedAddress1 = 0xB0B0B0B0; const string kExpectedFunctionName1("public_function"); - const u_int32_t kExpectedAddress2 = 0xF0F0F0F0; + const uint32_t kExpectedAddress2 = 0xF0F0F0F0; const string kExpectedFunctionName2("something else"); stabs .Stab(N_SECT, 1, 0, kExpectedAddress1, kExpectedFunctionName1) diff --git a/src/common/string_conversion.cc b/src/common/string_conversion.cc index 444ac817..c4107faf 100644 --- a/src/common/string_conversion.cc +++ b/src/common/string_conversion.cc @@ -38,15 +38,15 @@ namespace google_breakpad { using std::vector; -void UTF8ToUTF16(const char *in, vector *out) { +void UTF8ToUTF16(const char *in, vector *out) { size_t source_length = strlen(in); const UTF8 *source_ptr = reinterpret_cast(in); const UTF8 *source_end_ptr = source_ptr + source_length; // Erase the contents and zero fill to the expected size out->clear(); out->insert(out->begin(), source_length, 0); - u_int16_t *target_ptr = &(*out)[0]; - u_int16_t *target_end_ptr = target_ptr + out->capacity() * sizeof(u_int16_t); + uint16_t *target_ptr = &(*out)[0]; + uint16_t *target_end_ptr = target_ptr + out->capacity() * sizeof(uint16_t); ConversionResult result = ConvertUTF8toUTF16(&source_ptr, source_end_ptr, &target_ptr, target_end_ptr, strictConversion); @@ -55,11 +55,11 @@ void UTF8ToUTF16(const char *in, vector *out) { out->resize(result == conversionOK ? target_ptr - &(*out)[0] + 1: 0); } -int UTF8ToUTF16Char(const char *in, int in_length, u_int16_t out[2]) { +int UTF8ToUTF16Char(const char *in, int in_length, uint16_t out[2]) { const UTF8 *source_ptr = reinterpret_cast(in); const UTF8 *source_end_ptr = source_ptr + sizeof(char); - u_int16_t *target_ptr = out; - u_int16_t *target_end_ptr = target_ptr + 2 * sizeof(u_int16_t); + uint16_t *target_ptr = out; + uint16_t *target_end_ptr = target_ptr + 2 * sizeof(uint16_t); out[0] = out[1] = 0; // Process one character at a time @@ -82,15 +82,15 @@ int UTF8ToUTF16Char(const char *in, int in_length, u_int16_t out[2]) { return 0; } -void UTF32ToUTF16(const wchar_t *in, vector *out) { +void UTF32ToUTF16(const wchar_t *in, vector *out) { size_t source_length = wcslen(in); const UTF32 *source_ptr = reinterpret_cast(in); const UTF32 *source_end_ptr = source_ptr + source_length; // Erase the contents and zero fill to the expected size out->clear(); out->insert(out->begin(), source_length, 0); - u_int16_t *target_ptr = &(*out)[0]; - u_int16_t *target_end_ptr = target_ptr + out->capacity() * sizeof(u_int16_t); + uint16_t *target_ptr = &(*out)[0]; + uint16_t *target_end_ptr = target_ptr + out->capacity() * sizeof(uint16_t); ConversionResult result = ConvertUTF32toUTF16(&source_ptr, source_end_ptr, &target_ptr, target_end_ptr, strictConversion); @@ -99,11 +99,11 @@ void UTF32ToUTF16(const wchar_t *in, vector *out) { out->resize(result == conversionOK ? target_ptr - &(*out)[0] + 1: 0); } -void UTF32ToUTF16Char(wchar_t in, u_int16_t out[2]) { +void UTF32ToUTF16Char(wchar_t in, uint16_t out[2]) { const UTF32 *source_ptr = reinterpret_cast(&in); const UTF32 *source_end_ptr = source_ptr + 1; - u_int16_t *target_ptr = out; - u_int16_t *target_end_ptr = target_ptr + 2 * sizeof(u_int16_t); + uint16_t *target_ptr = out; + uint16_t *target_end_ptr = target_ptr + 2 * sizeof(uint16_t); out[0] = out[1] = 0; ConversionResult result = ConvertUTF32toUTF16(&source_ptr, source_end_ptr, &target_ptr, target_end_ptr, @@ -114,20 +114,20 @@ void UTF32ToUTF16Char(wchar_t in, u_int16_t out[2]) { } } -static inline u_int16_t Swap(u_int16_t value) { - return (value >> 8) | static_cast(value << 8); +static inline uint16_t Swap(uint16_t value) { + return (value >> 8) | static_cast(value << 8); } -string UTF16ToUTF8(const vector &in, bool swap) { +string UTF16ToUTF8(const vector &in, bool swap) { const UTF16 *source_ptr = &in[0]; - scoped_ptr source_buffer; + scoped_ptr source_buffer; // If we're to swap, we need to make a local copy and swap each byte pair if (swap) { int idx = 0; - source_buffer.reset(new u_int16_t[in.size()]); + source_buffer.reset(new uint16_t[in.size()]); UTF16 *source_buffer_ptr = source_buffer.get(); - for (vector::const_iterator it = in.begin(); + for (vector::const_iterator it = in.begin(); it != in.end(); ++it, ++idx) source_buffer_ptr[idx] = Swap(*it); diff --git a/src/common/string_conversion.h b/src/common/string_conversion.h index eeed4d28..b9ba96a2 100644 --- a/src/common/string_conversion.h +++ b/src/common/string_conversion.h @@ -44,24 +44,24 @@ using std::vector; // Convert |in| to UTF-16 into |out|. Use platform byte ordering. If the // conversion failed, |out| will be zero length. -void UTF8ToUTF16(const char *in, vector *out); +void UTF8ToUTF16(const char *in, vector *out); // Convert at least one character (up to a maximum of |in_length|) from |in| // to UTF-16 into |out|. Return the number of characters consumed from |in|. // Any unused characters in |out| will be initialized to 0. No memory will // be allocated by this routine. -int UTF8ToUTF16Char(const char *in, int in_length, u_int16_t out[2]); +int UTF8ToUTF16Char(const char *in, int in_length, uint16_t out[2]); // Convert |in| to UTF-16 into |out|. Use platform byte ordering. If the // conversion failed, |out| will be zero length. -void UTF32ToUTF16(const wchar_t *in, vector *out); +void UTF32ToUTF16(const wchar_t *in, vector *out); // Convert |in| to UTF-16 into |out|. Any unused characters in |out| will be // initialized to 0. No memory will be allocated by this routine. -void UTF32ToUTF16Char(wchar_t in, u_int16_t out[2]); +void UTF32ToUTF16Char(wchar_t in, uint16_t out[2]); // Convert |in| to UTF-8. If |swap| is true, swap bytes before converting. -string UTF16ToUTF8(const vector &in, bool swap); +string UTF16ToUTF8(const vector &in, bool swap); } // namespace google_breakpad diff --git a/src/common/test_assembler.cc b/src/common/test_assembler.cc index 7f5dd384..1e783b45 100644 --- a/src/common/test_assembler.cc +++ b/src/common/test_assembler.cc @@ -45,7 +45,7 @@ namespace test_assembler { using std::back_insert_iterator; Label::Label() : value_(new Binding()) { } -Label::Label(u_int64_t value) : value_(new Binding(value)) { } +Label::Label(uint64_t value) : value_(new Binding(value)) { } Label::Label(const Label &label) { value_ = label.value_; value_->Acquire(); @@ -54,7 +54,7 @@ Label::~Label() { if (value_->Release()) delete value_; } -Label &Label::operator=(u_int64_t value) { +Label &Label::operator=(uint64_t value) { value_->Set(NULL, value); return *this; } @@ -64,13 +64,13 @@ Label &Label::operator=(const Label &label) { return *this; } -Label Label::operator+(u_int64_t addend) const { +Label Label::operator+(uint64_t addend) const { Label l; l.value_->Set(this->value_, addend); return l; } -Label Label::operator-(u_int64_t subtrahend) const { +Label Label::operator-(uint64_t subtrahend) const { Label l; l.value_->Set(this->value_, -subtrahend); return l; @@ -89,31 +89,31 @@ Label Label::operator-(u_int64_t subtrahend) const { #define ALWAYS_EVALUATE_AND_ASSERT(x) assert(x) #endif -u_int64_t Label::operator-(const Label &label) const { - u_int64_t offset; +uint64_t Label::operator-(const Label &label) const { + uint64_t offset; ALWAYS_EVALUATE_AND_ASSERT(IsKnownOffsetFrom(label, &offset)); return offset; } -u_int64_t Label::Value() const { - u_int64_t v = 0; +uint64_t Label::Value() const { + uint64_t v = 0; ALWAYS_EVALUATE_AND_ASSERT(IsKnownConstant(&v)); return v; }; -bool Label::IsKnownConstant(u_int64_t *value_p) const { +bool Label::IsKnownConstant(uint64_t *value_p) const { Binding *base; - u_int64_t addend; + uint64_t addend; value_->Get(&base, &addend); if (base != NULL) return false; if (value_p) *value_p = addend; return true; } -bool Label::IsKnownOffsetFrom(const Label &label, u_int64_t *offset_p) const +bool Label::IsKnownOffsetFrom(const Label &label, uint64_t *offset_p) const { Binding *label_base, *this_base; - u_int64_t label_addend, this_addend; + uint64_t label_addend, this_addend; label.value_->Get(&label_base, &label_addend); value_->Get(&this_base, &this_addend); // If this and label are related, Get will find their final @@ -126,7 +126,7 @@ bool Label::IsKnownOffsetFrom(const Label &label, u_int64_t *offset_p) const Label::Binding::Binding() : base_(this), addend_(), reference_count_(1) { } -Label::Binding::Binding(u_int64_t addend) +Label::Binding::Binding(uint64_t addend) : base_(NULL), addend_(addend), reference_count_(1) { } Label::Binding::~Binding() { @@ -135,7 +135,7 @@ Label::Binding::~Binding() { delete base_; } -void Label::Binding::Set(Binding *binding, u_int64_t addend) { +void Label::Binding::Set(Binding *binding, uint64_t addend) { if (!base_ && !binding) { // We're equating two constants. This could be okay. assert(addend_ == addend); @@ -150,7 +150,7 @@ void Label::Binding::Set(Binding *binding, u_int64_t addend) { // another variable (otherwise, it wouldn't be final), this // guarantees we won't create cycles here, even for code like this: // l = m, m = n, n = l; - u_int64_t binding_addend; + uint64_t binding_addend; binding->Get(&binding, &binding_addend); addend += binding_addend; } @@ -183,14 +183,14 @@ void Label::Binding::Set(Binding *binding, u_int64_t addend) { } } -void Label::Binding::Get(Binding **base, u_int64_t *addend) { +void Label::Binding::Get(Binding **base, uint64_t *addend) { if (base_ && base_ != this) { // Recurse to find the end of our reference chain (the root of our // tree), and then rewrite every binding along the chain to refer // to it directly, adjusting addends appropriately. (This is why // this member function isn't this-const.) Binding *final_base; - u_int64_t final_addend; + uint64_t final_addend; base_->Get(&final_base, &final_addend); if (final_base) final_base->Acquire(); if (base_->Release()) delete base_; @@ -203,7 +203,7 @@ void Label::Binding::Get(Binding **base, u_int64_t *addend) { template static inline void InsertEndian(test_assembler::Endianness endianness, - size_t size, u_int64_t number, Inserter dest) { + size_t size, uint64_t number, Inserter dest) { assert(size > 0); if (endianness == kLittleEndian) { for (size_t i = 0; i < size; i++) { @@ -218,7 +218,7 @@ static inline void InsertEndian(test_assembler::Endianness endianness, } } -Section &Section::Append(Endianness endianness, size_t size, u_int64_t number) { +Section &Section::Append(Endianness endianness, size_t size, uint64_t number) { InsertEndian(endianness, size, number, back_insert_iterator(contents_)); return *this; @@ -228,7 +228,7 @@ Section &Section::Append(Endianness endianness, size_t size, const Label &label) { // If this label's value is known, there's no reason to waste an // entry in references_ on it. - u_int64_t value; + uint64_t value; if (label.IsKnownConstant(&value)) return Append(endianness, size, value); @@ -246,7 +246,7 @@ Section &Section::Append(Endianness endianness, size_t size, #define ENDIANNESS(e) ENDIANNESS_ ## e #define DEFINE_SHORT_APPEND_NUMBER_ENDIAN(e, bits) \ - Section &Section::e ## bits(u_int ## bits ## _t v) { \ + Section &Section::e ## bits(uint ## bits ## _t v) { \ InsertEndian(ENDIANNESS(e), bits / 8, v, \ back_insert_iterator(contents_)); \ return *this; \ @@ -272,7 +272,7 @@ DEFINE_SHORT_APPEND_ENDIAN(B, 32); DEFINE_SHORT_APPEND_ENDIAN(B, 64); #define DEFINE_SHORT_APPEND_NUMBER_DEFAULT(bits) \ - Section &Section::D ## bits(u_int ## bits ## _t v) { \ + Section &Section::D ## bits(uint ## bits ## _t v) { \ InsertEndian(endianness_, bits / 8, v, \ back_insert_iterator(contents_)); \ return *this; \ @@ -312,7 +312,7 @@ Section &Section::LEB128(long long value) { return *this; } -Section &Section::ULEB128(u_int64_t value) { +Section &Section::ULEB128(uint64_t value) { while (value > 0x7f) { contents_ += (value & 0x7f) | 0x80; value = (value >> 7); @@ -321,7 +321,7 @@ Section &Section::ULEB128(u_int64_t value) { return *this; } -Section &Section::Align(size_t alignment, u_int8_t pad_byte) { +Section &Section::Align(size_t alignment, uint8_t pad_byte) { // ALIGNMENT must be a power of two. assert(((alignment - 1) & alignment) == 0); size_t new_size = (contents_.size() + alignment - 1) & ~(alignment - 1); @@ -340,7 +340,7 @@ bool Section::GetContents(string *contents) { // the section's contents. for (size_t i = 0; i < references_.size(); i++) { Reference &r = references_[i]; - u_int64_t value; + uint64_t value; if (!r.label.IsKnownConstant(&value)) { fprintf(stderr, "Undefined label #%zu at offset 0x%zx\n", i, r.offset); return false; diff --git a/src/common/test_assembler.h b/src/common/test_assembler.h index 891cf677..373dbeba 100644 --- a/src/common/test_assembler.h +++ b/src/common/test_assembler.h @@ -110,7 +110,7 @@ namespace test_assembler { class Label { public: Label(); // An undefined label. - Label(u_int64_t value); // A label with a fixed value + Label(uint64_t value); // A label with a fixed value Label(const Label &value); // A label equal to another. ~Label(); @@ -119,23 +119,23 @@ class Label { // Providing this as a cast operator is nifty, but the conversions // happen in unexpected places. In particular, ISO C++ says that // Label + size_t becomes ambigious, because it can't decide whether - // to convert the Label to a u_int64_t and then to a size_t, or use + // to convert the Label to a uint64_t and then to a size_t, or use // the overloaded operator that returns a new label, even though the // former could fail if the label is not yet defined and the latter won't. - u_int64_t Value() const; + uint64_t Value() const; - Label &operator=(u_int64_t value); + Label &operator=(uint64_t value); Label &operator=(const Label &value); - Label operator+(u_int64_t addend) const; - Label operator-(u_int64_t subtrahend) const; - u_int64_t operator-(const Label &subtrahend) const; + Label operator+(uint64_t addend) const; + Label operator-(uint64_t subtrahend) const; + uint64_t operator-(const Label &subtrahend) const; // We could also provide == and != that work on undefined, but // related, labels. // Return true if this label's value is known. If VALUE_P is given, // set *VALUE_P to the known value if returning true. - bool IsKnownConstant(u_int64_t *value_p = NULL) const; + bool IsKnownConstant(uint64_t *value_p = NULL) const; // Return true if the offset from LABEL to this label is known. If // OFFSET_P is given, set *OFFSET_P to the offset when returning true. @@ -150,12 +150,12 @@ class Label { // m = l + 10; // l.IsKnownConstant(); // false // m.IsKnownConstant(); // false - // u_int64_t d; + // uint64_t d; // l.IsKnownOffsetFrom(m, &d); // true, and sets d to -10. // l-m // -10 // m-l // 10 // m.Value() // error: m's value is not known - bool IsKnownOffsetFrom(const Label &label, u_int64_t *offset_p = NULL) const; + bool IsKnownOffsetFrom(const Label &label, uint64_t *offset_p = NULL) const; private: // A label's value, or if that is not yet known, how the value is @@ -173,7 +173,7 @@ class Label { class Binding { public: Binding(); - Binding(u_int64_t addend); + Binding(uint64_t addend); ~Binding(); // Increment our reference count. @@ -186,7 +186,7 @@ class Label { // Update every binding on this binding's chain to point directly // to BINDING, or to be a constant, with addends adjusted // appropriately. - void Set(Binding *binding, u_int64_t value); + void Set(Binding *binding, uint64_t value); // Return what we know about the value of this binding. // - If this binding's value is a known constant, set BASE to @@ -198,7 +198,7 @@ class Label { // value. // - If this binding is unconstrained, set BASE to this, and leave // ADDEND unchanged. - void Get(Binding **base, u_int64_t *addend); + void Get(Binding **base, uint64_t *addend); private: // There are three cases: @@ -221,7 +221,7 @@ class Label { // binding on the chain to point directly to the final value, // adjusting addends as appropriate. Binding *base_; - u_int64_t addend_; + uint64_t addend_; // The number of Labels and Bindings pointing to this binding. // (When a binding points to itself, indicating a completely @@ -233,7 +233,7 @@ class Label { Binding *value_; }; -inline Label operator+(u_int64_t a, const Label &l) { return l + a; } +inline Label operator+(uint64_t a, const Label &l) { return l + a; } // Note that int-Label isn't defined, as negating a Label is not an // operation we support. @@ -288,7 +288,7 @@ class Section { // Append the SIZE bytes at DATA or the contents of STRING to the // end of this section. Return a reference to this section. - Section &Append(const u_int8_t *data, size_t size) { + Section &Append(const uint8_t *data, size_t size) { contents_.append(reinterpret_cast(data), size); return *this; }; @@ -299,7 +299,7 @@ class Section { // Append SIZE copies of BYTE to the end of this section. Return a // reference to this section. - Section &Append(size_t size, u_int8_t byte) { + Section &Append(size_t size, uint8_t byte) { contents_.append(size, (char) byte); return *this; } @@ -307,7 +307,7 @@ class Section { // Append NUMBER to this section. ENDIANNESS is the endianness to // use to write the number. SIZE is the length of the number in // bytes. Return a reference to this section. - Section &Append(Endianness endianness, size_t size, u_int64_t number); + Section &Append(Endianness endianness, size_t size, uint64_t number); Section &Append(Endianness endianness, size_t size, const Label &label); // Append SECTION to the end of this section. The labels SECTION @@ -352,12 +352,12 @@ class Section { // the compiler will properly sign-extend a signed value before // passing it to the function, at which point the function's // behavior is the same either way. - Section &L8(u_int8_t value) { contents_ += value; return *this; } - Section &B8(u_int8_t value) { contents_ += value; return *this; } - Section &D8(u_int8_t value) { contents_ += value; return *this; } - Section &L16(u_int16_t), &L32(u_int32_t), &L64(u_int64_t), - &B16(u_int16_t), &B32(u_int32_t), &B64(u_int64_t), - &D16(u_int16_t), &D32(u_int32_t), &D64(u_int64_t); + Section &L8(uint8_t value) { contents_ += value; return *this; } + Section &B8(uint8_t value) { contents_ += value; return *this; } + Section &D8(uint8_t value) { contents_ += value; return *this; } + Section &L16(uint16_t), &L32(uint32_t), &L64(uint64_t), + &B16(uint16_t), &B32(uint32_t), &B64(uint64_t), + &D16(uint16_t), &D32(uint32_t), &D64(uint64_t); Section &L8(const Label &label), &L16(const Label &label), &L32(const Label &label), &L64(const Label &label), &B8(const Label &label), &B16(const Label &label), @@ -399,13 +399,13 @@ class Section { // // Note that VALUE cannot be a Label (we would have to implement // relaxation). - Section &ULEB128(u_int64_t value); + Section &ULEB128(uint64_t value); // Jump to the next location aligned on an ALIGNMENT-byte boundary, // relative to the start of the section. Fill the gap with PAD_BYTE. // ALIGNMENT must be a power of two. Return a reference to this // section. - Section &Align(size_t alignment, u_int8_t pad_byte = 0); + Section &Align(size_t alignment, uint8_t pad_byte = 0); // Clear the contents of this section. void Clear(); diff --git a/src/common/test_assembler_unittest.cc b/src/common/test_assembler_unittest.cc index d4e95eff..94b5a5ce 100644 --- a/src/common/test_assembler_unittest.cc +++ b/src/common/test_assembler_unittest.cc @@ -60,7 +60,7 @@ TEST(ConstructLabelDeathTest, Undefined) { TEST(ConstructLabel, Constant) { Label l(0x060b9f974eaf301eULL); - u_int64_t v; + uint64_t v; EXPECT_TRUE(l.IsKnownConstant(&v)); EXPECT_EQ(v, 0x060b9f974eaf301eULL); EXPECT_EQ(l.Value(), 0x060b9f974eaf301eULL); @@ -69,7 +69,7 @@ TEST(ConstructLabel, Constant) { TEST(ConstructLabel, Copy) { Label l; Label m(l); - u_int64_t v; + uint64_t v; EXPECT_TRUE(l.IsKnownOffsetFrom(m, &v)); EXPECT_EQ(0U, v); } @@ -82,7 +82,7 @@ TEST(Assignment, UnconstrainedToUnconstrained) { l = m; EXPECT_EQ(0U, l-m); EXPECT_TRUE(l.IsKnownOffsetFrom(m)); - u_int64_t d; + uint64_t d; EXPECT_TRUE(l.IsKnownOffsetFrom(m, &d)); EXPECT_EQ(0U, d); EXPECT_FALSE(l.IsKnownConstant()); @@ -94,7 +94,7 @@ TEST(Assignment, UnconstrainedToRelated) { l = m; EXPECT_EQ(0U, l-m); EXPECT_TRUE(l.IsKnownOffsetFrom(m)); - u_int64_t d; + uint64_t d; EXPECT_TRUE(l.IsKnownOffsetFrom(m, &d)); EXPECT_EQ(0U, d); EXPECT_FALSE(l.IsKnownConstant()); @@ -106,7 +106,7 @@ TEST(Assignment, UnconstrainedToKnown) { l = m; EXPECT_EQ(0U, l-m); EXPECT_TRUE(l.IsKnownOffsetFrom(m)); - u_int64_t d; + uint64_t d; EXPECT_TRUE(l.IsKnownOffsetFrom(m, &d)); EXPECT_EQ(0U, d); EXPECT_TRUE(m.IsKnownConstant()); @@ -119,7 +119,7 @@ TEST(Assignment, RelatedToUnconstrained) { l = m; EXPECT_EQ(0U, l-n); EXPECT_TRUE(l.IsKnownOffsetFrom(n)); - u_int64_t d; + uint64_t d; EXPECT_TRUE(l.IsKnownOffsetFrom(n, &d)); EXPECT_EQ(0U, d); EXPECT_FALSE(l.IsKnownConstant()); @@ -132,7 +132,7 @@ TEST(Assignment, RelatedToRelated) { l = m; EXPECT_EQ(0U, n-o); EXPECT_TRUE(n.IsKnownOffsetFrom(o)); - u_int64_t d; + uint64_t d; EXPECT_TRUE(n.IsKnownOffsetFrom(o, &d)); EXPECT_EQ(0U, d); EXPECT_FALSE(l.IsKnownConstant()); @@ -234,7 +234,7 @@ TEST(Addition, LabelConstant) { Label l, m; m = l + 0x5248d93e8bbe9497ULL; EXPECT_TRUE(m.IsKnownOffsetFrom(l)); - u_int64_t d; + uint64_t d; EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d)); EXPECT_EQ(0x5248d93e8bbe9497ULL, d); EXPECT_FALSE(m.IsKnownConstant()); @@ -244,7 +244,7 @@ TEST(Addition, ConstantLabel) { Label l, m; m = 0xf51e94e00d6e3c84ULL + l; EXPECT_TRUE(m.IsKnownOffsetFrom(l)); - u_int64_t d; + uint64_t d; EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d)); EXPECT_EQ(0xf51e94e00d6e3c84ULL, d); EXPECT_FALSE(m.IsKnownConstant()); @@ -255,7 +255,7 @@ TEST(Addition, KnownLabelConstant) { l = 0x16286307042ce0d8ULL; m = l + 0x3fdddd91306719d7ULL; EXPECT_TRUE(m.IsKnownOffsetFrom(l)); - u_int64_t d; + uint64_t d; EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d)); EXPECT_EQ(0x3fdddd91306719d7ULL, d); EXPECT_TRUE(m.IsKnownConstant()); @@ -267,7 +267,7 @@ TEST(Addition, ConstantKnownLabel) { l = 0x50f62d0cdd1031deULL; m = 0x1b13462d8577c538ULL + l; EXPECT_TRUE(m.IsKnownOffsetFrom(l)); - u_int64_t d; + uint64_t d; EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d)); EXPECT_EQ(0x1b13462d8577c538ULL, d); EXPECT_TRUE(m.IsKnownConstant()); @@ -278,7 +278,7 @@ TEST(Subtraction, LabelConstant) { Label l, m; m = l - 0x0620884d21d3138eULL; EXPECT_TRUE(m.IsKnownOffsetFrom(l)); - u_int64_t d; + uint64_t d; EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d)); EXPECT_EQ(-0x0620884d21d3138eULL, d); EXPECT_FALSE(m.IsKnownConstant()); @@ -289,7 +289,7 @@ TEST(Subtraction, KnownLabelConstant) { l = 0x6237fbaf9ef7929eULL; m = l - 0x317730995d2ab6eeULL; EXPECT_TRUE(m.IsKnownOffsetFrom(l)); - u_int64_t d; + uint64_t d; EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d)); EXPECT_EQ(-0x317730995d2ab6eeULL, d); EXPECT_TRUE(m.IsKnownConstant()); @@ -475,10 +475,10 @@ TEST(LabelChain, AssignEndRelationBeforeForward) { b = a + 0x1; c = b + 0x10; d = c + 0x100; - EXPECT_EQ(-(u_int64_t)0x111U, a-x); - EXPECT_EQ(-(u_int64_t)0x110U, b-x); - EXPECT_EQ(-(u_int64_t)0x100U, c-x); - EXPECT_EQ(-(u_int64_t)0U, d-x); + EXPECT_EQ(-(uint64_t)0x111U, a-x); + EXPECT_EQ(-(uint64_t)0x110U, b-x); + EXPECT_EQ(-(uint64_t)0x100U, c-x); + EXPECT_EQ(-(uint64_t)0U, d-x); } TEST(LabelChain, AssignEndRelationBeforeBackward) { @@ -488,10 +488,10 @@ TEST(LabelChain, AssignEndRelationBeforeBackward) { d = c + 0x100; c = b + 0x10; b = a + 0x1; - EXPECT_EQ(-(u_int64_t)0x111U, a-x); - EXPECT_EQ(-(u_int64_t)0x110U, b-x); - EXPECT_EQ(-(u_int64_t)0x100U, c-x); - EXPECT_EQ(-(u_int64_t)0U, d-x); + EXPECT_EQ(-(uint64_t)0x111U, a-x); + EXPECT_EQ(-(uint64_t)0x110U, b-x); + EXPECT_EQ(-(uint64_t)0x100U, c-x); + EXPECT_EQ(-(uint64_t)0U, d-x); } TEST(LabelChain, AssignEndRelationAfterForward) { @@ -501,10 +501,10 @@ TEST(LabelChain, AssignEndRelationAfterForward) { c = b + 0x10; d = c + 0x100; x = d; - EXPECT_EQ(-(u_int64_t)0x111U, a-x); - EXPECT_EQ(-(u_int64_t)0x110U, b-x); - EXPECT_EQ(-(u_int64_t)0x100U, c-x); - EXPECT_EQ(-(u_int64_t)0x000U, d-x); + EXPECT_EQ(-(uint64_t)0x111U, a-x); + EXPECT_EQ(-(uint64_t)0x110U, b-x); + EXPECT_EQ(-(uint64_t)0x100U, c-x); + EXPECT_EQ(-(uint64_t)0x000U, d-x); } TEST(LabelChain, AssignEndRelationAfterBackward) { @@ -514,10 +514,10 @@ TEST(LabelChain, AssignEndRelationAfterBackward) { c = b + 0x10; b = a + 0x1; x = d; - EXPECT_EQ(-(u_int64_t)0x111U, a-x); - EXPECT_EQ(-(u_int64_t)0x110U, b-x); - EXPECT_EQ(-(u_int64_t)0x100U, c-x); - EXPECT_EQ(-(u_int64_t)0x000U, d-x); + EXPECT_EQ(-(uint64_t)0x111U, a-x); + EXPECT_EQ(-(uint64_t)0x110U, b-x); + EXPECT_EQ(-(uint64_t)0x100U, c-x); + EXPECT_EQ(-(uint64_t)0x000U, d-x); } TEST(LabelChain, AssignEndValueBeforeForward) { @@ -623,10 +623,10 @@ TEST(LabelChain, ConstructEndRelationAfterForward) { Label c(b + 0x10); Label d(c + 0x100); x = d; - EXPECT_EQ(-(u_int64_t)0x111U, a-x); - EXPECT_EQ(-(u_int64_t)0x110U, b-x); - EXPECT_EQ(-(u_int64_t)0x100U, c-x); - EXPECT_EQ(-(u_int64_t)0x000U, d-x); + EXPECT_EQ(-(uint64_t)0x111U, a-x); + EXPECT_EQ(-(uint64_t)0x110U, b-x); + EXPECT_EQ(-(uint64_t)0x100U, c-x); + EXPECT_EQ(-(uint64_t)0x000U, d-x); } TEST(LabelChain, ConstructEndValueAfterForward) { @@ -732,11 +732,11 @@ class SectionFixture { public: Section section; string contents; - static const u_int8_t data[]; + static const uint8_t data[]; static const size_t data_size; }; -const u_int8_t SectionFixture::data[] = { +const uint8_t SectionFixture::data[] = { 0x87, 0x4f, 0x43, 0x67, 0x30, 0xd0, 0xd4, 0x0e }; @@ -753,7 +753,7 @@ const u_int8_t SectionFixture::data[] = { #define ASSERT_BYTES(s, b) \ do \ { \ - static const u_int8_t expected_bytes[] = b; \ + static const uint8_t expected_bytes[] = b; \ ASSERT_EQ(sizeof(expected_bytes), s.size()); \ ASSERT_TRUE(memcmp(s.data(), (const char *) expected_bytes, \ sizeof(expected_bytes)) == 0); \ @@ -1361,7 +1361,7 @@ TEST_F(Append, Variety) { ASSERT_EQ(8 * 18U, section.Size()); ASSERT_TRUE(section.GetContents(&contents)); - static const u_int8_t expected[] = { + static const uint8_t expected[] = { 0x35, 0xa6, 0x6b, 0x28, 0xf7, 0xa8, 0x99, 0xa1, 0x61, 0x8b, 0x39, 0x44, 0x8f, 0x44, 0x40, 0x65, 0xa5, 0x0e, 0xc9, 0x1c, 0x5e, 0x87, 0xbf, 0xa4, 0x28, 0xb9, 0xf4, -- cgit v1.2.1