From ab98dcc986f5a27e972dad1735fe089154186cd9 Mon Sep 17 00:00:00 2001 From: avi Date: Mon, 21 Dec 2015 11:35:33 -0800 Subject: Switch to standard integer types in courgette/. BUG=138542 TBR=wfh@chromium.org NOPRESUBMIT=true Review URL: https://codereview.chromium.org/1543643002 Cr-Commit-Position: refs/heads/master@{#366439} --- courgette/adjustment_method.cc | 46 +++++---- courgette/adjustment_method.h | 2 +- courgette/adjustment_method_2.cc | 62 ++++++------ courgette/assembly_program.cc | 73 ++++++++------ courgette/assembly_program.h | 28 +++--- courgette/bsdiff_memory_unittest.cc | 2 + courgette/consecutive_range_visitor.h | 2 + courgette/consecutive_range_visitor_unittest.cc | 2 + courgette/courgette_tool.cc | 6 +- courgette/crc.cc | 8 +- courgette/crc.h | 5 +- courgette/difference_estimator.cc | 22 ++-- courgette/difference_estimator.h | 3 + courgette/disassembler.cc | 9 +- courgette/disassembler.h | 14 +-- courgette/disassembler_elf_32.cc | 14 +-- courgette/disassembler_elf_32.h | 11 +- courgette/disassembler_elf_32_arm.cc | 128 +++++++++++++----------- courgette/disassembler_elf_32_arm.h | 30 +++--- courgette/disassembler_elf_32_x86.cc | 27 ++--- courgette/disassembler_elf_32_x86.h | 9 +- courgette/disassembler_elf_32_x86_unittest.cc | 5 +- courgette/disassembler_win32_x64.cc | 98 +++++++++--------- courgette/disassembler_win32_x64.h | 47 +++++---- courgette/disassembler_win32_x64_unittest.cc | 6 +- courgette/disassembler_win32_x86.cc | 92 ++++++++--------- courgette/disassembler_win32_x86.h | 47 +++++---- courgette/disassembler_win32_x86_unittest.cc | 6 +- courgette/encode_decode_unittest.cc | 2 + courgette/encoded_program.cc | 127 +++++++++++------------ courgette/encoded_program.h | 19 ++-- courgette/encoded_program_fuzz_unittest.cc | 2 + courgette/encoded_program_unittest.cc | 39 ++++---- courgette/ensemble.cc | 6 +- courgette/ensemble.h | 12 ++- courgette/ensemble_apply.cc | 21 ++-- courgette/ensemble_create.cc | 3 +- courgette/image_utils.h | 31 +++--- courgette/image_utils_unittest.cc | 4 +- courgette/label_manager.cc | 7 +- courgette/label_manager.h | 5 +- courgette/label_manager_unittest.cc | 31 +++--- courgette/memory_allocator.cc | 5 +- courgette/memory_allocator.h | 15 +-- courgette/memory_allocator_unittest.cc | 2 + courgette/memory_monitor.cc | 1 + courgette/patch_generator_x86_32.h | 2 +- courgette/patcher_x86_32.h | 7 +- courgette/region.h | 19 ++-- courgette/rel32_finder_win32_x86.cc | 19 ++-- courgette/rel32_finder_win32_x86.h | 11 +- courgette/rel32_finder_win32_x86_unittest.cc | 13 ++- courgette/simple_delta.cc | 1 - courgette/streams.cc | 60 +++++------ courgette/streams.h | 30 +++--- courgette/streams_unittest.cc | 30 +++--- courgette/third_party/bsdiff.h | 9 +- courgette/third_party/bsdiff_apply.cc | 30 +++--- courgette/third_party/bsdiff_create.cc | 16 +-- courgette/third_party/paged_array.h | 4 +- courgette/third_party/qsufsort_unittest.cc | 2 + courgette/typedrva_unittest.cc | 28 +++--- courgette/types_elf.h | 13 +-- courgette/types_win_pe.h | 28 +++--- courgette/versioning_unittest.cc | 3 +- 65 files changed, 797 insertions(+), 664 deletions(-) diff --git a/courgette/adjustment_method.cc b/courgette/adjustment_method.cc index 2bc9269..ce93a21 100644 --- a/courgette/adjustment_method.cc +++ b/courgette/adjustment_method.cc @@ -4,6 +4,9 @@ #include "courgette/adjustment_method.h" +#include +#include + #include #include #include @@ -11,8 +14,8 @@ #include #include -#include "base/basictypes.h" #include "base/logging.h" +#include "base/macros.h" #include "base/strings/string_number_conversions.h" #include "base/strings/stringprintf.h" #include "courgette/assembly_program.h" @@ -41,10 +44,10 @@ class LabelInfo { Label* label_; // The label that this info a surrogate for. // Information used only in debugging messages. - uint32 is_model_ : 1; // Is the label in the model? - uint32 debug_index_ : 31; // An unique small number for naming the label. + uint32_t is_model_ : 1; // Is the label in the model? + uint32_t debug_index_ : 31; // An unique small number for naming the label. - uint32 refs_; // Number of times this Label is referenced. + uint32_t refs_; // Number of times this Label is referenced. LabelInfo* assignment_; // Label from other program corresponding to this. @@ -53,7 +56,7 @@ class LabelInfo { LabelInfo* next_addr_; // Label(Info) at next highest address. LabelInfo* prev_addr_; // Label(Info) at next lowest address. - std::vector positions_; // Offsets into the trace of references. + std::vector positions_; // Offsets into the trace of references. // Just a no-argument constructor and copy constructor. Actual LabelInfo // objects are allocated in std::pair structs in a std::map. @@ -149,9 +152,7 @@ struct Node { bool in_queue_; bool Extended() const { return !edges_.empty(); } - uint32 Weight() const { - return edges_in_frequency_order.front()->count_; - } + uint32_t Weight() const { return edges_in_frequency_order.front()->count_; } }; static std::string ToString(Node* node) { @@ -190,8 +191,8 @@ struct OrderNodeByWeightDecreasing { bool operator()(Node* a, Node* b) const { // (Maybe tie-break on total count, followed by lowest assigned node indexes // in path.) - uint32 a_weight = a->Weight(); - uint32 b_weight = b->Weight(); + uint32_t a_weight = a->Weight(); + uint32_t b_weight = b->Weight(); if (a_weight != b_weight) return a_weight > b_weight; if (a->length_ != b->length_) @@ -254,7 +255,7 @@ class AssignmentProblem { void SkipCommittedLabels(Node* node) { ExtendNode(node, p_trace_); - uint32 skipped = 0; + uint32_t skipped = 0; while (!node->edges_in_frequency_order.empty() && node->edges_in_frequency_order.front()->in_edge_->assignment_) { ++skipped; @@ -421,9 +422,9 @@ class AssignmentProblem { } } - uint32 TryExtendSequence(uint32 p_pos_start, uint32 m_pos_start) { - uint32 p_pos = p_pos_start + 1; - uint32 m_pos = m_pos_start + 1; + uint32_t TryExtendSequence(uint32_t p_pos_start, uint32_t m_pos_start) { + uint32_t p_pos = p_pos_start + 1; + uint32_t m_pos = m_pos_start + 1; while (p_pos < p_trace_.size() && m_pos < m_trace_.size()) { LabelInfo* p_info = p_trace_[p_pos]; @@ -456,12 +457,13 @@ class AssignmentProblem { return p_pos - p_pos_start; } - uint32 TryExtendSequenceBackwards(uint32 p_pos_start, uint32 m_pos_start) { + uint32_t TryExtendSequenceBackwards(uint32_t p_pos_start, + uint32_t m_pos_start) { if (p_pos_start == 0 || m_pos_start == 0) return 0; - uint32 p_pos = p_pos_start - 1; - uint32 m_pos = m_pos_start - 1; + uint32_t p_pos = p_pos_start - 1; + uint32_t m_pos = m_pos_start - 1; while (p_pos > 0 && m_pos > 0) { LabelInfo* p_info = p_trace_[p_pos]; @@ -522,7 +524,7 @@ class AssignmentProblem { Node* MakeRootNode(const Trace& trace) { Node* node = new Node(NULL, NULL); all_nodes_.push_back(node); - for (uint32 i = 0; i < trace.size(); ++i) { + for (uint32_t i = 0; i < trace.size(); ++i) { ++node->count_; node->places_.push_back(i); } @@ -534,7 +536,7 @@ class AssignmentProblem { if (node->Extended()) return; for (size_t i = 0; i < node->places_.size(); ++i) { - uint32 index = node->places_.at(i); + uint32_t index = node->places_.at(i); if (index < trace.size()) { LabelInfo* item = trace.at(index); Node*& slot = node->edges_[item]; @@ -633,11 +635,11 @@ class GraphAdjuster : public AdjustmentMethod { } void ReferenceLabel(Trace* trace, Label* label, bool is_model) { - trace->push_back(MakeLabelInfo(label, is_model, - static_cast(trace->size()))); + trace->push_back( + MakeLabelInfo(label, is_model, static_cast(trace->size()))); } - LabelInfo* MakeLabelInfo(Label* label, bool is_model, uint32 position) { + LabelInfo* MakeLabelInfo(Label* label, bool is_model, uint32_t position) { LabelInfo& slot = label_infos_[label]; if (slot.label_ == NULL) { slot.label_ = label; diff --git a/courgette/adjustment_method.h b/courgette/adjustment_method.h index 0ecf04d..a19ec61 100644 --- a/courgette/adjustment_method.h +++ b/courgette/adjustment_method.h @@ -5,7 +5,7 @@ #ifndef COURGETTE_ADJUSTMENT_METHOD_H_ #define COURGETTE_ADJUSTMENT_METHOD_H_ -#include "base/basictypes.h" +#include "base/macros.h" namespace courgette { diff --git a/courgette/adjustment_method_2.cc b/courgette/adjustment_method_2.cc index 57f02ac..d783cda 100644 --- a/courgette/adjustment_method_2.cc +++ b/courgette/adjustment_method_2.cc @@ -4,6 +4,9 @@ #include "courgette/adjustment_method.h" +#include +#include + #include #include #include @@ -12,9 +15,9 @@ #include #include -#include "base/basictypes.h" #include "base/format_macros.h" #include "base/logging.h" +#include "base/macros.h" #include "base/strings/stringprintf.h" #include "base/time/time.h" #include "courgette/assembly_program.h" @@ -176,16 +179,16 @@ class LabelInfo { Label* label_; // The label that this info a surrogate for. - uint32 is_model_ : 1; // Is the label in the model? - uint32 debug_index_ : 31; // A small number for naming the label in debug - // output. The pair (is_model_, debug_index_) is - // unique. + uint32_t is_model_ : 1; // Is the label in the model? + uint32_t debug_index_ : 31; // A small number for naming the label in debug + // output. The pair (is_model_, debug_index_) is + // unique. int refs_; // Number of times this Label is referenced. LabelInfo* assignment_; // Label from other program corresponding to this. - std::vector positions_; // Offsets into the trace of references. + std::vector positions_; // Offsets into the trace of references. private: AssignmentCandidates* candidates_; @@ -213,7 +216,7 @@ class LabelInfoMaker { public: LabelInfoMaker() : debug_label_index_gen_(0) {} - LabelInfo* MakeLabelInfo(Label* label, bool is_model, uint32 position) { + LabelInfo* MakeLabelInfo(Label* label, bool is_model, uint32_t position) { LabelInfo& slot = label_infos_[label]; if (slot.label_ == NULL) { slot.label_ = label; @@ -364,7 +367,7 @@ LabelInfo::~LabelInfo() { // position of one of the occurrences in the Trace. class Shingle { public: - static const uint8 kWidth = 5; + static const uint8_t kWidth = 5; struct InterningLess { bool operator()(const Shingle& a, const Shingle& b) const; @@ -388,7 +391,7 @@ class Shingle { LabelInfo* at(size_t i) const { return trace_[exemplar_position_ + i]; } void add_position(size_t position) { - positions_.push_back(static_cast(position)); + positions_.push_back(static_cast(position)); } int position_count() const { return static_cast(positions_.size()); } @@ -414,7 +417,7 @@ class Shingle { const Trace& trace_; // The shingle lives inside trace_. size_t exemplar_position_; // At this position (and other positions). - std::vector positions_; // Includes exemplar_position_. + std::vector positions_; // Includes exemplar_position_. ShinglePattern* pattern_; // Pattern changes as LabelInfos are assigned. @@ -430,7 +433,7 @@ class Shingle { std::string ToString(const Shingle* instance) { std::string s; const char* sep = "<"; - for (uint8 i = 0; i < Shingle::kWidth; ++i) { + for (uint8_t i = 0; i < Shingle::kWidth; ++i) { // base::StringAppendF(&s, "%s%x ", sep, instance.at(i)->label_->rva_); s += sep; s += ToString(instance->at(i)); @@ -446,7 +449,7 @@ std::string ToString(const Shingle* instance) { bool Shingle::InterningLess::operator()( const Shingle& a, const Shingle& b) const { - for (uint8 i = 0; i < kWidth; ++i) { + for (uint8_t i = 0; i < kWidth; ++i) { LabelInfo* info_a = a.at(i); LabelInfo* info_b = b.at(i); if (info_a->label_->rva_ < info_b->label_->rva_) @@ -478,11 +481,11 @@ class ShinglePattern { // --> struct Index { explicit Index(const Shingle* instance); - uint8 kinds_[Shingle::kWidth]; - uint8 variables_; - uint8 unique_variables_; - uint8 first_variable_index_; - uint32 hash_; + uint8_t kinds_[Shingle::kWidth]; + uint8_t variables_; + uint8_t unique_variables_; + uint8_t first_variable_index_; + uint32_t hash_; int assigned_indexes_[Shingle::kWidth]; }; @@ -526,10 +529,10 @@ std::string ToString(const ShinglePattern::Index* index) { } else { base::StringAppendF(&s, "<%d: ", index->variables_); const char* sep = ""; - for (uint8 i = 0; i < Shingle::kWidth; ++i) { + for (uint8_t i = 0; i < Shingle::kWidth; ++i) { s += sep; sep = ", "; - uint32 kind = index->kinds_[i]; + uint32_t kind = index->kinds_[i]; int offset = kind & ShinglePattern::kOffsetMask; if (kind & ShinglePattern::kVariable) base::StringAppendF(&s, "V%d", offset); @@ -622,7 +625,7 @@ struct ShinglePatternIndexLess { if (a.hash_ < b.hash_) return true; if (a.hash_ > b.hash_) return false; - for (uint8 i = 0; i < Shingle::kWidth; ++i) { + for (uint8_t i = 0; i < Shingle::kWidth; ++i) { if (a.kinds_[i] < b.kinds_[i]) return true; if (a.kinds_[i] > b.kinds_[i]) return false; if ((a.kinds_[i] & ShinglePattern::kVariable) == 0) { @@ -636,22 +639,22 @@ struct ShinglePatternIndexLess { } }; -static uint32 hash_combine(uint32 h, uint32 v) { +static uint32_t hash_combine(uint32_t h, uint32_t v) { h += v; return (h * (37 + 0x0000d100)) ^ (h >> 13); } ShinglePattern::Index::Index(const Shingle* instance) { - uint32 hash = 0; + uint32_t hash = 0; variables_ = 0; unique_variables_ = 0; first_variable_index_ = 255; - for (uint8 i = 0; i < Shingle::kWidth; ++i) { + for (uint8_t i = 0; i < Shingle::kWidth; ++i) { LabelInfo* info = instance->at(i); - uint8 kind = 0; + uint8_t kind = 0; int code = -1; - uint8 j = 0; + uint8_t j = 0; for ( ; j < i; ++j) { if (info == instance->at(j)) { // Duplicate LabelInfo kind = kinds_[j]; @@ -942,7 +945,7 @@ class AssignmentProblem { // For the positions in |info|, find the shingles that overlap that position. void AddAffectedPositions(LabelInfo* info, ShingleSet* affected_shingles) { - const uint8 kWidth = Shingle::kWidth; + const uint8_t kWidth = Shingle::kWidth; for (size_t i = 0; i < info->positions_.size(); ++i) { size_t position = info->positions_[i]; // Find bounds to the subrange of |trace_| we are in. @@ -1059,7 +1062,7 @@ class AssignmentProblem { // int score = p1; // ? weigh all equally?? int score = std::min(p1, m1); - for (uint8 i = 0; i < Shingle::kWidth; ++i) { + for (uint8_t i = 0; i < Shingle::kWidth; ++i) { LabelInfo* program_info = program_instance->at(i); LabelInfo* model_info = model_instance->at(i); if ((model_info->assignment_ == NULL) != @@ -1275,9 +1278,8 @@ class Adjuster : public AdjustmentMethod { } void ReferenceLabel(Trace* trace, Label* label, bool is_model) { - trace->push_back( - label_info_maker_.MakeLabelInfo(label, is_model, - static_cast(trace->size()))); + trace->push_back(label_info_maker_.MakeLabelInfo( + label, is_model, static_cast(trace->size()))); } AssemblyProgram* prog_; // Program to be adjusted, owned by caller. diff --git a/courgette/assembly_program.cc b/courgette/assembly_program.cc index f050390..0767892 100644 --- a/courgette/assembly_program.cc +++ b/courgette/assembly_program.cc @@ -5,6 +5,8 @@ #include "courgette/assembly_program.h" #include +#include +#include #include #include #include @@ -52,22 +54,20 @@ class ElfARMRelocsInstruction : public Instruction { // Emits a single byte. class ByteInstruction : public Instruction { public: - explicit ByteInstruction(uint8 value) : Instruction(DEFBYTE, value) {} - uint8 byte_value() const { return info_; } + explicit ByteInstruction(uint8_t value) : Instruction(DEFBYTE, value) {} + uint8_t byte_value() const { return info_; } }; // Emits a single byte. class BytesInstruction : public Instruction { public: - BytesInstruction(const uint8* values, size_t len) - : Instruction(DEFBYTES, 0), - values_(values), - len_(len) {} - const uint8* byte_values() const { return values_; } + BytesInstruction(const uint8_t* values, size_t len) + : Instruction(DEFBYTES, 0), values_(values), len_(len) {} + const uint8_t* byte_values() const { return values_; } size_t len() const { return len_; } private: - const uint8* values_; + const uint8_t* values_; size_t len_; }; @@ -87,19 +87,25 @@ class InstructionWithLabel : public Instruction { // a specially-compressed ARM op. class InstructionWithLabelARM : public InstructionWithLabel { public: - InstructionWithLabelARM(OP op, uint16 compressed_op, Label* label, - const uint8* arm_op, uint16 op_size) - : InstructionWithLabel(op, label), compressed_op_(compressed_op), - arm_op_(arm_op), op_size_(op_size) { + InstructionWithLabelARM(OP op, + uint16_t compressed_op, + Label* label, + const uint8_t* arm_op, + uint16_t op_size) + : InstructionWithLabel(op, label), + compressed_op_(compressed_op), + arm_op_(arm_op), + op_size_(op_size) { if (label == NULL) NOTREACHED(); } - uint16 compressed_op() const { return compressed_op_; } - const uint8* arm_op() const { return arm_op_; } - uint16 op_size() const { return op_size_; } + uint16_t compressed_op() const { return compressed_op_; } + const uint8_t* arm_op() const { return arm_op_; } + uint16_t op_size() const { return op_size_; } + private: - uint16 compressed_op_; - const uint8* arm_op_; - uint16 op_size_; + uint16_t compressed_op_; + const uint8_t* arm_op_; + uint16_t op_size_; }; } // namespace @@ -143,11 +149,11 @@ CheckBool AssemblyProgram::EmitOriginInstruction(RVA rva) { return Emit(ScopedInstruction(UncheckedNew(rva))); } -CheckBool AssemblyProgram::EmitByteInstruction(uint8 byte) { +CheckBool AssemblyProgram::EmitByteInstruction(uint8_t byte) { return EmitShared(GetByteInstruction(byte)); } -CheckBool AssemblyProgram::EmitBytesInstruction(const uint8* values, +CheckBool AssemblyProgram::EmitBytesInstruction(const uint8_t* values, size_t len) { return Emit(ScopedInstruction(UncheckedNew(values, len))); } @@ -157,8 +163,10 @@ CheckBool AssemblyProgram::EmitRel32(Label* label) { ScopedInstruction(UncheckedNew(REL32, label))); } -CheckBool AssemblyProgram::EmitRel32ARM(uint16 op, Label* label, - const uint8* arm_op, uint16 op_size) { +CheckBool AssemblyProgram::EmitRel32ARM(uint16_t op, + Label* label, + const uint8_t* arm_op, + uint16_t op_size) { return Emit(ScopedInstruction(UncheckedNew( REL32ARM, op, label, arm_op, op_size))); } @@ -324,7 +332,7 @@ void AssemblyProgram::AssignRemainingIndexes(RVAToLabel* labels) { if (prev) prev_index = prev->index_; else - prev_index = static_cast(available.size()); + prev_index = static_cast(available.size()); if (prev_index != 0 && prev_index != Label::kNoIndex && available.at(prev_index - 1)) { @@ -400,14 +408,14 @@ EncodedProgram* AssemblyProgram::Encode() const { break; } case DEFBYTE: { - uint8 b = static_cast(instruction)->byte_value(); + uint8_t b = static_cast(instruction)->byte_value(); if (!encoded->AddCopy(1, &b)) return NULL; break; } case DEFBYTES: { - const uint8* byte_values = - static_cast(instruction)->byte_values(); + const uint8_t* byte_values = + static_cast(instruction)->byte_values(); size_t len = static_cast(instruction)->len(); if (!encoded->AddCopy(len, byte_values)) @@ -423,9 +431,8 @@ EncodedProgram* AssemblyProgram::Encode() const { case REL32ARM: { Label* label = static_cast(instruction)->label(); - uint16 compressed_op = - static_cast(instruction)-> - compressed_op(); + uint16_t compressed_op = + static_cast(instruction)->compressed_op(); if (!encoded->AddRel32ARM(compressed_op, label->index_)) return NULL; break; @@ -466,7 +473,7 @@ EncodedProgram* AssemblyProgram::Encode() const { return encoded.release(); } -Instruction* AssemblyProgram::GetByteInstruction(uint8 byte) { +Instruction* AssemblyProgram::GetByteInstruction(uint8_t byte) { if (!byte_instruction_cache_) { Instruction** ram = nullptr; if (!base::UncheckedMalloc(sizeof(Instruction*) * 256, @@ -477,7 +484,7 @@ Instruction* AssemblyProgram::GetByteInstruction(uint8 byte) { for (int i = 0; i < 256; ++i) { byte_instruction_cache_[i] = - UncheckedNew(static_cast(i)); + UncheckedNew(static_cast(i)); if (!byte_instruction_cache_[i]) { for (int j = 0; j < i; ++j) UncheckedDelete(byte_instruction_cache_[j]); @@ -526,9 +533,9 @@ CheckBool AssemblyProgram::TrimLabels() { Label* label = static_cast(instruction)->label(); if (label->count_ <= lower_limit) { - const uint8* arm_op = + const uint8_t* arm_op = static_cast(instruction)->arm_op(); - uint16 op_size = + uint16_t op_size = static_cast(instruction)->op_size(); if (op_size < 1) diff --git a/courgette/assembly_program.h b/courgette/assembly_program.h index 88cf2e8..36dc369 100644 --- a/courgette/assembly_program.h +++ b/courgette/assembly_program.h @@ -5,13 +5,15 @@ #ifndef COURGETTE_ASSEMBLY_PROGRAM_H_ #define COURGETTE_ASSEMBLY_PROGRAM_H_ +#include +#include + #include #include #include -#include "base/basictypes.h" +#include "base/macros.h" #include "base/memory/scoped_ptr.h" - #include "courgette/disassembler.h" #include "courgette/image_utils.h" #include "courgette/memory_allocator.h" @@ -47,8 +49,8 @@ class Instruction { explicit Instruction(OP op) : op_(op), info_(0) {} Instruction(OP op, unsigned int info) : op_(op), info_(info) {} - uint32 op_ : 4; // A few bits to store the OP code. - uint32 info_ : 28; // Remaining bits in first word available to subclass. + uint32_t op_ : 4; // A few bits to store the OP code. + uint32_t info_ : 28; // Remaining bits in first word available to subclass. private: DISALLOW_COPY_AND_ASSIGN(Instruction); @@ -82,7 +84,7 @@ class AssemblyProgram { ExecutableType kind() const { return kind_; } - void set_image_base(uint64 image_base) { image_base_ = image_base; } + void set_image_base(uint64_t image_base) { image_base_ = image_base; } // Instructions will be assembled in the order they are emitted. @@ -99,19 +101,21 @@ class AssemblyProgram { CheckBool EmitOriginInstruction(RVA rva) WARN_UNUSED_RESULT; // Generates a single byte of data or machine instruction. - CheckBool EmitByteInstruction(uint8 byte) WARN_UNUSED_RESULT; + CheckBool EmitByteInstruction(uint8_t byte) WARN_UNUSED_RESULT; // Generates multiple bytes of data or machine instructions. - CheckBool EmitBytesInstruction(const uint8* value, size_t len) - WARN_UNUSED_RESULT; + CheckBool EmitBytesInstruction(const uint8_t* value, + size_t len) WARN_UNUSED_RESULT; // Generates 4-byte relative reference to address of 'label'. CheckBool EmitRel32(Label* label) WARN_UNUSED_RESULT; // Generates 4-byte relative reference to address of 'label' for // ARM. - CheckBool EmitRel32ARM(uint16 op, Label* label, const uint8* arm_op, - uint16 op_size) WARN_UNUSED_RESULT; + CheckBool EmitRel32ARM(uint16_t op, + Label* label, + const uint8_t* arm_op, + uint16_t op_size) WARN_UNUSED_RESULT; // Generates 4-byte absolute reference to address of 'label'. CheckBool EmitAbs32(Label* label) WARN_UNUSED_RESULT; @@ -171,10 +175,10 @@ class AssemblyProgram { static void AssignRemainingIndexes(RVAToLabel* labels); // Sharing instructions that emit a single byte saves a lot of space. - Instruction* GetByteInstruction(uint8 byte); + Instruction* GetByteInstruction(uint8_t byte); scoped_ptr byte_instruction_cache_; - uint64 image_base_; // Desired or mandated base address of image. + uint64_t image_base_; // Desired or mandated base address of image. InstructionVector instructions_; // All the instructions in program. diff --git a/courgette/bsdiff_memory_unittest.cc b/courgette/bsdiff_memory_unittest.cc index fe9fae6..5274565 100644 --- a/courgette/bsdiff_memory_unittest.cc +++ b/courgette/bsdiff_memory_unittest.cc @@ -4,6 +4,8 @@ #include "courgette/third_party/bsdiff.h" +#include + #include "courgette/base_test_unittest.h" #include "courgette/courgette.h" #include "courgette/streams.h" diff --git a/courgette/consecutive_range_visitor.h b/courgette/consecutive_range_visitor.h index 562409d..f911154 100644 --- a/courgette/consecutive_range_visitor.h +++ b/courgette/consecutive_range_visitor.h @@ -5,6 +5,8 @@ #ifndef COURGETTE_CONSECUTIVE_RANGE_VISITOR_H_ #define COURGETTE_CONSECUTIVE_RANGE_VISITOR_H_ +#include + #include #include "base/macros.h" diff --git a/courgette/consecutive_range_visitor_unittest.cc b/courgette/consecutive_range_visitor_unittest.cc index 648a6d7..7e38b05 100644 --- a/courgette/consecutive_range_visitor_unittest.cc +++ b/courgette/consecutive_range_visitor_unittest.cc @@ -4,6 +4,8 @@ #include "courgette/consecutive_range_visitor.h" +#include + #include #include "testing/gtest/include/gtest/gtest.h" diff --git a/courgette/courgette_tool.cc b/courgette/courgette_tool.cc index 962e078..88c346b 100644 --- a/courgette/courgette_tool.cc +++ b/courgette/courgette_tool.cc @@ -2,11 +2,13 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +#include +#include + #include #include #include "base/at_exit.h" -#include "base/basictypes.h" #include "base/command_line.h" #include "base/files/file_path.h" #include "base/files/file_util.h" @@ -48,7 +50,7 @@ void Problem(const char* format, ...) { } std::string ReadOrFail(const base::FilePath& file_name, const char* kind) { - int64 file_size = 0; + int64_t file_size = 0; if (!base::GetFileSize(file_name, &file_size)) Problem("Can't read %s file.", kind); std::string buffer; diff --git a/courgette/crc.cc b/courgette/crc.cc index 28a0f9c..2b86b68 100644 --- a/courgette/crc.cc +++ b/courgette/crc.cc @@ -4,6 +4,9 @@ #include "courgette/crc.h" +#include +#include + #ifdef COURGETTE_USE_CRC_LIB # include "zlib.h" #else @@ -12,12 +15,11 @@ extern "C" { } #endif -#include "base/basictypes.h" namespace courgette { -uint32 CalculateCrc(const uint8* buffer, size_t size) { - uint32 crc; +uint32_t CalculateCrc(const uint8_t* buffer, size_t size) { + uint32_t crc; #ifdef COURGETTE_USE_CRC_LIB // Calculate Crc by calling CRC method in zlib diff --git a/courgette/crc.h b/courgette/crc.h index c3662bb..b0c3323 100644 --- a/courgette/crc.h +++ b/courgette/crc.h @@ -5,13 +5,14 @@ #ifndef COURGETTE_CRC_H_ #define COURGETTE_CRC_H_ -#include "base/basictypes.h" +#include +#include namespace courgette { // Calculates Crc of the given buffer by calling CRC method in LZMA SDK // -uint32 CalculateCrc(const uint8* buffer, size_t size); +uint32_t CalculateCrc(const uint8_t* buffer, size_t size); } // namespace courgette #endif // COURGETTE_CRC_H_ diff --git a/courgette/difference_estimator.cc b/courgette/difference_estimator.cc index 82c23ee..8b7aa29 100644 --- a/courgette/difference_estimator.cc +++ b/courgette/difference_estimator.cc @@ -8,7 +8,11 @@ #include "courgette/difference_estimator.h" +#include +#include + #include "base/containers/hash_tables.h" +#include "base/macros.h" namespace courgette { @@ -21,9 +25,9 @@ namespace { static_assert(kTupleSize >= 4 && kTupleSize <= 8, "kTupleSize should be between 4 and 8"); -size_t HashTuple(const uint8* source) { - size_t hash1 = *reinterpret_cast(source); - size_t hash2 = *reinterpret_cast(source + kTupleSize - 4); +size_t HashTuple(const uint8_t* source) { + size_t hash1 = *reinterpret_cast(source); + size_t hash2 = *reinterpret_cast(source + kTupleSize - 4); size_t hash = ((hash1 * 17 + hash2 * 37) + (hash1 >> 17)) ^ (hash2 >> 23); return hash; } @@ -43,9 +47,9 @@ class DifferenceEstimator::Base { void Init() { if (region_.length() < kTupleSize) return; - const uint8* start = region_.start(); - const uint8* end = region_.end() - (kTupleSize - 1); - for (const uint8* p = start; p < end; ++p) { + const uint8_t* start = region_.start(); + const uint8_t* end = region_.end() - (kTupleSize - 1); + for (const uint8_t* p = start; p < end; ++p) { size_t hash = HashTuple(p); hashes_.insert(hash); } @@ -99,10 +103,10 @@ DifferenceEstimator::Subject* DifferenceEstimator::MakeSubject( size_t DifferenceEstimator::Measure(Base* base, Subject* subject) { size_t mismatches = 0; if (subject->region().length() >= kTupleSize) { - const uint8* start = subject->region().start(); - const uint8* end = subject->region().end() - (kTupleSize - 1); + const uint8_t* start = subject->region().start(); + const uint8_t* end = subject->region().end() - (kTupleSize - 1); - const uint8* p = start; + const uint8_t* p = start; while (p < end) { size_t hash = HashTuple(p); if (base->hashes_.find(hash) == base->hashes_.end()) { diff --git a/courgette/difference_estimator.h b/courgette/difference_estimator.h index 295ff93..690c840 100644 --- a/courgette/difference_estimator.h +++ b/courgette/difference_estimator.h @@ -8,8 +8,11 @@ #ifndef COURGETTE_DIFFERENCE_ESTIMATOR_H_ #define COURGETTE_DIFFERENCE_ESTIMATOR_H_ +#include + #include +#include "base/macros.h" #include "courgette/region.h" namespace courgette { diff --git a/courgette/disassembler.cc b/courgette/disassembler.cc index f146b4e..363d6e4 100644 --- a/courgette/disassembler.cc +++ b/courgette/disassembler.cc @@ -4,11 +4,13 @@ #include "courgette/disassembler.h" +#include +#include + #include #include #include -#include "base/basictypes.h" #include "base/logging.h" #include "courgette/assembly_program.h" @@ -101,15 +103,14 @@ void DeleteAssemblyProgram(AssemblyProgram* program) { Disassembler::Disassembler(const void* start, size_t length) : failure_reason_("uninitialized") { - - start_ = reinterpret_cast(start); + start_ = reinterpret_cast(start); length_ = length; end_ = start_ + length_; }; Disassembler::~Disassembler() {}; -const uint8* Disassembler::OffsetToPointer(size_t offset) const { +const uint8_t* Disassembler::OffsetToPointer(size_t offset) const { assert(start_ + offset <= end_); return start_ + offset; } diff --git a/courgette/disassembler.h b/courgette/disassembler.h index abbec3a..e833cfa 100644 --- a/courgette/disassembler.h +++ b/courgette/disassembler.h @@ -5,8 +5,10 @@ #ifndef COURGETTE_DISASSEMBLER_H_ #define COURGETTE_DISASSEMBLER_H_ -#include "base/basictypes.h" +#include +#include +#include "base/macros.h" #include "courgette/courgette.h" #include "courgette/image_utils.h" @@ -34,12 +36,12 @@ class Disassembler { // Returns the length of the source executable. May reduce after ParseHeader. size_t length() const { return length_; } - const uint8* start() const { return start_; } - const uint8* end() const { return end_; } + const uint8_t* start() const { return start_; } + const uint8_t* end() const { return end_; } // Returns a pointer into the memory copy of the file format. // FileOffsetToPointer(0) returns a pointer to the start of the file format. - const uint8* OffsetToPointer(size_t offset) const; + const uint8_t* OffsetToPointer(size_t offset) const; protected: Disassembler(const void* start, size_t length); @@ -65,8 +67,8 @@ class Disassembler { // the total data. // size_t length_; // In current memory. - const uint8* start_; // In current memory, base for 'file offsets'. - const uint8* end_; // In current memory. + const uint8_t* start_; // In current memory, base for 'file offsets'. + const uint8_t* end_; // In current memory. DISALLOW_COPY_AND_ASSIGN(Disassembler); }; diff --git a/courgette/disassembler_elf_32.cc b/courgette/disassembler_elf_32.cc index be420d4..c6139a8 100644 --- a/courgette/disassembler_elf_32.cc +++ b/courgette/disassembler_elf_32.cc @@ -4,11 +4,13 @@ #include "courgette/disassembler_elf_32.h" +#include +#include + #include #include #include -#include "base/basictypes.h" #include "base/logging.h" #include "base/memory/scoped_vector.h" @@ -182,7 +184,7 @@ CheckBool DisassemblerElf32::RVAToFileOffset(Elf32_Addr addr, RVA DisassemblerElf32::FileOffsetToRVA(size_t offset) const { // File offsets can be 64 bit values, but we are dealing with 32 // bit executables and so only need to support 32bit file sizes. - uint32 offset32 = (uint32)offset; + uint32_t offset32 = (uint32_t)offset; for (int i = 0; i < SectionHeaderCount(); i++) { @@ -240,7 +242,7 @@ CheckBool DisassemblerElf32::RVAsToOffsets(ScopedVector* rvas) { CheckBool DisassemblerElf32::ParseFile(AssemblyProgram* program) { // Walk all the bytes in the file, whether or not in a section. - uint32 file_offset = 0; + uint32_t file_offset = 0; std::vector abs_offsets; @@ -370,8 +372,7 @@ CheckBool DisassemblerElf32::ParseProgbitsSection( if (*current_abs_offset != end_abs_offset && file_offset == **current_abs_offset) { - - const uint8* p = OffsetToPointer(file_offset); + const uint8_t* p = OffsetToPointer(file_offset); RVA target_rva = Read32LittleEndian(p); if (!program->EmitAbs32(program->FindOrMakeAbs32Label(target_rva))) @@ -383,8 +384,7 @@ CheckBool DisassemblerElf32::ParseProgbitsSection( if (*current_rel != end_rel && file_offset == (**current_rel)->get_offset()) { - - uint32 relative_target = (**current_rel)->relative_target(); + uint32_t relative_target = (**current_rel)->relative_target(); // This cast is for 64 bit systems, and is only safe because we // are working on 32 bit executables. RVA target_rva = (RVA)(origin + (file_offset - origin_offset) + diff --git a/courgette/disassembler_elf_32.h b/courgette/disassembler_elf_32.h index 608c73a..110dd71 100644 --- a/courgette/disassembler_elf_32.h +++ b/courgette/disassembler_elf_32.h @@ -5,7 +5,10 @@ #ifndef COURGETTE_DISASSEMBLER_ELF_32_H_ #define COURGETTE_DISASSEMBLER_ELF_32_H_ -#include "base/basictypes.h" +#include +#include + +#include "base/macros.h" #include "base/memory/scoped_vector.h" #include "courgette/assembly_program.h" #include "courgette/disassembler.h" @@ -56,13 +59,13 @@ class DisassemblerElf32 : public Disassembler { } // Computes the relative jump's offset from the op in p. - virtual CheckBool ComputeRelativeTarget(const uint8* op_pointer) = 0; + virtual CheckBool ComputeRelativeTarget(const uint8_t* op_pointer) = 0; // Emits the courgette instruction corresponding to the RVA type. virtual CheckBool EmitInstruction(AssemblyProgram* program, RVA target_rva) = 0; - virtual uint16 op_size() const = 0; + virtual uint16_t op_size() const = 0; static bool IsLessThan(TypedRVA *a, TypedRVA *b) { return a->rva() < b->rva(); @@ -109,7 +112,7 @@ class DisassemblerElf32 : public Disassembler { return section_header_table_ + id; } - const uint8 *SectionBody(int id) const { + const uint8_t* SectionBody(int id) const { return OffsetToPointer(SectionHeader(id)->sh_offset); } diff --git a/courgette/disassembler_elf_32_arm.cc b/courgette/disassembler_elf_32_arm.cc index 800a64c..f6490d9 100644 --- a/courgette/disassembler_elf_32_arm.cc +++ b/courgette/disassembler_elf_32_arm.cc @@ -4,11 +4,13 @@ #include "courgette/disassembler_elf_32_arm.h" +#include +#include + #include #include #include -#include "base/basictypes.h" #include "base/logging.h" #include "courgette/assembly_program.h" @@ -17,8 +19,11 @@ namespace courgette { -CheckBool DisassemblerElf32ARM::Compress(ARM_RVA type, uint32 arm_op, RVA rva, - uint16* c_op, uint32* addr) { +CheckBool DisassemblerElf32ARM::Compress(ARM_RVA type, + uint32_t arm_op, + RVA rva, + uint16_t* c_op, + uint32_t* addr) { // This method takes an ARM or thumb opcode, extracts the relative // target address from it (addr), and creates a corresponding // Courgette opcode (c_op). @@ -31,32 +36,32 @@ CheckBool DisassemblerElf32ARM::Compress(ARM_RVA type, uint32 arm_op, RVA rva, case ARM_OFF8: { // The offset is given by lower 8 bits of the op. It is a 9-bit // offset, shifted right one bit and signed extended. - uint32 temp = (arm_op & 0x00FF) << 1; + uint32_t temp = (arm_op & 0x00FF) << 1; if (temp & 0x0100) temp |= 0xFFFFFE00; temp += 4; // Offset from _next_ PC. fflush(stdout); (*addr) = temp; - (*c_op) = static_cast(arm_op >> 8) | 0x1000; + (*c_op) = static_cast(arm_op >> 8) | 0x1000; break; } case ARM_OFF11: { // The offset is given by lower 11 bits of the op, and is a // 12-bit offset, shifted right one bit and sign extended. - uint32 temp = (arm_op & 0x07FF) << 1; + uint32_t temp = (arm_op & 0x07FF) << 1; if (temp & 0x00000800) temp |= 0xFFFFF000; temp += 4; // Offset from _next_ PC. (*addr) = temp; - (*c_op) = static_cast(arm_op >> 11) | 0x2000; + (*c_op) = static_cast(arm_op >> 11) | 0x2000; break; } case ARM_OFF24: { // The offset is given by the lower 24-bits of the op, shifted // left 2 bits, and sign extended. - uint32 temp = (arm_op & 0x00FFFFFF) << 2; + uint32_t temp = (arm_op & 0x00FFFFFF) << 2; if (temp & 0x02000000) temp |= 0xFC000000; temp += 8; @@ -66,28 +71,28 @@ CheckBool DisassemblerElf32ARM::Compress(ARM_RVA type, uint32 arm_op, RVA rva, break; } case ARM_OFF25: { - uint32 temp = 0; + uint32_t temp = 0; temp |= (arm_op & 0x000007FF) << 1; // imm11 temp |= (arm_op & 0x03FF0000) >> 4; // imm10 - uint32 S = (arm_op & (1 << 26)) >> 26; - uint32 j2 = (arm_op & (1 << 11)) >> 11; - uint32 j1 = (arm_op & (1 << 13)) >> 13; + uint32_t S = (arm_op & (1 << 26)) >> 26; + uint32_t j2 = (arm_op & (1 << 11)) >> 11; + uint32_t j1 = (arm_op & (1 << 13)) >> 13; bool bit12 = ((arm_op & (1 << 12)) >> 12) != 0; bool bit14 = ((arm_op & (1 << 14)) >> 14) != 0; - uint32 i2 = ~(j2 ^ S) & 1; - uint32 i1 = ~(j1 ^ S) & 1; + uint32_t i2 = ~(j2 ^ S) & 1; + uint32_t i1 = ~(j1 ^ S) & 1; bool toARM = bit14 && !bit12; temp |= (S << 24) | (i1 << 23) | (i2 << 22); if (temp & 0x01000000) // sign extension temp |= 0xFE000000; - uint32 prefetch; + uint32_t prefetch; if (toARM) { // Align PC on 4-byte boundary - uint32 align4byte = (rva % 4) ? 2 : 4; + uint32_t align4byte = (rva % 4) ? 2 : 4; prefetch = align4byte; } else { prefetch = 4; @@ -95,23 +100,23 @@ CheckBool DisassemblerElf32ARM::Compress(ARM_RVA type, uint32 arm_op, RVA rva, temp += prefetch; (*addr) = temp; - uint32 temp2 = 0x4000; + uint32_t temp2 = 0x4000; temp2 |= (arm_op & (1 << 12)) >> 12; temp2 |= (arm_op & (1 << 14)) >> 13; temp2 |= (arm_op & (1 << 15)) >> 13; temp2 |= (arm_op & 0xF8000000) >> 24; temp2 |= (prefetch & 0x0000000F) << 8; - (*c_op) = static_cast(temp2); + (*c_op) = static_cast(temp2); break; } case ARM_OFF21: { - uint32 temp = 0; + uint32_t temp = 0; temp |= (arm_op & 0x000007FF) << 1; // imm11 temp |= (arm_op & 0x003F0000) >> 4; // imm6 - uint32 S = (arm_op & (1 << 26)) >> 26; - uint32 j2 = (arm_op & (1 << 11)) >> 11; - uint32 j1 = (arm_op & (1 << 13)) >> 13; + uint32_t S = (arm_op & (1 << 26)) >> 26; + uint32_t j2 = (arm_op & (1 << 11)) >> 11; + uint32_t j1 = (arm_op & (1 << 13)) >> 13; temp |= (S << 20) | (j1 << 19) | (j2 << 18); @@ -120,9 +125,9 @@ CheckBool DisassemblerElf32ARM::Compress(ARM_RVA type, uint32 arm_op, RVA rva, temp += 4; (*addr) = temp; - uint32 temp2 = 0x5000; + uint32_t temp2 = 0x5000; temp2 |= (arm_op & 0x03C00000) >> 22; // just save the cond - (*c_op) = static_cast(temp2); + (*c_op) = static_cast(temp2); break; } default: @@ -131,8 +136,10 @@ CheckBool DisassemblerElf32ARM::Compress(ARM_RVA type, uint32 arm_op, RVA rva, return true; } -CheckBool DisassemblerElf32ARM::Decompress(ARM_RVA type, uint16 c_op, - uint32 addr, uint32* arm_op) { +CheckBool DisassemblerElf32ARM::Decompress(ARM_RVA type, + uint16_t c_op, + uint32_t addr, + uint32_t* arm_op) { // Reverses the process in the compress() method. Takes the // Courgette op and relative address and reconstructs the original // ARM or thumb op. @@ -147,23 +154,23 @@ CheckBool DisassemblerElf32ARM::Decompress(ARM_RVA type, uint16 c_op, (*arm_op) = ((c_op & 0x0FFF) << 24) | (((addr - 8) >> 2) & 0x00FFFFFF); break; case ARM_OFF25: { - uint32 temp = 0; + uint32_t temp = 0; temp |= (c_op & (1 << 0)) << 12; temp |= (c_op & (1 << 1)) << 13; temp |= (c_op & (1 << 2)) << 13; temp |= (c_op & (0xF8000000 >> 24)) << 24; - uint32 prefetch = (c_op & 0x0F00) >> 8; + uint32_t prefetch = (c_op & 0x0F00) >> 8; addr -= prefetch; addr &= 0x01FFFFFF; - uint32 S = (addr & (1 << 24)) >> 24; - uint32 i1 = (addr & (1 << 23)) >> 23; - uint32 i2 = (addr & (1 << 22)) >> 22; + uint32_t S = (addr & (1 << 24)) >> 24; + uint32_t i1 = (addr & (1 << 23)) >> 23; + uint32_t i2 = (addr & (1 << 22)) >> 22; - uint32 j1 = ((~i1) ^ S) & 1; - uint32 j2 = ((~i2) ^ S) & 1; + uint32_t j1 = ((~i1) ^ S) & 1; + uint32_t j2 = ((~i2) ^ S) & 1; temp |= S << 26; temp |= j2 << 11; @@ -176,15 +183,15 @@ CheckBool DisassemblerElf32ARM::Decompress(ARM_RVA type, uint16 c_op, break; } case ARM_OFF21: { - uint32 temp = 0xF0008000; + uint32_t temp = 0xF0008000; temp |= (c_op & (0x03C00000 >> 22)) << 22; addr -= 4; addr &= 0x001FFFFF; - uint32 S = (addr & (1 << 20)) >> 20; - uint32 j1 = (addr & (1 << 19)) >> 19; - uint32 j2 = (addr & (1 << 18)) >> 18; + uint32_t S = (addr & (1 << 20)) >> 20; + uint32_t j1 = (addr & (1 << 19)) >> 19; + uint32_t j2 = (addr & (1 << 18)) >> 18; temp |= S << 26; temp |= j2 << 11; @@ -202,7 +209,7 @@ CheckBool DisassemblerElf32ARM::Decompress(ARM_RVA type, uint16 c_op, return true; } -uint16 DisassemblerElf32ARM::TypedRVAARM::op_size() const { +uint16_t DisassemblerElf32ARM::TypedRVAARM::op_size() const { switch (type_) { case ARM_OFF8: return 2; @@ -220,7 +227,7 @@ uint16 DisassemblerElf32ARM::TypedRVAARM::op_size() const { } CheckBool DisassemblerElf32ARM::TypedRVAARM::ComputeRelativeTarget( - const uint8* op_pointer) { + const uint8_t* op_pointer) { arm_op_ = op_pointer; switch (type_) { case ARM_OFF8: @@ -243,8 +250,8 @@ CheckBool DisassemblerElf32ARM::TypedRVAARM::ComputeRelativeTarget( // Fall through case ARM_OFF21: { // A thumb-2 op is 32 bits stored as two 16-bit words - uint32 pval = (Read16LittleEndian(op_pointer) << 16) - | Read16LittleEndian(op_pointer + 2); + uint32_t pval = (Read16LittleEndian(op_pointer) << 16) | + Read16LittleEndian(op_pointer + 2); RVA relative_target; CheckBool ret = Compress(type_, pval, rva(), &c_op_, &relative_target); set_relative_target(relative_target); @@ -276,7 +283,7 @@ CheckBool DisassemblerElf32ARM::RelToRVA(Elf32_Rel rel, RVA* result) const { (elf32_rel_arm_type_values)(unsigned char)rel.r_info; // The other 3 bytes of r_info are the symbol - uint32 symbol = rel.r_info >> 8; + uint32_t symbol = rel.r_info >> 8; switch(type) { @@ -321,8 +328,8 @@ CheckBool DisassemblerElf32ARM::ParseRelocationSection( Elf32_Rel *section_relocs_iter = (Elf32_Rel *)OffsetToPointer(section_header->sh_offset); - uint32 section_relocs_count = section_header->sh_size / - section_header->sh_entsize; + uint32_t section_relocs_count = + section_header->sh_size / section_header->sh_entsize; if (abs32_locations_.size() > section_relocs_count) match = false; @@ -330,7 +337,7 @@ CheckBool DisassemblerElf32ARM::ParseRelocationSection( if (!abs32_locations_.empty()) { std::vector::iterator reloc_iter = abs32_locations_.begin(); - for (uint32 i = 0; i < section_relocs_count; i++) { + for (uint32_t i = 0; i < section_relocs_count; i++) { if (section_relocs_iter->r_offset == *reloc_iter) break; @@ -364,20 +371,19 @@ CheckBool DisassemblerElf32ARM::ParseRelocationSection( CheckBool DisassemblerElf32ARM::ParseRel32RelocsFromSection( const Elf32_Shdr* section_header) { + uint32_t start_file_offset = section_header->sh_offset; + uint32_t end_file_offset = start_file_offset + section_header->sh_size; - uint32 start_file_offset = section_header->sh_offset; - uint32 end_file_offset = start_file_offset + section_header->sh_size; - - const uint8* start_pointer = OffsetToPointer(start_file_offset); - const uint8* end_pointer = OffsetToPointer(end_file_offset); + const uint8_t* start_pointer = OffsetToPointer(start_file_offset); + const uint8_t* end_pointer = OffsetToPointer(end_file_offset); // Quick way to convert from Pointer to RVA within a single Section is to // subtract 'pointer_to_rva'. - const uint8* const adjust_pointer_to_rva = start_pointer - - section_header->sh_addr; + const uint8_t* const adjust_pointer_to_rva = + start_pointer - section_header->sh_addr; // Find the rel32 relocations. - const uint8* p = start_pointer; + const uint8_t* p = start_pointer; bool on_32bit = 1; // 32-bit ARM ops appear on 32-bit boundaries, so track it while (p < end_pointer) { // Heuristic discovery of rel32 locations in instruction stream: are the @@ -390,12 +396,12 @@ CheckBool DisassemblerElf32ARM::ParseRel32RelocsFromSection( // 16-bit thumb ops if (!found && (p + 3) <= end_pointer) { - uint16 pval = Read16LittleEndian(p); + uint16_t pval = Read16LittleEndian(p); if ((pval & 0xF000) == 0xD000) { RVA rva = static_cast(p - adjust_pointer_to_rva); rel32_rva = new TypedRVAARM(ARM_OFF8, rva); - if (!rel32_rva->ComputeRelativeTarget((uint8*) p)) { + if (!rel32_rva->ComputeRelativeTarget((uint8_t*)p)) { return false; } target_rva = rel32_rva->rva() + rel32_rva->relative_target(); @@ -404,7 +410,7 @@ CheckBool DisassemblerElf32ARM::ParseRel32RelocsFromSection( RVA rva = static_cast(p - adjust_pointer_to_rva); rel32_rva = new TypedRVAARM(ARM_OFF11, rva); - if (!rel32_rva->ComputeRelativeTarget((uint8*) p)) { + if (!rel32_rva->ComputeRelativeTarget((uint8_t*)p)) { return false; } target_rva = rel32_rva->rva() + rel32_rva->relative_target(); @@ -415,7 +421,7 @@ CheckBool DisassemblerElf32ARM::ParseRel32RelocsFromSection( // thumb-2 ops comprised of two 16-bit words if (!found && (p + 5) <= end_pointer) { // This is really two 16-bit words, not one 32-bit word. - uint32 pval = (Read16LittleEndian(p) << 16) | Read16LittleEndian(p + 2); + uint32_t pval = (Read16LittleEndian(p) << 16) | Read16LittleEndian(p + 2); if ((pval & 0xF8008000) == 0xF0008000) { // Covers thumb-2's 32-bit conditional/unconditional branches @@ -424,7 +430,7 @@ CheckBool DisassemblerElf32ARM::ParseRel32RelocsFromSection( RVA rva = static_cast(p - adjust_pointer_to_rva); rel32_rva = new TypedRVAARM(ARM_OFF25, rva); - if (!rel32_rva->ComputeRelativeTarget((uint8*) p)) { + if (!rel32_rva->ComputeRelativeTarget((uint8_t*)p)) { return false; } target_rva = rel32_rva->rva() + rel32_rva->relative_target(); @@ -435,7 +441,7 @@ CheckBool DisassemblerElf32ARM::ParseRel32RelocsFromSection( RVA rva = static_cast(p - adjust_pointer_to_rva); rel32_rva = new TypedRVAARM(ARM_OFF21, rva); - if (!rel32_rva->ComputeRelativeTarget((uint8*) p)) { + if (!rel32_rva->ComputeRelativeTarget((uint8_t*)p)) { return false; } target_rva = rel32_rva->rva() + rel32_rva->relative_target(); @@ -446,13 +452,13 @@ CheckBool DisassemblerElf32ARM::ParseRel32RelocsFromSection( // 32-bit ARM ops if (!found && on_32bit && (p + 5) <= end_pointer) { - uint32 pval = Read32LittleEndian(p); + uint32_t pval = Read32LittleEndian(p); if ((pval & 0x0E000000) == 0x0A000000) { // Covers both 0x0A 0x0B ARM relative branches RVA rva = static_cast(p - adjust_pointer_to_rva); rel32_rva = new TypedRVAARM(ARM_OFF24, rva); - if (!rel32_rva->ComputeRelativeTarget((uint8*) p)) { + if (!rel32_rva->ComputeRelativeTarget((uint8_t*)p)) { return false; } target_rva = rel32_rva->rva() + rel32_rva->relative_target(); diff --git a/courgette/disassembler_elf_32_arm.h b/courgette/disassembler_elf_32_arm.h index 8a64766..17ebb25 100644 --- a/courgette/disassembler_elf_32_arm.h +++ b/courgette/disassembler_elf_32_arm.h @@ -5,7 +5,10 @@ #ifndef COURGETTE_DISASSEMBLER_ELF_32_ARM_H_ #define COURGETTE_DISASSEMBLER_ELF_32_ARM_H_ -#include "base/basictypes.h" +#include +#include + +#include "base/macros.h" #include "courgette/disassembler_elf_32.h" #include "courgette/memory_allocator.h" #include "courgette/types_elf.h" @@ -28,22 +31,20 @@ class DisassemblerElf32ARM : public DisassemblerElf32 { public: TypedRVAARM(ARM_RVA type, RVA rva) : TypedRVA(rva), type_(type) { } - uint16 c_op() const { - return c_op_; - } + uint16_t c_op() const { return c_op_; } - virtual CheckBool ComputeRelativeTarget(const uint8* op_pointer); + virtual CheckBool ComputeRelativeTarget(const uint8_t* op_pointer); virtual CheckBool EmitInstruction(AssemblyProgram* program, RVA target_rva); - virtual uint16 op_size() const; + virtual uint16_t op_size() const; private: ARM_RVA type_; - uint16 c_op_; // set by ComputeRelativeTarget() - const uint8* arm_op_; + uint16_t c_op_; // set by ComputeRelativeTarget() + const uint8_t* arm_op_; }; explicit DisassemblerElf32ARM(const void* start, size_t length); @@ -52,11 +53,16 @@ class DisassemblerElf32ARM : public DisassemblerElf32 { virtual e_machine_values ElfEM() { return EM_ARM; } - static CheckBool Compress(ARM_RVA type, uint32 arm_op, RVA rva, - uint16* c_op /* out */, uint32* addr /* out */); + static CheckBool Compress(ARM_RVA type, + uint32_t arm_op, + RVA rva, + uint16_t* c_op /* out */, + uint32_t* addr /* out */); - static CheckBool Decompress(ARM_RVA type, uint16 c_op, uint32 addr, - uint32* arm_op /* out */); + static CheckBool Decompress(ARM_RVA type, + uint16_t c_op, + uint32_t addr, + uint32_t* arm_op /* out */); protected: diff --git a/courgette/disassembler_elf_32_x86.cc b/courgette/disassembler_elf_32_x86.cc index da389a4..98084c1 100644 --- a/courgette/disassembler_elf_32_x86.cc +++ b/courgette/disassembler_elf_32_x86.cc @@ -4,11 +4,13 @@ #include "courgette/disassembler_elf_32_x86.h" +#include +#include + #include #include #include -#include "base/basictypes.h" #include "base/logging.h" #include "courgette/assembly_program.h" @@ -29,7 +31,7 @@ CheckBool DisassemblerElf32X86::RelToRVA(Elf32_Rel rel, RVA* result) const { (elf32_rel_386_type_values)(unsigned char)rel.r_info; // The other 3 bytes of r_info are the symbol - uint32 symbol = rel.r_info >> 8; + uint32_t symbol = rel.r_info >> 8; switch(type) { @@ -88,8 +90,8 @@ CheckBool DisassemblerElf32X86::ParseRelocationSection( Elf32_Rel *section_relocs_iter = (Elf32_Rel *)OffsetToPointer(section_header->sh_offset); - uint32 section_relocs_count = section_header->sh_size / - section_header->sh_entsize; + uint32_t section_relocs_count = + section_header->sh_size / section_header->sh_entsize; if (abs32_locations_.empty()) match = false; @@ -119,27 +121,26 @@ CheckBool DisassemblerElf32X86::ParseRelocationSection( CheckBool DisassemblerElf32X86::ParseRel32RelocsFromSection( const Elf32_Shdr* section_header) { + uint32_t start_file_offset = section_header->sh_offset; + uint32_t end_file_offset = start_file_offset + section_header->sh_size; - uint32 start_file_offset = section_header->sh_offset; - uint32 end_file_offset = start_file_offset + section_header->sh_size; - - const uint8* start_pointer = OffsetToPointer(start_file_offset); - const uint8* end_pointer = OffsetToPointer(end_file_offset); + const uint8_t* start_pointer = OffsetToPointer(start_file_offset); + const uint8_t* end_pointer = OffsetToPointer(end_file_offset); // Quick way to convert from Pointer to RVA within a single Section is to // subtract 'pointer_to_rva'. - const uint8* const adjust_pointer_to_rva = start_pointer - - section_header->sh_addr; + const uint8_t* const adjust_pointer_to_rva = + start_pointer - section_header->sh_addr; // Find the rel32 relocations. - const uint8* p = start_pointer; + const uint8_t* p = start_pointer; while (p < end_pointer) { //RVA current_rva = static_cast(p - adjust_pointer_to_rva); // Heuristic discovery of rel32 locations in instruction stream: are the // next few bytes the start of an instruction containing a rel32 // addressing mode? - const uint8* rel32 = NULL; + const uint8_t* rel32 = NULL; if (p + 5 <= end_pointer) { if (*p == 0xE8 || *p == 0xE9) { // jmp rel32 and call rel32 diff --git a/courgette/disassembler_elf_32_x86.h b/courgette/disassembler_elf_32_x86.h index 913e93f..5c87d4c 100644 --- a/courgette/disassembler_elf_32_x86.h +++ b/courgette/disassembler_elf_32_x86.h @@ -5,7 +5,10 @@ #ifndef COURGETTE_DISASSEMBLER_ELF_32_X86_H_ #define COURGETTE_DISASSEMBLER_ELF_32_X86_H_ -#include "base/basictypes.h" +#include +#include + +#include "base/macros.h" #include "courgette/disassembler_elf_32.h" #include "courgette/memory_allocator.h" #include "courgette/types_elf.h" @@ -21,7 +24,7 @@ class DisassemblerElf32X86 : public DisassemblerElf32 { explicit TypedRVAX86(RVA rva) : TypedRVA(rva) { } - CheckBool ComputeRelativeTarget(const uint8* op_pointer) override { + CheckBool ComputeRelativeTarget(const uint8_t* op_pointer) override { set_relative_target(Read32LittleEndian(op_pointer) + 4); return true; } @@ -31,7 +34,7 @@ class DisassemblerElf32X86 : public DisassemblerElf32 { return program->EmitRel32(program->FindOrMakeRel32Label(target_rva)); } - uint16 op_size() const override { return 4; } + uint16_t op_size() const override { return 4; } }; explicit DisassemblerElf32X86(const void* start, size_t length); diff --git a/courgette/disassembler_elf_32_x86_unittest.cc b/courgette/disassembler_elf_32_x86_unittest.cc index d48bc4f..3ce6a63 100644 --- a/courgette/disassembler_elf_32_x86_unittest.cc +++ b/courgette/disassembler_elf_32_x86_unittest.cc @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +#include +#include + #include "courgette/assembly_program.h" #include "courgette/base_test_unittest.h" #include "courgette/disassembler_elf_32_x86.h" @@ -30,7 +33,7 @@ void DisassemblerElf32X86Test::TestExe(const char* file_name, // real file, since trailing debug info is not included EXPECT_EQ(file1.length(), disassembler->length()); - const uint8* offset_p = disassembler->OffsetToPointer(0); + const uint8_t* offset_p = disassembler->OffsetToPointer(0); EXPECT_EQ(reinterpret_cast(file1.c_str()), reinterpret_cast(offset_p)); EXPECT_EQ(0x7F, offset_p[0]); diff --git a/courgette/disassembler_win32_x64.cc b/courgette/disassembler_win32_x64.cc index 58e787b..357930d 100644 --- a/courgette/disassembler_win32_x64.cc +++ b/courgette/disassembler_win32_x64.cc @@ -4,11 +4,13 @@ #include "courgette/disassembler_win32_x64.h" +#include +#include + #include #include #include -#include "base/basictypes.h" #include "base/logging.h" #include "base/numerics/safe_conversions.h" @@ -55,13 +57,12 @@ bool DisassemblerWin32X64::ParseHeader() { return Bad("Not MZ"); // offset from DOS header to PE header is stored in DOS header. - uint32 offset = ReadU32(start(), - kOffsetOfFileAddressOfNewExeHeader); + uint32_t offset = ReadU32(start(), kOffsetOfFileAddressOfNewExeHeader); if (offset >= length()) return Bad("Bad offset to PE header"); - const uint8* const pe_header = OffsetToPointer(offset); + const uint8_t* const pe_header = OffsetToPointer(offset); const size_t kMinPEHeaderSize = 4 /*signature*/ + kSizeOfCoffHeader; if (pe_header <= start() || pe_header >= end() - kMinPEHeaderSize) @@ -83,13 +84,13 @@ bool DisassemblerWin32X64::ParseHeader() { // The second field of the IMAGE_NT_HEADERS is the COFF header. // The COFF header is also called an IMAGE_FILE_HEADER // http://msdn.microsoft.com/en-us/library/ms680313(VS.85).aspx - const uint8* const coff_header = pe_header + 4; + const uint8_t* const coff_header = pe_header + 4; machine_type_ = ReadU16(coff_header, 0); number_of_sections_ = ReadU16(coff_header, 2); size_of_optional_header_ = ReadU16(coff_header, 16); // The rest of the IMAGE_NT_HEADERS is the IMAGE_OPTIONAL_HEADER(32|64) - const uint8* const optional_header = coff_header + kSizeOfCoffHeader; + const uint8_t* const optional_header = coff_header + kSizeOfCoffHeader; optional_header_ = optional_header; if (optional_header + size_of_optional_header_ >= end()) @@ -99,7 +100,7 @@ bool DisassemblerWin32X64::ParseHeader() { if (size_of_optional_header_ < 2) return Bad("optional header no magic"); - uint16 magic = ReadU16(optional_header, 0); + uint16_t magic = ReadU16(optional_header, 0); if (magic == kImageNtOptionalHdr32Magic) { is_PE32_plus_ = false; @@ -176,7 +177,7 @@ bool DisassemblerWin32X64::ParseHeader() { if (memcmp(section->name, ".text", 6) == 0) has_text_section_ = true; - uint32 section_end = + uint32_t section_end = section->file_offset_of_raw_data + section->size_of_raw_data; if (section_end > detected_length) detected_length = section_end; @@ -229,8 +230,8 @@ bool DisassemblerWin32X64::ParseRelocs(std::vector *relocs) { // "The format of the base relocation data is somewhat quirky" // at http://msdn.microsoft.com/en-us/library/ms809762.aspx - const uint8* relocs_start = RVAToPointer(base_relocation_table_.address_); - const uint8* relocs_end = relocs_start + relocs_size; + const uint8_t* relocs_start = RVAToPointer(base_relocation_table_.address_); + const uint8_t* relocs_end = relocs_start + relocs_size; // Make sure entire base relocation table is within the buffer. if (relocs_start < start() || @@ -240,17 +241,17 @@ bool DisassemblerWin32X64::ParseRelocs(std::vector *relocs) { return Bad(".relocs outside image"); } - const uint8* block = relocs_start; + const uint8_t* block = relocs_start; // Walk the variable sized blocks. while (block + 8 < relocs_end) { RVA page_rva = ReadU32(block, 0); - uint32 size = ReadU32(block, 4); + uint32_t size = ReadU32(block, 4); if (size < 8 || // Size includes header ... size % 4 != 0) // ... and is word aligned. return Bad("unreasonable relocs block"); - const uint8* end_entries = block + size; + const uint8_t* end_entries = block + size; if (end_entries <= block || end_entries <= start() || @@ -258,8 +259,8 @@ bool DisassemblerWin32X64::ParseRelocs(std::vector *relocs) { return Bad(".relocs block outside image"); // Walk through the two-byte entries. - for (const uint8* p = block + 8; p < end_entries; p += 2) { - uint16 entry = ReadU16(p, 0); + for (const uint8_t* p = block + 8; p < end_entries; p += 2) { + uint16_t entry = ReadU16(p, 0); int type = entry >> 12; int offset = entry & 0xFFF; @@ -287,7 +288,7 @@ bool DisassemblerWin32X64::ParseRelocs(std::vector *relocs) { const Section* DisassemblerWin32X64::RVAToSection(RVA rva) const { for (int i = 0; i < number_of_sections_; i++) { const Section* section = §ions_[i]; - uint32 offset = rva - section->virtual_address; + uint32_t offset = rva - section->virtual_address; if (offset < section->virtual_size) { return section; } @@ -298,7 +299,7 @@ const Section* DisassemblerWin32X64::RVAToSection(RVA rva) const { int DisassemblerWin32X64::RVAToFileOffset(RVA rva) const { const Section* section = RVAToSection(rva); if (section) { - uint32 offset = rva - section->virtual_address; + uint32_t offset = rva - section->virtual_address; if (offset < section->size_of_raw_data) { return section->file_offset_of_raw_data + offset; } else { @@ -317,7 +318,7 @@ int DisassemblerWin32X64::RVAToFileOffset(RVA rva) const { return kNoOffset; } -const uint8* DisassemblerWin32X64::RVAToPointer(RVA rva) const { +const uint8_t* DisassemblerWin32X64::RVAToPointer(RVA rva) const { int file_offset = RVAToFileOffset(rva); if (file_offset == kNoOffset) return NULL; @@ -336,7 +337,7 @@ std::string DisassemblerWin32X64::SectionName(const Section* section) { CheckBool DisassemblerWin32X64::ParseFile(AssemblyProgram* program) { // Walk all the bytes in the file, whether or not in a section. - uint32 file_offset = 0; + uint32_t file_offset = 0; while (file_offset < length()) { const Section* section = FindNextSection(file_offset); if (section == NULL) { @@ -346,14 +347,14 @@ CheckBool DisassemblerWin32X64::ParseFile(AssemblyProgram* program) { break; } if (file_offset < section->file_offset_of_raw_data) { - uint32 section_start_offset = section->file_offset_of_raw_data; + uint32_t section_start_offset = section->file_offset_of_raw_data; if(!ParseNonSectionFileRegion(file_offset, section_start_offset, program)) return false; file_offset = section_start_offset; } - uint32 end = file_offset + section->size_of_raw_data; + uint32_t end = file_offset + section->size_of_raw_data; if (!ParseFileRegion(section, file_offset, end, program)) return false; file_offset = end; @@ -376,7 +377,7 @@ bool DisassemblerWin32X64::ParseAbs32Relocs() { for (size_t i = 0; i < abs32_locations_.size(); ++i) { RVA rva = abs32_locations_[i]; // The 4 bytes at the relocation are a reference to some address. - uint32 target_address = Read32LittleEndian(RVAToPointer(rva)); + uint32_t target_address = Read32LittleEndian(RVAToPointer(rva)); ++abs32_target_rvas_[target_address - image_base()]; } #endif @@ -384,7 +385,7 @@ bool DisassemblerWin32X64::ParseAbs32Relocs() { } void DisassemblerWin32X64::ParseRel32RelocsFromSections() { - uint32 file_offset = 0; + uint32_t file_offset = 0; while (file_offset < length()) { const Section* section = FindNextSection(file_offset); if (section == NULL) @@ -427,28 +428,28 @@ void DisassemblerWin32X64::ParseRel32RelocsFromSection(const Section* section) { if (!isCode) return; - uint32 start_file_offset = section->file_offset_of_raw_data; - uint32 end_file_offset = start_file_offset + section->size_of_raw_data; + uint32_t start_file_offset = section->file_offset_of_raw_data; + uint32_t end_file_offset = start_file_offset + section->size_of_raw_data; RVA relocs_start_rva = base_relocation_table().address_; - const uint8* start_pointer = OffsetToPointer(start_file_offset); - const uint8* end_pointer = OffsetToPointer(end_file_offset); + const uint8_t* start_pointer = OffsetToPointer(start_file_offset); + const uint8_t* end_pointer = OffsetToPointer(end_file_offset); RVA start_rva = FileOffsetToRVA(start_file_offset); RVA end_rva = start_rva + section->virtual_size; // Quick way to convert from Pointer to RVA within a single Section is to // subtract 'pointer_to_rva'. - const uint8* const adjust_pointer_to_rva = start_pointer - start_rva; + const uint8_t* const adjust_pointer_to_rva = start_pointer - start_rva; std::vector::iterator abs32_pos = abs32_locations_.begin(); // Find the rel32 relocations. - const uint8* p = start_pointer; + const uint8_t* p = start_pointer; while (p < end_pointer) { RVA current_rva = static_cast(p - adjust_pointer_to_rva); if (current_rva == relocs_start_rva) { - uint32 relocs_size = base_relocation_table().size_; + uint32_t relocs_size = base_relocation_table().size_; if (relocs_size) { p += relocs_size; continue; @@ -461,7 +462,7 @@ void DisassemblerWin32X64::ParseRel32RelocsFromSection(const Section* section) { // Heuristic discovery of rel32 locations in instruction stream: are the // next few bytes the start of an instruction containing a rel32 // addressing mode? - const uint8* rel32 = NULL; + const uint8_t* rel32 = NULL; bool is_rip_relative = false; if (p + 5 <= end_pointer) { @@ -528,8 +529,8 @@ void DisassemblerWin32X64::ParseRel32RelocsFromSection(const Section* section) { } CheckBool DisassemblerWin32X64::ParseNonSectionFileRegion( - uint32 start_file_offset, - uint32 end_file_offset, + uint32_t start_file_offset, + uint32_t end_file_offset, AssemblyProgram* program) { if (incomplete_disassembly_) return true; @@ -544,21 +545,21 @@ CheckBool DisassemblerWin32X64::ParseNonSectionFileRegion( return true; } -CheckBool DisassemblerWin32X64::ParseFileRegion( - const Section* section, - uint32 start_file_offset, uint32 end_file_offset, - AssemblyProgram* program) { +CheckBool DisassemblerWin32X64::ParseFileRegion(const Section* section, + uint32_t start_file_offset, + uint32_t end_file_offset, + AssemblyProgram* program) { RVA relocs_start_rva = base_relocation_table().address_; - const uint8* start_pointer = OffsetToPointer(start_file_offset); - const uint8* end_pointer = OffsetToPointer(end_file_offset); + const uint8_t* start_pointer = OffsetToPointer(start_file_offset); + const uint8_t* end_pointer = OffsetToPointer(end_file_offset); RVA start_rva = FileOffsetToRVA(start_file_offset); RVA end_rva = start_rva + section->virtual_size; // Quick way to convert from Pointer to RVA within a single Section is to // subtract 'pointer_to_rva'. - const uint8* const adjust_pointer_to_rva = start_pointer - start_rva; + const uint8_t* const adjust_pointer_to_rva = start_pointer - start_rva; std::vector::iterator rel32_pos = rel32_locations_.begin(); std::vector::iterator abs32_pos = abs32_locations_.begin(); @@ -566,7 +567,7 @@ CheckBool DisassemblerWin32X64::ParseFileRegion( if (!program->EmitOriginInstruction(start_rva)) return false; - const uint8* p = start_pointer; + const uint8_t* p = start_pointer; while (p < end_pointer) { RVA current_rva = static_cast(p - adjust_pointer_to_rva); @@ -577,7 +578,7 @@ CheckBool DisassemblerWin32X64::ParseFileRegion( if (current_rva == relocs_start_rva) { if (!program->EmitPeRelocsInstruction()) return false; - uint32 relocs_size = base_relocation_table().size_; + uint32_t relocs_size = base_relocation_table().size_; if (relocs_size) { p += relocs_size; continue; @@ -588,7 +589,7 @@ CheckBool DisassemblerWin32X64::ParseFileRegion( ++abs32_pos; if (abs32_pos != abs32_locations_.end() && *abs32_pos == current_rva) { - uint64 target_address = Read64LittleEndian(p); + uint64_t target_address = Read64LittleEndian(p); RVA target_rva = base::checked_cast(target_address - image_base()); // TODO(sra): target could be Label+offset. It is not clear how to guess // which it might be. We assume offset==0. @@ -690,7 +691,8 @@ std::string DisassemblerWin32X64::DescribeRVA(RVA rva) const { return s.str(); } -const Section* DisassemblerWin32X64::FindNextSection(uint32 fileOffset) const { +const Section* DisassemblerWin32X64::FindNextSection( + uint32_t fileOffset) const { const Section* best = 0; for (int i = 0; i < number_of_sections_; i++) { const Section* section = §ions_[i]; @@ -706,10 +708,10 @@ const Section* DisassemblerWin32X64::FindNextSection(uint32 fileOffset) const { return best; } -RVA DisassemblerWin32X64::FileOffsetToRVA(uint32 file_offset) const { +RVA DisassemblerWin32X64::FileOffsetToRVA(uint32_t file_offset) const { for (int i = 0; i < number_of_sections_; i++) { const Section* section = §ions_[i]; - uint32 offset = file_offset - section->file_offset_of_raw_data; + uint32_t offset = file_offset - section->file_offset_of_raw_data; if (offset < section->size_of_raw_data) { return section->virtual_address + offset; } @@ -725,7 +727,7 @@ bool DisassemblerWin32X64::ReadDataDirectory( size_t offset = index * 8 + offset_of_data_directories_; if (offset >= size_of_optional_header_) return Bad("number of data directories inconsistent"); - const uint8* data_directory = optional_header_ + offset; + const uint8_t* data_directory = optional_header_ + offset; if (data_directory < start() || data_directory + 8 >= end()) return Bad("data directory outside image"); @@ -736,7 +738,7 @@ bool DisassemblerWin32X64::ReadDataDirectory( // TODO(sra): validate RVA. directory->address_ = rva; - directory->size_ = static_cast(size); + directory->size_ = static_cast(size); return true; } else { directory->address_ = 0; diff --git a/courgette/disassembler_win32_x64.h b/courgette/disassembler_win32_x64.h index bce4802..3b0b978 100644 --- a/courgette/disassembler_win32_x64.h +++ b/courgette/disassembler_win32_x64.h @@ -5,7 +5,10 @@ #ifndef COURGETTE_DISASSEMBLER_WIN32_X64_H_ #define COURGETTE_DISASSEMBLER_WIN32_X64_H_ -#include "base/basictypes.h" +#include +#include + +#include "base/macros.h" #include "courgette/disassembler.h" #include "courgette/memory_allocator.h" #include "courgette/types_win_pe.h" @@ -36,7 +39,7 @@ class DisassemblerWin32X64 : public Disassembler { // bool has_text_section() const { return has_text_section_; } - uint32 size_of_code() const { return size_of_code_; } + uint32_t size_of_code() const { return size_of_code_; } bool is_32bit() const { return !is_PE32_plus_; } // Returns 'true' if the base relocation table can be parsed. @@ -53,7 +56,7 @@ class DisassemblerWin32X64 : public Disassembler { // Returns same as FileOffsetToPointer(RVAToFileOffset(rva)) except that NULL // is returned if there is no file offset corresponding to 'rva'. - const uint8* RVAToPointer(RVA rva) const; + const uint8_t* RVAToPointer(RVA rva) const; static std::string SectionName(const Section* section); @@ -63,11 +66,14 @@ class DisassemblerWin32X64 : public Disassembler { void ParseRel32RelocsFromSections(); void ParseRel32RelocsFromSection(const Section* section); - CheckBool ParseNonSectionFileRegion(uint32 start_file_offset, - uint32 end_file_offset, AssemblyProgram* program) WARN_UNUSED_RESULT; + CheckBool ParseNonSectionFileRegion(uint32_t start_file_offset, + uint32_t end_file_offset, + AssemblyProgram* program) + WARN_UNUSED_RESULT; CheckBool ParseFileRegion(const Section* section, - uint32 start_file_offset, uint32 end_file_offset, - AssemblyProgram* program) WARN_UNUSED_RESULT; + uint32_t start_file_offset, + uint32_t end_file_offset, + AssemblyProgram* program) WARN_UNUSED_RESULT; #if COURGETTE_HISTOGRAM_TARGETS void HistogramTargets(const char* kind, const std::map& map); @@ -76,7 +82,7 @@ class DisassemblerWin32X64 : public Disassembler { // Most addresses are represented as 32-bit RVAs. The one address we can't // do this with is the image base address. 'image_base' is valid only for // 32-bit executables. 'image_base_64' is valid for 32- and 64-bit executable. - uint64 image_base() const { return image_base_; } + uint64_t image_base() const { return image_base_; } const ImageDataDirectory& base_relocation_table() const { return base_relocation_table_; @@ -89,15 +95,14 @@ class DisassemblerWin32X64 : public Disassembler { // Finds the first section at file_offset or above. Does not return sections // that have no raw bytes in the file. - const Section* FindNextSection(uint32 file_offset) const; + const Section* FindNextSection(uint32_t file_offset) const; // There are 2 'coordinate systems' for reasoning about executables. // FileOffset - the the offset within a single .EXE or .DLL *file*. // RVA - relative virtual address (offset within *loaded image*) // FileOffsetToRVA and RVAToFileOffset convert between these representations. - RVA FileOffsetToRVA(uint32 offset) const; - + RVA FileOffsetToRVA(uint32_t offset) const; private: @@ -118,23 +123,23 @@ class DisassemblerWin32X64 : public Disassembler { bool is_PE32_plus_; // PE32_plus is for 64 bit executables. // Location and size of IMAGE_OPTIONAL_HEADER in the buffer. - const uint8 *optional_header_; - uint16 size_of_optional_header_; - uint16 offset_of_data_directories_; + const uint8_t* optional_header_; + uint16_t size_of_optional_header_; + uint16_t offset_of_data_directories_; - uint16 machine_type_; - uint16 number_of_sections_; + uint16_t machine_type_; + uint16_t number_of_sections_; const Section *sections_; bool has_text_section_; - uint32 size_of_code_; - uint32 size_of_initialized_data_; - uint32 size_of_uninitialized_data_; + uint32_t size_of_code_; + uint32_t size_of_initialized_data_; + uint32_t size_of_uninitialized_data_; RVA base_of_code_; RVA base_of_data_; - uint64 image_base_; - uint32 size_of_image_; + uint64_t image_base_; + uint32_t size_of_image_; int number_of_data_directories_; ImageDataDirectory export_table_; diff --git a/courgette/disassembler_win32_x64_unittest.cc b/courgette/disassembler_win32_x64_unittest.cc index f67e800..8f732b3 100644 --- a/courgette/disassembler_win32_x64_unittest.cc +++ b/courgette/disassembler_win32_x64_unittest.cc @@ -4,6 +4,8 @@ #include "courgette/disassembler_win32_x64.h" +#include + #include "base/memory/scoped_ptr.h" #include "base/stl_util.h" #include "courgette/base_test_unittest.h" @@ -44,13 +46,13 @@ void DisassemblerWin32X64Test::TestExe() const { EXPECT_TRUE(can_parse_relocs); EXPECT_TRUE(base::STLIsSorted(relocs)); - const uint8* offset_p = disassembler->OffsetToPointer(0); + const uint8_t* offset_p = disassembler->OffsetToPointer(0); EXPECT_EQ(reinterpret_cast(file1.c_str()), reinterpret_cast(offset_p)); EXPECT_EQ('M', offset_p[0]); EXPECT_EQ('Z', offset_p[1]); - const uint8* rva_p = disassembler->RVAToPointer(0); + const uint8_t* rva_p = disassembler->RVAToPointer(0); EXPECT_EQ(reinterpret_cast(file1.c_str()), reinterpret_cast(rva_p)); EXPECT_EQ('M', rva_p[0]); diff --git a/courgette/disassembler_win32_x86.cc b/courgette/disassembler_win32_x86.cc index 85d99f4..bc41ff0 100644 --- a/courgette/disassembler_win32_x86.cc +++ b/courgette/disassembler_win32_x86.cc @@ -4,11 +4,13 @@ #include "courgette/disassembler_win32_x86.h" +#include +#include + #include #include #include -#include "base/basictypes.h" #include "base/logging.h" #include "courgette/assembly_program.h" @@ -55,13 +57,12 @@ bool DisassemblerWin32X86::ParseHeader() { return Bad("Not MZ"); // offset from DOS header to PE header is stored in DOS header. - uint32 offset = ReadU32(start(), - kOffsetOfFileAddressOfNewExeHeader); + uint32_t offset = ReadU32(start(), kOffsetOfFileAddressOfNewExeHeader); if (offset >= length()) return Bad("Bad offset to PE header"); - const uint8* const pe_header = OffsetToPointer(offset); + const uint8_t* const pe_header = OffsetToPointer(offset); const size_t kMinPEHeaderSize = 4 /*signature*/ + kSizeOfCoffHeader; if (pe_header <= start() || pe_header >= end() - kMinPEHeaderSize) @@ -83,13 +84,13 @@ bool DisassemblerWin32X86::ParseHeader() { // The second field of the IMAGE_NT_HEADERS is the COFF header. // The COFF header is also called an IMAGE_FILE_HEADER // http://msdn.microsoft.com/en-us/library/ms680313(VS.85).aspx - const uint8* const coff_header = pe_header + 4; + const uint8_t* const coff_header = pe_header + 4; machine_type_ = ReadU16(coff_header, 0); number_of_sections_ = ReadU16(coff_header, 2); size_of_optional_header_ = ReadU16(coff_header, 16); // The rest of the IMAGE_NT_HEADERS is the IMAGE_OPTIONAL_HEADER(32|64) - const uint8* const optional_header = coff_header + kSizeOfCoffHeader; + const uint8_t* const optional_header = coff_header + kSizeOfCoffHeader; optional_header_ = optional_header; if (optional_header + size_of_optional_header_ >= end()) @@ -99,7 +100,7 @@ bool DisassemblerWin32X86::ParseHeader() { if (size_of_optional_header_ < 2) return Bad("optional header no magic"); - uint16 magic = ReadU16(optional_header, 0); + uint16_t magic = ReadU16(optional_header, 0); if (magic == kImageNtOptionalHdr32Magic) { is_PE32_plus_ = false; @@ -176,7 +177,7 @@ bool DisassemblerWin32X86::ParseHeader() { if (memcmp(section->name, ".text", 6) == 0) has_text_section_ = true; - uint32 section_end = + uint32_t section_end = section->file_offset_of_raw_data + section->size_of_raw_data; if (section_end > detected_length) detected_length = section_end; @@ -229,8 +230,8 @@ bool DisassemblerWin32X86::ParseRelocs(std::vector *relocs) { // "The format of the base relocation data is somewhat quirky" // at http://msdn.microsoft.com/en-us/library/ms809762.aspx - const uint8* relocs_start = RVAToPointer(base_relocation_table_.address_); - const uint8* relocs_end = relocs_start + relocs_size; + const uint8_t* relocs_start = RVAToPointer(base_relocation_table_.address_); + const uint8_t* relocs_end = relocs_start + relocs_size; // Make sure entire base relocation table is within the buffer. if (relocs_start < start() || @@ -240,17 +241,17 @@ bool DisassemblerWin32X86::ParseRelocs(std::vector *relocs) { return Bad(".relocs outside image"); } - const uint8* block = relocs_start; + const uint8_t* block = relocs_start; // Walk the variable sized blocks. while (block + 8 < relocs_end) { RVA page_rva = ReadU32(block, 0); - uint32 size = ReadU32(block, 4); + uint32_t size = ReadU32(block, 4); if (size < 8 || // Size includes header ... size % 4 != 0) // ... and is word aligned. return Bad("unreasonable relocs block"); - const uint8* end_entries = block + size; + const uint8_t* end_entries = block + size; if (end_entries <= block || end_entries <= start() || @@ -258,8 +259,8 @@ bool DisassemblerWin32X86::ParseRelocs(std::vector *relocs) { return Bad(".relocs block outside image"); // Walk through the two-byte entries. - for (const uint8* p = block + 8; p < end_entries; p += 2) { - uint16 entry = ReadU16(p, 0); + for (const uint8_t* p = block + 8; p < end_entries; p += 2) { + uint16_t entry = ReadU16(p, 0); int type = entry >> 12; int offset = entry & 0xFFF; @@ -267,7 +268,7 @@ bool DisassemblerWin32X86::ParseRelocs(std::vector *relocs) { // Skip the relocs that live outside of the image. It might be the case // if a reloc is relative to a register, e.g.: // mov ecx,dword ptr [eax+044D5888h] - uint32 target_address = Read32LittleEndian(RVAToPointer(rva)); + uint32_t target_address = Read32LittleEndian(RVAToPointer(rva)); if (target_address < image_base_ || target_address > (image_base_ + size_of_image_)) { continue; @@ -293,7 +294,7 @@ bool DisassemblerWin32X86::ParseRelocs(std::vector *relocs) { const Section* DisassemblerWin32X86::RVAToSection(RVA rva) const { for (int i = 0; i < number_of_sections_; i++) { const Section* section = §ions_[i]; - uint32 offset = rva - section->virtual_address; + uint32_t offset = rva - section->virtual_address; if (offset < section->virtual_size) { return section; } @@ -304,7 +305,7 @@ const Section* DisassemblerWin32X86::RVAToSection(RVA rva) const { int DisassemblerWin32X86::RVAToFileOffset(RVA rva) const { const Section* section = RVAToSection(rva); if (section) { - uint32 offset = rva - section->virtual_address; + uint32_t offset = rva - section->virtual_address; if (offset < section->size_of_raw_data) { return section->file_offset_of_raw_data + offset; } else { @@ -323,7 +324,7 @@ int DisassemblerWin32X86::RVAToFileOffset(RVA rva) const { return kNoOffset; } -const uint8* DisassemblerWin32X86::RVAToPointer(RVA rva) const { +const uint8_t* DisassemblerWin32X86::RVAToPointer(RVA rva) const { int file_offset = RVAToFileOffset(rva); if (file_offset == kNoOffset) return NULL; @@ -342,7 +343,7 @@ std::string DisassemblerWin32X86::SectionName(const Section* section) { CheckBool DisassemblerWin32X86::ParseFile(AssemblyProgram* program) { // Walk all the bytes in the file, whether or not in a section. - uint32 file_offset = 0; + uint32_t file_offset = 0; while (file_offset < length()) { const Section* section = FindNextSection(file_offset); if (section == NULL) { @@ -352,14 +353,14 @@ CheckBool DisassemblerWin32X86::ParseFile(AssemblyProgram* program) { break; } if (file_offset < section->file_offset_of_raw_data) { - uint32 section_start_offset = section->file_offset_of_raw_data; + uint32_t section_start_offset = section->file_offset_of_raw_data; if(!ParseNonSectionFileRegion(file_offset, section_start_offset, program)) return false; file_offset = section_start_offset; } - uint32 end = file_offset + section->size_of_raw_data; + uint32_t end = file_offset + section->size_of_raw_data; if (!ParseFileRegion(section, file_offset, end, program)) return false; file_offset = end; @@ -382,7 +383,7 @@ bool DisassemblerWin32X86::ParseAbs32Relocs() { for (size_t i = 0; i < abs32_locations_.size(); ++i) { RVA rva = abs32_locations_[i]; // The 4 bytes at the relocation are a reference to some address. - uint32 target_address = Read32LittleEndian(RVAToPointer(rva)); + uint32_t target_address = Read32LittleEndian(RVAToPointer(rva)); ++abs32_target_rvas_[target_address - image_base()]; } #endif @@ -390,7 +391,7 @@ bool DisassemblerWin32X86::ParseAbs32Relocs() { } void DisassemblerWin32X86::ParseRel32RelocsFromSections() { - uint32 file_offset = 0; + uint32_t file_offset = 0; while (file_offset < length()) { const Section* section = FindNextSection(file_offset); if (section == NULL) @@ -433,11 +434,11 @@ void DisassemblerWin32X86::ParseRel32RelocsFromSection(const Section* section) { if (!isCode) return; - uint32 start_file_offset = section->file_offset_of_raw_data; - uint32 end_file_offset = start_file_offset + section->size_of_raw_data; + uint32_t start_file_offset = section->file_offset_of_raw_data; + uint32_t end_file_offset = start_file_offset + section->size_of_raw_data; - const uint8* start_pointer = OffsetToPointer(start_file_offset); - const uint8* end_pointer = OffsetToPointer(end_file_offset); + const uint8_t* start_pointer = OffsetToPointer(start_file_offset); + const uint8_t* end_pointer = OffsetToPointer(end_file_offset); RVA start_rva = FileOffsetToRVA(start_file_offset); RVA end_rva = start_rva + section->virtual_size; @@ -456,8 +457,8 @@ void DisassemblerWin32X86::ParseRel32RelocsFromSection(const Section* section) { } CheckBool DisassemblerWin32X86::ParseNonSectionFileRegion( - uint32 start_file_offset, - uint32 end_file_offset, + uint32_t start_file_offset, + uint32_t end_file_offset, AssemblyProgram* program) { if (incomplete_disassembly_) return true; @@ -472,21 +473,21 @@ CheckBool DisassemblerWin32X86::ParseNonSectionFileRegion( return true; } -CheckBool DisassemblerWin32X86::ParseFileRegion( - const Section* section, - uint32 start_file_offset, uint32 end_file_offset, - AssemblyProgram* program) { +CheckBool DisassemblerWin32X86::ParseFileRegion(const Section* section, + uint32_t start_file_offset, + uint32_t end_file_offset, + AssemblyProgram* program) { RVA relocs_start_rva = base_relocation_table().address_; - const uint8* start_pointer = OffsetToPointer(start_file_offset); - const uint8* end_pointer = OffsetToPointer(end_file_offset); + const uint8_t* start_pointer = OffsetToPointer(start_file_offset); + const uint8_t* end_pointer = OffsetToPointer(end_file_offset); RVA start_rva = FileOffsetToRVA(start_file_offset); RVA end_rva = start_rva + section->virtual_size; // Quick way to convert from Pointer to RVA within a single Section is to // subtract 'pointer_to_rva'. - const uint8* const adjust_pointer_to_rva = start_pointer - start_rva; + const uint8_t* const adjust_pointer_to_rva = start_pointer - start_rva; std::vector::iterator rel32_pos = rel32_locations_.begin(); std::vector::iterator abs32_pos = abs32_locations_.begin(); @@ -494,7 +495,7 @@ CheckBool DisassemblerWin32X86::ParseFileRegion( if (!program->EmitOriginInstruction(start_rva)) return false; - const uint8* p = start_pointer; + const uint8_t* p = start_pointer; while (p < end_pointer) { RVA current_rva = static_cast(p - adjust_pointer_to_rva); @@ -505,7 +506,7 @@ CheckBool DisassemblerWin32X86::ParseFileRegion( if (current_rva == relocs_start_rva) { if (!program->EmitPeRelocsInstruction()) return false; - uint32 relocs_size = base_relocation_table().size_; + uint32_t relocs_size = base_relocation_table().size_; if (relocs_size) { p += relocs_size; continue; @@ -516,7 +517,7 @@ CheckBool DisassemblerWin32X86::ParseFileRegion( ++abs32_pos; if (abs32_pos != abs32_locations_.end() && *abs32_pos == current_rva) { - uint32 target_address = Read32LittleEndian(p); + uint32_t target_address = Read32LittleEndian(p); RVA target_rva = target_address - image_base(); // TODO(sra): target could be Label+offset. It is not clear how to guess // which it might be. We assume offset==0. @@ -618,7 +619,8 @@ std::string DisassemblerWin32X86::DescribeRVA(RVA rva) const { return s.str(); } -const Section* DisassemblerWin32X86::FindNextSection(uint32 fileOffset) const { +const Section* DisassemblerWin32X86::FindNextSection( + uint32_t fileOffset) const { const Section* best = 0; for (int i = 0; i < number_of_sections_; i++) { const Section* section = §ions_[i]; @@ -634,10 +636,10 @@ const Section* DisassemblerWin32X86::FindNextSection(uint32 fileOffset) const { return best; } -RVA DisassemblerWin32X86::FileOffsetToRVA(uint32 file_offset) const { +RVA DisassemblerWin32X86::FileOffsetToRVA(uint32_t file_offset) const { for (int i = 0; i < number_of_sections_; i++) { const Section* section = §ions_[i]; - uint32 offset = file_offset - section->file_offset_of_raw_data; + uint32_t offset = file_offset - section->file_offset_of_raw_data; if (offset < section->size_of_raw_data) { return section->virtual_address + offset; } @@ -653,7 +655,7 @@ bool DisassemblerWin32X86::ReadDataDirectory( size_t offset = index * 8 + offset_of_data_directories_; if (offset >= size_of_optional_header_) return Bad("number of data directories inconsistent"); - const uint8* data_directory = optional_header_ + offset; + const uint8_t* data_directory = optional_header_ + offset; if (data_directory < start() || data_directory + 8 >= end()) return Bad("data directory outside image"); @@ -664,7 +666,7 @@ bool DisassemblerWin32X86::ReadDataDirectory( // TODO(sra): validate RVA. directory->address_ = rva; - directory->size_ = static_cast(size); + directory->size_ = static_cast(size); return true; } else { directory->address_ = 0; diff --git a/courgette/disassembler_win32_x86.h b/courgette/disassembler_win32_x86.h index 52ce520..891636c 100644 --- a/courgette/disassembler_win32_x86.h +++ b/courgette/disassembler_win32_x86.h @@ -5,7 +5,10 @@ #ifndef COURGETTE_DISASSEMBLER_WIN32_X86_H_ #define COURGETTE_DISASSEMBLER_WIN32_X86_H_ -#include "base/basictypes.h" +#include +#include + +#include "base/macros.h" #include "courgette/disassembler.h" #include "courgette/memory_allocator.h" #include "courgette/types_win_pe.h" @@ -36,7 +39,7 @@ class DisassemblerWin32X86 : public Disassembler { // bool has_text_section() const { return has_text_section_; } - uint32 size_of_code() const { return size_of_code_; } + uint32_t size_of_code() const { return size_of_code_; } bool is_32bit() const { return !is_PE32_plus_; } // Returns 'true' if the base relocation table can be parsed. @@ -53,7 +56,7 @@ class DisassemblerWin32X86 : public Disassembler { // Returns same as FileOffsetToPointer(RVAToFileOffset(rva)) except that NULL // is returned if there is no file offset corresponding to 'rva'. - const uint8* RVAToPointer(RVA rva) const; + const uint8_t* RVAToPointer(RVA rva) const; static std::string SectionName(const Section* section); @@ -63,11 +66,14 @@ class DisassemblerWin32X86 : public Disassembler { void ParseRel32RelocsFromSections(); void ParseRel32RelocsFromSection(const Section* section); - CheckBool ParseNonSectionFileRegion(uint32 start_file_offset, - uint32 end_file_offset, AssemblyProgram* program) WARN_UNUSED_RESULT; + CheckBool ParseNonSectionFileRegion(uint32_t start_file_offset, + uint32_t end_file_offset, + AssemblyProgram* program) + WARN_UNUSED_RESULT; CheckBool ParseFileRegion(const Section* section, - uint32 start_file_offset, uint32 end_file_offset, - AssemblyProgram* program) WARN_UNUSED_RESULT; + uint32_t start_file_offset, + uint32_t end_file_offset, + AssemblyProgram* program) WARN_UNUSED_RESULT; #if COURGETTE_HISTOGRAM_TARGETS void HistogramTargets(const char* kind, const std::map& map); @@ -76,7 +82,7 @@ class DisassemblerWin32X86 : public Disassembler { // Most addresses are represented as 32-bit RVAs. The one address we can't // do this with is the image base address. 'image_base' is valid only for // 32-bit executables. 'image_base_64' is valid for 32- and 64-bit executable. - uint32 image_base() const { return static_cast(image_base_); } + uint32_t image_base() const { return static_cast(image_base_); } const ImageDataDirectory& base_relocation_table() const { return base_relocation_table_; @@ -87,15 +93,14 @@ class DisassemblerWin32X86 : public Disassembler { // Finds the first section at file_offset or above. Does not return sections // that have no raw bytes in the file. - const Section* FindNextSection(uint32 file_offset) const; + const Section* FindNextSection(uint32_t file_offset) const; // There are 2 'coordinate systems' for reasoning about executables. // FileOffset - the the offset within a single .EXE or .DLL *file*. // RVA - relative virtual address (offset within *loaded image*) // FileOffsetToRVA and RVAToFileOffset convert between these representations. - RVA FileOffsetToRVA(uint32 offset) const; - + RVA FileOffsetToRVA(uint32_t offset) const; private: @@ -116,23 +121,23 @@ class DisassemblerWin32X86 : public Disassembler { bool is_PE32_plus_; // PE32_plus is for 64 bit executables. // Location and size of IMAGE_OPTIONAL_HEADER in the buffer. - const uint8 *optional_header_; - uint16 size_of_optional_header_; - uint16 offset_of_data_directories_; + const uint8_t* optional_header_; + uint16_t size_of_optional_header_; + uint16_t offset_of_data_directories_; - uint16 machine_type_; - uint16 number_of_sections_; + uint16_t machine_type_; + uint16_t number_of_sections_; const Section *sections_; bool has_text_section_; - uint32 size_of_code_; - uint32 size_of_initialized_data_; - uint32 size_of_uninitialized_data_; + uint32_t size_of_code_; + uint32_t size_of_initialized_data_; + uint32_t size_of_uninitialized_data_; RVA base_of_code_; RVA base_of_data_; - uint64 image_base_; // range limited to 32 bits for 32 bit executable - uint32 size_of_image_; + uint64_t image_base_; // range limited to 32 bits for 32 bit executable + uint32_t size_of_image_; int number_of_data_directories_; ImageDataDirectory export_table_; diff --git a/courgette/disassembler_win32_x86_unittest.cc b/courgette/disassembler_win32_x86_unittest.cc index 40cc412..4e16464 100644 --- a/courgette/disassembler_win32_x86_unittest.cc +++ b/courgette/disassembler_win32_x86_unittest.cc @@ -4,6 +4,8 @@ #include "courgette/disassembler_win32_x86.h" +#include + #include "base/memory/scoped_ptr.h" #include "base/stl_util.h" #include "courgette/base_test_unittest.h" @@ -44,13 +46,13 @@ void DisassemblerWin32X86Test::TestExe() const { EXPECT_TRUE(can_parse_relocs); EXPECT_TRUE(base::STLIsSorted(relocs)); - const uint8* offset_p = disassembler->OffsetToPointer(0); + const uint8_t* offset_p = disassembler->OffsetToPointer(0); EXPECT_EQ(reinterpret_cast(file1.c_str()), reinterpret_cast(offset_p)); EXPECT_EQ('M', offset_p[0]); EXPECT_EQ('Z', offset_p[1]); - const uint8* rva_p = disassembler->RVAToPointer(0); + const uint8_t* rva_p = disassembler->RVAToPointer(0); EXPECT_EQ(reinterpret_cast(file1.c_str()), reinterpret_cast(rva_p)); EXPECT_EQ('M', rva_p[0]); diff --git a/courgette/encode_decode_unittest.cc b/courgette/encode_decode_unittest.cc index 2cf5cd4..9e89c20 100644 --- a/courgette/encode_decode_unittest.cc +++ b/courgette/encode_decode_unittest.cc @@ -2,6 +2,8 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +#include + #include "courgette/base_test_unittest.h" #include "courgette/courgette.h" #include "courgette/streams.h" diff --git a/courgette/encoded_program.cc b/courgette/encoded_program.cc index a4c0089..209fe2f 100644 --- a/courgette/encoded_program.cc +++ b/courgette/encoded_program.cc @@ -4,6 +4,9 @@ #include "courgette/encoded_program.h" +#include +#include + #include #include #include @@ -42,7 +45,7 @@ CheckBool WriteVector(const V& items, SinkStream* buffer) { template bool ReadVector(V* items, SourceStream* buffer) { - uint32 count; + uint32_t count; if (!buffer->ReadVarint32(&count)) return false; @@ -50,7 +53,7 @@ bool ReadVector(V* items, SourceStream* buffer) { bool ok = items->reserve(count); for (size_t i = 0; ok && i < count; ++i) { - uint32 item; + uint32_t item; ok = buffer->ReadVarint32(&item); if (ok) ok = items->push_back(static_cast(item)); @@ -64,10 +67,10 @@ template CheckBool WriteSigned32Delta(const V& set, SinkStream* buffer) { size_t count = set.size(); bool ok = buffer->WriteSizeVarint32(count); - uint32 prev = 0; + uint32_t prev = 0; for (size_t i = 0; ok && i < count; ++i) { - uint32 current = set[i]; - int32 delta = current - prev; + uint32_t current = set[i]; + int32_t delta = current - prev; ok = buffer->WriteVarint32Signed(delta); prev = current; } @@ -76,19 +79,19 @@ CheckBool WriteSigned32Delta(const V& set, SinkStream* buffer) { template static CheckBool ReadSigned32Delta(V* set, SourceStream* buffer) { - uint32 count; + uint32_t count; if (!buffer->ReadVarint32(&count)) return false; set->clear(); bool ok = set->reserve(count); - uint32 prev = 0; + uint32_t prev = 0; for (size_t i = 0; ok && i < count; ++i) { - int32 delta; + int32_t delta; ok = buffer->ReadVarint32Signed(&delta); if (ok) { - uint32 current = static_cast(prev + delta); + uint32_t current = static_cast(prev + delta); ok = set->push_back(current); prev = current; } @@ -116,7 +119,7 @@ CheckBool WriteVectorU8(const V& items, SinkStream* buffer) { template bool ReadVectorU8(V* items, SourceStream* buffer) { - uint32 count; + uint32_t count; if (!buffer->ReadVarint32(&count)) return false; @@ -190,7 +193,7 @@ CheckBool EncodedProgram::AddOrigin(RVA origin) { } CheckBool EncodedProgram::AddCopy(size_t count, const void* bytes) { - const uint8* source = static_cast(bytes); + const uint8_t* source = static_cast(bytes); bool ok = true; @@ -240,7 +243,7 @@ CheckBool EncodedProgram::AddRel32(int label_index) { return ops_.push_back(REL32) && rel32_ix_.push_back(label_index); } -CheckBool EncodedProgram::AddRel32ARM(uint16 op, int label_index) { +CheckBool EncodedProgram::AddRel32ARM(uint16_t op, int label_index) { return ops_.push_back(static_cast(op)) && rel32_ix_.push_back(label_index); } @@ -295,7 +298,7 @@ static FieldSelect GetFieldSelect() { scoped_ptr env(base::Environment::Create()); std::string s; env->GetVar("A_FIELDS", &s); - uint64 fields; + uint64_t fields; if (!base::StringToUint64(s, &fields)) return static_cast(~0); return static_cast(fields); @@ -314,8 +317,8 @@ CheckBool EncodedProgram::WriteTo(SinkStreamSet* streams) { // the rest can be interleaved. if (select & INCLUDE_MISC) { - uint32 high = static_cast(image_base_ >> 32); - uint32 low = static_cast(image_base_ & 0xffffffffU); + uint32_t high = static_cast(image_base_ >> 32); + uint32_t low = static_cast(image_base_ & 0xffffffffU); if (!streams->stream(kStreamMisc)->WriteVarint32(high) || !streams->stream(kStreamMisc)->WriteVarint32(low)) { @@ -360,14 +363,14 @@ CheckBool EncodedProgram::WriteTo(SinkStreamSet* streams) { } bool EncodedProgram::ReadFrom(SourceStreamSet* streams) { - uint32 high; - uint32 low; + uint32_t high; + uint32_t low; if (!streams->stream(kStreamMisc)->ReadVarint32(&high) || !streams->stream(kStreamMisc)->ReadVarint32(&low)) { return false; } - image_base_ = (static_cast(high) << 32) | low; + image_base_ = (static_cast(high) << 32) | low; if (!ReadSigned32Delta(&abs32_rva_, streams->stream(kStreamAbs32Addresses))) return false; @@ -411,58 +414,56 @@ CheckBool EncodedProgram::EvaluateRel32ARM(OP op, SinkStream* output) { switch (op & 0x0000F000) { case REL32ARM8: { - uint32 index; + uint32_t index; if (!VectorAt(rel32_ix_, ix_rel32_ix, &index)) return false; ++ix_rel32_ix; RVA rva; if (!VectorAt(rel32_rva_, index, &rva)) return false; - uint32 decompressed_op; - if (!DisassemblerElf32ARM::Decompress(ARM_OFF8, - static_cast(op), - static_cast(rva - - current_rva), - &decompressed_op)) { + uint32_t decompressed_op; + if (!DisassemblerElf32ARM::Decompress( + ARM_OFF8, static_cast(op), + static_cast(rva - current_rva), &decompressed_op)) { return false; } - uint16 op16 = static_cast(decompressed_op); + uint16_t op16 = static_cast(decompressed_op); if (!output->Write(&op16, 2)) return false; current_rva += 2; break; } case REL32ARM11: { - uint32 index; + uint32_t index; if (!VectorAt(rel32_ix_, ix_rel32_ix, &index)) return false; ++ix_rel32_ix; RVA rva; if (!VectorAt(rel32_rva_, index, &rva)) return false; - uint32 decompressed_op; - if (!DisassemblerElf32ARM::Decompress(ARM_OFF11, (uint16) op, - (uint32) (rva - current_rva), + uint32_t decompressed_op; + if (!DisassemblerElf32ARM::Decompress(ARM_OFF11, (uint16_t)op, + (uint32_t)(rva - current_rva), &decompressed_op)) { return false; } - uint16 op16 = static_cast(decompressed_op); + uint16_t op16 = static_cast(decompressed_op); if (!output->Write(&op16, 2)) return false; current_rva += 2; break; } case REL32ARM24: { - uint32 index; + uint32_t index; if (!VectorAt(rel32_ix_, ix_rel32_ix, &index)) return false; ++ix_rel32_ix; RVA rva; if (!VectorAt(rel32_rva_, index, &rva)) return false; - uint32 decompressed_op; - if (!DisassemblerElf32ARM::Decompress(ARM_OFF24, (uint16) op, - (uint32) (rva - current_rva), + uint32_t decompressed_op; + if (!DisassemblerElf32ARM::Decompress(ARM_OFF24, (uint16_t)op, + (uint32_t)(rva - current_rva), &decompressed_op)) { return false; } @@ -472,40 +473,40 @@ CheckBool EncodedProgram::EvaluateRel32ARM(OP op, break; } case REL32ARM25: { - uint32 index; + uint32_t index; if (!VectorAt(rel32_ix_, ix_rel32_ix, &index)) return false; ++ix_rel32_ix; RVA rva; if (!VectorAt(rel32_rva_, index, &rva)) return false; - uint32 decompressed_op; - if (!DisassemblerElf32ARM::Decompress(ARM_OFF25, (uint16) op, - (uint32) (rva - current_rva), + uint32_t decompressed_op; + if (!DisassemblerElf32ARM::Decompress(ARM_OFF25, (uint16_t)op, + (uint32_t)(rva - current_rva), &decompressed_op)) { return false; } - uint32 words = (decompressed_op << 16) | (decompressed_op >> 16); + uint32_t words = (decompressed_op << 16) | (decompressed_op >> 16); if (!output->Write(&words, 4)) return false; current_rva += 4; break; } case REL32ARM21: { - uint32 index; + uint32_t index; if (!VectorAt(rel32_ix_, ix_rel32_ix, &index)) return false; ++ix_rel32_ix; RVA rva; if (!VectorAt(rel32_rva_, index, &rva)) return false; - uint32 decompressed_op; - if (!DisassemblerElf32ARM::Decompress(ARM_OFF21, (uint16) op, - (uint32) (rva - current_rva), + uint32_t decompressed_op; + if (!DisassemblerElf32ARM::Decompress(ARM_OFF21, (uint16_t)op, + (uint32_t)(rva - current_rva), &decompressed_op)) { return false; } - uint32 words = (decompressed_op << 16) | (decompressed_op >> 16); + uint32_t words = (decompressed_op << 16) | (decompressed_op >> 16); if (!output->Write(&words, 4)) return false; current_rva += 4; @@ -530,7 +531,7 @@ CheckBool EncodedProgram::AssembleTo(SinkStream* final_buffer) { RVA current_rva = 0; bool pending_pe_relocation_table = false; - uint8 pending_pe_relocation_table_type = 0x03; // IMAGE_REL_BASED_HIGHLOW + uint8_t pending_pe_relocation_table_type = 0x03; // IMAGE_REL_BASED_HIGHLOW Elf32_Word pending_elf_relocation_table_type = 0; SinkStream bytes_following_relocation_table; @@ -560,7 +561,7 @@ CheckBool EncodedProgram::AssembleTo(SinkStream* final_buffer) { return false; ++ix_copy_counts; for (size_t i = 0; i < count; ++i) { - uint8 b; + uint8_t b; if (!VectorAt(copy_bytes_, ix_copy_bytes, &b)) return false; ++ix_copy_bytes; @@ -572,7 +573,7 @@ CheckBool EncodedProgram::AssembleTo(SinkStream* final_buffer) { } case COPY1: { - uint8 b; + uint8_t b; if (!VectorAt(copy_bytes_, ix_copy_bytes, &b)) return false; ++ix_copy_bytes; @@ -583,14 +584,14 @@ CheckBool EncodedProgram::AssembleTo(SinkStream* final_buffer) { } case REL32: { - uint32 index; + uint32_t index; if (!VectorAt(rel32_ix_, ix_rel32_ix, &index)) return false; ++ix_rel32_ix; RVA rva; if (!VectorAt(rel32_rva_, index, &rva)) return false; - uint32 offset = (rva - (current_rva + 4)); + uint32_t offset = (rva - (current_rva + 4)); if (!output->Write(&offset, 4)) return false; current_rva += 4; @@ -599,7 +600,7 @@ CheckBool EncodedProgram::AssembleTo(SinkStream* final_buffer) { case ABS32: case ABS64: { - uint32 index; + uint32_t index; if (!VectorAt(abs32_ix_, ix_abs32_ix, &index)) return false; ++ix_abs32_ix; @@ -607,18 +608,18 @@ CheckBool EncodedProgram::AssembleTo(SinkStream* final_buffer) { if (!VectorAt(abs32_rva_, index, &rva)) return false; if (op == ABS32) { - base::CheckedNumeric abs32 = image_base_; + base::CheckedNumeric abs32 = image_base_; abs32 += rva; - uint32 safe_abs32 = abs32.ValueOrDie(); + uint32_t safe_abs32 = abs32.ValueOrDie(); if (!abs32_relocs_.push_back(current_rva) || !output->Write(&safe_abs32, 4)) { return false; } current_rva += 4; } else { - base::CheckedNumeric abs64 = image_base_; + base::CheckedNumeric abs64 = image_base_; abs64 += rva; - uint64 safe_abs64 = abs64.ValueOrDie(); + uint64_t safe_abs64 = abs64.ValueOrDie(); if (!abs32_relocs_.push_back(current_rva) || !output->Write(&safe_abs64, 8)) { return false; @@ -715,9 +716,9 @@ CheckBool EncodedProgram::AssembleTo(SinkStream* final_buffer) { // table file format. // struct RelocBlockPOD { - uint32 page_rva; - uint32 block_size; - uint16 relocs[4096]; // Allow up to one relocation per byte of a 4k page. + uint32_t page_rva; + uint32_t block_size; + uint16_t relocs[4096]; // Allow up to one relocation per byte of a 4k page. }; static_assert(offsetof(RelocBlockPOD, relocs) == 8, "reloc block header size"); @@ -729,7 +730,7 @@ class RelocBlock { pod.block_size = 8; } - void Add(uint16 item) { + void Add(uint16_t item) { pod.relocs[(pod.block_size-8)/2] = item; pod.block_size += 2; } @@ -749,21 +750,21 @@ class RelocBlock { }; CheckBool EncodedProgram::GeneratePeRelocations(SinkStream* buffer, - uint8 type) { + uint8_t type) { std::sort(abs32_relocs_.begin(), abs32_relocs_.end()); RelocBlock block; bool ok = true; for (size_t i = 0; ok && i < abs32_relocs_.size(); ++i) { - uint32 rva = abs32_relocs_[i]; - uint32 page_rva = rva & ~0xFFF; + uint32_t rva = abs32_relocs_[i]; + uint32_t page_rva = rva & ~0xFFF; if (page_rva != block.pod.page_rva) { ok &= block.Flush(buffer); block.pod.page_rva = page_rva; } if (ok) - block.Add(((static_cast(type)) << 12) | (rva & 0xFFF)); + block.Add(((static_cast(type)) << 12) | (rva & 0xFFF)); } ok &= block.Flush(buffer); return ok; diff --git a/courgette/encoded_program.h b/courgette/encoded_program.h index 641f523..81e1639 100644 --- a/courgette/encoded_program.h +++ b/courgette/encoded_program.h @@ -5,9 +5,12 @@ #ifndef COURGETTE_ENCODED_PROGRAM_H_ #define COURGETTE_ENCODED_PROGRAM_H_ +#include +#include + #include -#include "base/basictypes.h" +#include "base/macros.h" #include "courgette/disassembler.h" #include "courgette/memory_allocator.h" #include "courgette/types_elf.h" @@ -43,7 +46,7 @@ class EncodedProgram { // Generating an EncodedProgram: // // (1) The image base can be specified at any time. - void set_image_base(uint64 base) { image_base_ = base; } + void set_image_base(uint64_t base) { image_base_ = base; } // (2) Address tables and indexes defined first. CheckBool DefineRel32Label(int index, RVA address) WARN_UNUSED_RESULT; @@ -56,7 +59,7 @@ class EncodedProgram { CheckBool AddOrigin(RVA rva) WARN_UNUSED_RESULT; CheckBool AddCopy(size_t count, const void* bytes) WARN_UNUSED_RESULT; CheckBool AddRel32(int label_index) WARN_UNUSED_RESULT; - CheckBool AddRel32ARM(uint16 op, int label_index) WARN_UNUSED_RESULT; + CheckBool AddRel32ARM(uint16_t op, int label_index) WARN_UNUSED_RESULT; CheckBool AddAbs32(int label_index) WARN_UNUSED_RESULT; CheckBool AddAbs64(int label_index) WARN_UNUSED_RESULT; CheckBool AddPeMakeRelocs(ExecutableType kind) WARN_UNUSED_RESULT; @@ -104,13 +107,13 @@ class EncodedProgram { typedef NoThrowBuffer RvaVector; typedef NoThrowBuffer SizeTVector; - typedef NoThrowBuffer UInt32Vector; - typedef NoThrowBuffer UInt8Vector; + typedef NoThrowBuffer UInt32Vector; + typedef NoThrowBuffer UInt8Vector; typedef NoThrowBuffer OPVector; void DebuggingSummary(); - CheckBool GeneratePeRelocations(SinkStream *buffer, - uint8 type) WARN_UNUSED_RESULT; + CheckBool GeneratePeRelocations(SinkStream* buffer, + uint8_t type) WARN_UNUSED_RESULT; CheckBool GenerateElfRelocations(Elf32_Word pending_elf_relocation_table, SinkStream *buffer) WARN_UNUSED_RESULT; CheckBool DefineLabelCommon(RvaVector*, int, RVA) WARN_UNUSED_RESULT; @@ -121,7 +124,7 @@ class EncodedProgram { SinkStream* output); // Binary assembly language tables. - uint64 image_base_; + uint64_t image_base_; RvaVector rel32_rva_; RvaVector abs32_rva_; OPVector ops_; diff --git a/courgette/encoded_program_fuzz_unittest.cc b/courgette/encoded_program_fuzz_unittest.cc index 9801fc8..b755f85 100644 --- a/courgette/encoded_program_fuzz_unittest.cc +++ b/courgette/encoded_program_fuzz_unittest.cc @@ -13,6 +13,8 @@ #include "base/test/test_suite.h" +#include + #include "courgette/base_test_unittest.h" #include "courgette/courgette.h" #include "courgette/streams.h" diff --git a/courgette/encoded_program_unittest.cc b/courgette/encoded_program_unittest.cc index a2ce9b6..5d29452 100644 --- a/courgette/encoded_program_unittest.cc +++ b/courgette/encoded_program_unittest.cc @@ -4,6 +4,9 @@ #include "courgette/encoded_program.h" +#include +#include + #include "base/macros.h" #include "base/memory/scoped_ptr.h" #include "courgette/disassembler.h" @@ -15,7 +18,7 @@ namespace { using courgette::EncodedProgram; struct AddressSpec { - int32 index; + int32_t index; courgette::RVA rva; }; @@ -27,7 +30,7 @@ scoped_ptr CreateTestProgram(AddressSpec* abs32_specs, size_t num_rel32_specs) { scoped_ptr program(new EncodedProgram()); - uint32 base = 0x00900000; + uint32_t base = 0x00900000; program->set_image_base(base); for (size_t i = 0; i < num_abs32_specs; ++i) { @@ -48,13 +51,13 @@ scoped_ptr CreateTestProgram(AddressSpec* abs32_specs, return program; } -bool CompareSink(const uint8 expected[], +bool CompareSink(const uint8_t expected[], size_t num_expected, courgette::SinkStream* ss) { size_t n = ss->Length(); if (num_expected != n) return false; - const uint8* buffer = ss->Buffer(); + const uint8_t* buffer = ss->Buffer(); return memcmp(&expected[0], buffer, n) == 0; } @@ -98,9 +101,11 @@ TEST(EncodedProgramTest, Test) { EXPECT_TRUE(can_assemble); encoded2.reset(); - const uint8 golden[] = { - 0x04, 0x00, 0x90, 0x00, // ABS32 to base + 4 - 0xF8, 0xFF, 0xFF, 0xFF // REL32 from next line to base + 2 + const uint8_t golden[] = { + 0x04, 0x00, 0x90, + 0x00, // ABS32 to base + 4 + 0xF8, 0xFF, 0xFF, + 0xFF // REL32 from next line to base + 2 }; EXPECT_TRUE(CompareSink(golden, arraysize(golden), &assembled)); } @@ -121,15 +126,15 @@ TEST(EncodedProgramTest, TestWriteAddress) { program.reset(); // Check addresses in sinks. - const uint8 golden_abs32_indexes[] = { - 0x03, 0x07, 0x03, 0x05 // 3 indexes: [7, 3, 5]. + const uint8_t golden_abs32_indexes[] = { + 0x03, 0x07, 0x03, 0x05 // 3 indexes: [7, 3, 5]. }; EXPECT_TRUE(CompareSink(golden_abs32_indexes, arraysize(golden_abs32_indexes), sinks.stream(courgette::kStreamAbs32Indexes))); - const uint8 golden_rel32_indexes[] = { - 0x03, 0x00, 0x03, 0x01 // 3 indexes: [0, 3, 1]. + const uint8_t golden_rel32_indexes[] = { + 0x03, 0x00, 0x03, 0x01 // 3 indexes: [0, 3, 1]. }; EXPECT_TRUE(CompareSink(golden_rel32_indexes, arraysize(golden_rel32_indexes), @@ -141,9 +146,9 @@ TEST(EncodedProgramTest, TestWriteAddress) { // Hex: [0, 0, 0, 0x02, 0, 0x15, 0, 0xFFFFFFF4]. // Complement neg: [0, 0, 0, 0x02, 0, 0x15, 0, (0x0B)]. // Varint32 Signed: [0, 0, 0, 0x04, 0, 0x2A, 0, 0x17]. - const uint8 golden_abs32_addresses[] = { - 0x08, // 8 address deltas. - 0x00, 0x00, 0x00, 0x04, 0x00, 0x2A, 0x00, 0x17, + const uint8_t golden_abs32_addresses[] = { + 0x08, // 8 address deltas. + 0x00, 0x00, 0x00, 0x04, 0x00, 0x2A, 0x00, 0x17, }; EXPECT_TRUE(CompareSink(golden_abs32_addresses, arraysize(golden_abs32_addresses), @@ -155,9 +160,9 @@ TEST(EncodedProgramTest, TestWriteAddress) { // Hex: [0x10, 0xFFFFFFF7, 0, 0x19]. // Complement Neg: [0x10, (0x08), 0, 0x19]. // Varint32 Signed: [0x20, 0x11, 0, 0x32]. - const uint8 golden_rel32_addresses[] = { - 0x04, // 4 address deltas. - 0x20, 0x11, 0x00, 0x32, + const uint8_t golden_rel32_addresses[] = { + 0x04, // 4 address deltas. + 0x20, 0x11, 0x00, 0x32, }; EXPECT_TRUE(CompareSink(golden_rel32_addresses, arraysize(golden_rel32_addresses), diff --git a/courgette/ensemble.cc b/courgette/ensemble.cc index 669e264..d5277a4 100644 --- a/courgette/ensemble.cc +++ b/courgette/ensemble.cc @@ -4,7 +4,9 @@ #include "courgette/ensemble.h" -#include "base/basictypes.h" +#include +#include + #include "base/strings/string_number_conversions.h" #include "courgette/region.h" @@ -33,7 +35,7 @@ std::string Element::Name() const { Status Ensemble::FindEmbeddedElements() { size_t length = region_.length(); - const uint8* start = region_.start(); + const uint8_t* start = region_.start(); size_t position = 0; while (position < length) { diff --git a/courgette/ensemble.h b/courgette/ensemble.h index e538bd6..adb4b07 100644 --- a/courgette/ensemble.h +++ b/courgette/ensemble.h @@ -17,11 +17,13 @@ #ifndef COURGETTE_ENSEMBLE_H_ #define COURGETTE_ENSEMBLE_H_ -#include -#include +#include +#include -#include "base/basictypes.h" +#include +#include +#include "base/macros.h" #include "courgette/courgette.h" #include "courgette/region.h" #include "courgette/streams.h" @@ -130,9 +132,9 @@ struct CourgettePatchFile { // element-2 // ... - static const uint32 kMagic = 'C' | ('o' << 8) | ('u' << 16); + static const uint32_t kMagic = 'C' | ('o' << 8) | ('u' << 16); - static const uint32 kVersion = 20110216; + static const uint32_t kVersion = 20110216; }; // For any transform you would implement both a TransformationPatcher and a diff --git a/courgette/ensemble_apply.cc b/courgette/ensemble_apply.cc index 121fae8..f740ba9 100644 --- a/courgette/ensemble_apply.cc +++ b/courgette/ensemble_apply.cc @@ -6,10 +6,13 @@ #include "courgette/ensemble.h" -#include "base/basictypes.h" +#include +#include + #include "base/files/file_util.h" #include "base/files/memory_mapped_file.h" #include "base/logging.h" +#include "base/macros.h" #include "courgette/crc.h" #include "courgette/patcher_x86_32.h" #include "courgette/region.h" @@ -61,9 +64,9 @@ class EnsemblePatchApplication { Region base_region_; // Location of in-memory copy of 'old' version. - uint32 source_checksum_; - uint32 target_checksum_; - uint32 final_patch_input_size_prediction_; + uint32_t source_checksum_; + uint32_t target_checksum_; + uint32_t final_patch_input_size_prediction_; std::vector patchers_; @@ -85,14 +88,14 @@ EnsemblePatchApplication::~EnsemblePatchApplication() { } Status EnsemblePatchApplication::ReadHeader(SourceStream* header_stream) { - uint32 magic; + uint32_t magic; if (!header_stream->ReadVarint32(&magic)) return C_BAD_ENSEMBLE_MAGIC; if (magic != CourgettePatchFile::kMagic) return C_BAD_ENSEMBLE_MAGIC; - uint32 version; + uint32_t version; if (!header_stream->ReadVarint32(&version)) return C_BAD_ENSEMBLE_VERSION; @@ -117,7 +120,7 @@ Status EnsemblePatchApplication::InitBase(const Region& region) { } Status EnsemblePatchApplication::ValidateBase() { - uint32 checksum = CalculateCrc(base_region_.start(), base_region_.length()); + uint32_t checksum = CalculateCrc(base_region_.start(), base_region_.length()); if (source_checksum_ != checksum) return C_BAD_ENSEMBLE_CRC; @@ -126,12 +129,12 @@ Status EnsemblePatchApplication::ValidateBase() { Status EnsemblePatchApplication::ReadInitialParameters( SourceStream* transformation_parameters) { - uint32 number_of_transformations = 0; + uint32_t number_of_transformations = 0; if (!transformation_parameters->ReadVarint32(&number_of_transformations)) return C_BAD_ENSEMBLE_HEADER; for (size_t i = 0; i < number_of_transformations; ++i) { - uint32 kind; + uint32_t kind; if (!transformation_parameters->ReadVarint32(&kind)) return C_BAD_ENSEMBLE_HEADER; diff --git a/courgette/ensemble_create.cc b/courgette/ensemble_create.cc index ea5873c..3bc1846 100644 --- a/courgette/ensemble_create.cc +++ b/courgette/ensemble_create.cc @@ -14,10 +14,11 @@ #include "courgette/ensemble.h" +#include + #include #include -#include "base/basictypes.h" #include "base/logging.h" #include "base/time/time.h" diff --git a/courgette/image_utils.h b/courgette/image_utils.h index 47ba4f4..9a077fd 100644 --- a/courgette/image_utils.h +++ b/courgette/image_utils.h @@ -5,7 +5,8 @@ #ifndef COURGETTE_IMAGE_UTILS_H_ #define COURGETTE_IMAGE_UTILS_H_ -#include "base/basictypes.h" +#include +#include // COURGETTE_HISTOGRAM_TARGETS prints out a histogram of how frequently // different target addresses are referenced. Purely for debugging. @@ -13,7 +14,7 @@ namespace courgette { -typedef uint32 RVA; +typedef uint32_t RVA; // A Label is a symbolic reference to an address. Unlike a conventional // assembly language, we always know the address. The address will later be @@ -32,32 +33,32 @@ class Label { RVA rva_ = 0; // Address referred to by the label. int index_ = kNoIndex; // Index of address in address table. - int32 count_ = 0; + int32_t count_ = 0; }; // These helper functions avoid the need for casts in the main code. -inline uint16 ReadU16(const uint8* address, size_t offset) { - return *reinterpret_cast(address + offset); +inline uint16_t ReadU16(const uint8_t* address, size_t offset) { + return *reinterpret_cast(address + offset); } -inline uint32 ReadU32(const uint8* address, size_t offset) { - return *reinterpret_cast(address + offset); +inline uint32_t ReadU32(const uint8_t* address, size_t offset) { + return *reinterpret_cast(address + offset); } -inline uint64 ReadU64(const uint8* address, size_t offset) { - return *reinterpret_cast(address + offset); +inline uint64_t ReadU64(const uint8_t* address, size_t offset) { + return *reinterpret_cast(address + offset); } -inline uint16 Read16LittleEndian(const void* address) { - return *reinterpret_cast(address); +inline uint16_t Read16LittleEndian(const void* address) { + return *reinterpret_cast(address); } -inline uint32 Read32LittleEndian(const void* address) { - return *reinterpret_cast(address); +inline uint32_t Read32LittleEndian(const void* address) { + return *reinterpret_cast(address); } -inline uint64 Read64LittleEndian(const void* address) { - return *reinterpret_cast(address); +inline uint64_t Read64LittleEndian(const void* address) { + return *reinterpret_cast(address); } } // namespace courgette diff --git a/courgette/image_utils_unittest.cc b/courgette/image_utils_unittest.cc index a90c19b..5b914c5 100644 --- a/courgette/image_utils_unittest.cc +++ b/courgette/image_utils_unittest.cc @@ -4,6 +4,8 @@ #include "courgette/image_utils.h" +#include + #include "testing/gtest/include/gtest/gtest.h" namespace courgette { @@ -11,7 +13,7 @@ namespace courgette { namespace { TEST(ImageUtilsTest, Read) { - uint8 test_data[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 00}; + uint8_t test_data[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 00}; EXPECT_EQ(0x2301U, Read16LittleEndian(test_data)); EXPECT_EQ(0x67452301U, Read32LittleEndian(test_data)); EXPECT_EQ(0xEFCDAB8967452301ULL, Read64LittleEndian(test_data)); diff --git a/courgette/label_manager.cc b/courgette/label_manager.cc index 14b6b4f..f19975d 100644 --- a/courgette/label_manager.cc +++ b/courgette/label_manager.cc @@ -4,6 +4,9 @@ #include "courgette/label_manager.h" +#include +#include + #include #include "base/logging.h" @@ -47,12 +50,12 @@ void LabelManager::Read(RvaVisitor* rva_visitor) { labels_.reserve(num_distinct_rva); for (CRV it(rvas.begin(), rvas.end()); it.has_more(); it.advance()) { labels_.push_back(Label(*it.cur())); - base::CheckedNumeric count = it.repeat(); + base::CheckedNumeric count = it.repeat(); labels_.back().count_ = count.ValueOrDie(); } } -void LabelManager::RemoveUnderusedLabels(int32 count_threshold) { +void LabelManager::RemoveUnderusedLabels(int32_t count_threshold) { if (count_threshold <= 0) return; labels_.erase(std::remove_if(labels_.begin(), labels_.end(), diff --git a/courgette/label_manager.h b/courgette/label_manager.h index 595e2e7..d155561 100644 --- a/courgette/label_manager.h +++ b/courgette/label_manager.h @@ -5,6 +5,9 @@ #ifndef COURGETTE_LABEL_MANAGER_H_ #define COURGETTE_LABEL_MANAGER_H_ +#include +#include + #include #include "base/macros.h" @@ -43,7 +46,7 @@ class LabelManager { void Read(RvaVisitor* rva_visitor); // Removes |labels_| elements whose |count_| is less than |count_threshold|. - void RemoveUnderusedLabels(int32 count_threshold); + void RemoveUnderusedLabels(int32_t count_threshold); // Efficiently searches for a Label that targets |rva|. Returns the pointer to // the stored Label instance if found, or null otherwise. diff --git a/courgette/label_manager_unittest.cc b/courgette/label_manager_unittest.cc index 2387162..acc6240 100644 --- a/courgette/label_manager_unittest.cc +++ b/courgette/label_manager_unittest.cc @@ -4,6 +4,9 @@ #include "courgette/label_manager.h" +#include +#include + #include #include #include @@ -42,7 +45,7 @@ class TestLabelManager : public LabelManager { }; void CheckLabelManagerContent(TestLabelManager* label_manager, - const std::map& expected) { + const std::map& expected) { EXPECT_EQ(expected.size(), label_manager->LabelCount()); for (const auto& rva_and_count : expected) { Label* label = label_manager->Find(rva_and_count.first); @@ -75,16 +78,11 @@ TEST(LabelManagerTest, Basic) { TestLabelManager label_manager; label_manager.Read(&visitor); - static const std::pair kExpected1Raw[] = { - {0x00000110, 1}, - {0x04000010, 3}, - {0x04000020, 1}, - {0x04000030, 2}, - {0xABCD1234, 1}, - {0xFEEDF00D, 2} - }; - std::map expected1(std::begin(kExpected1Raw), - std::end(kExpected1Raw)); + static const std::pair kExpected1Raw[] = { + {0x00000110, 1}, {0x04000010, 3}, {0x04000020, 1}, + {0x04000030, 2}, {0xABCD1234, 1}, {0xFEEDF00D, 2}}; + std::map expected1(std::begin(kExpected1Raw), + std::end(kExpected1Raw)); CheckLabelManagerContent(&label_manager, expected1); @@ -98,13 +96,10 @@ TEST(LabelManagerTest, Basic) { // Remove Labels with |count_| < 2. label_manager.RemoveUnderusedLabels(2); - static const std::pair kExpected2Raw[] = { - {0x04000010, 3}, - {0x04000030, 2}, - {0xFEEDF00D, 2} - }; - std::map expected2(std::begin(kExpected2Raw), - std::end(kExpected2Raw)); + static const std::pair kExpected2Raw[] = { + {0x04000010, 3}, {0x04000030, 2}, {0xFEEDF00D, 2}}; + std::map expected2(std::begin(kExpected2Raw), + std::end(kExpected2Raw)); CheckLabelManagerContent(&label_manager, expected2); } diff --git a/courgette/memory_allocator.cc b/courgette/memory_allocator.cc index 5b92c80..e83a293 100644 --- a/courgette/memory_allocator.cc +++ b/courgette/memory_allocator.cc @@ -4,6 +4,9 @@ #include "courgette/memory_allocator.h" +#include +#include + #include #include "base/files/file_util.h" @@ -108,7 +111,7 @@ bool TempMapping::Initialize(size_t size) { } void* TempMapping::memory() const { - uint8* mem = reinterpret_cast(mapping_.view()); + uint8_t* mem = reinterpret_cast(mapping_.view()); // The 'this' pointer is written at the start of mapping_.view(), so // go past it. (See Initialize()). if (mem) diff --git a/courgette/memory_allocator.h b/courgette/memory_allocator.h index 59d3ec8..6541e91 100644 --- a/courgette/memory_allocator.h +++ b/courgette/memory_allocator.h @@ -5,9 +5,10 @@ #ifndef COURGETTE_MEMORY_ALLOCATOR_H_ #define COURGETTE_MEMORY_ALLOCATOR_H_ +#include +#include #include -#include "base/basictypes.h" #include "base/compiler_specific.h" #include "base/files/file.h" #include "base/files/file_path.h" @@ -194,12 +195,12 @@ class MemoryAllocator { } void deallocate(pointer ptr, size_type size) { - uint8* mem = reinterpret_cast(ptr); + uint8_t* mem = reinterpret_cast(ptr); mem -= sizeof(T); if (mem[0] == HEAP_ALLOCATION) { free(mem); } else { - DCHECK_EQ(static_cast(FILE_ALLOCATION), mem[0]); + DCHECK_EQ(static_cast(FILE_ALLOCATION), mem[0]); UncheckedDelete(TempMapping::GetMappingFromPtr(mem)); } } @@ -215,20 +216,20 @@ class MemoryAllocator { return NULL; size_type bytes = count * sizeof(T); - uint8* mem = NULL; + uint8_t* mem = NULL; // First see if we can do this allocation on the heap. if (count < kMaxHeapAllocationSize && base::UncheckedMalloc(bytes, reinterpret_cast(&mem))) { - mem[0] = static_cast(HEAP_ALLOCATION); + mem[0] = static_cast(HEAP_ALLOCATION); } else { // Back the allocation with a temp file if either the request exceeds the // max heap allocation threshold or the heap allocation failed. TempMapping* mapping = UncheckedNew(); if (mapping) { if (mapping->Initialize(bytes)) { - mem = reinterpret_cast(mapping->memory()); - mem[0] = static_cast(FILE_ALLOCATION); + mem = reinterpret_cast(mapping->memory()); + mem[0] = static_cast(FILE_ALLOCATION); } else { UncheckedDelete(mapping); } diff --git a/courgette/memory_allocator_unittest.cc b/courgette/memory_allocator_unittest.cc index 335cdc9..9d2d476 100644 --- a/courgette/memory_allocator_unittest.cc +++ b/courgette/memory_allocator_unittest.cc @@ -4,6 +4,8 @@ #include "courgette/memory_allocator.h" +#include + #include #include "base/macros.h" diff --git a/courgette/memory_monitor.cc b/courgette/memory_monitor.cc index 2769cdc..a480531 100644 --- a/courgette/memory_monitor.cc +++ b/courgette/memory_monitor.cc @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +#include #include #include diff --git a/courgette/patch_generator_x86_32.h b/courgette/patch_generator_x86_32.h index 3610eeb..ac558be 100644 --- a/courgette/patch_generator_x86_32.h +++ b/courgette/patch_generator_x86_32.h @@ -9,8 +9,8 @@ #define COURGETTE_WIN32_X86_GENERATOR_H_ #include "base/logging.h" +#include "base/macros.h" #include "base/memory/scoped_ptr.h" - #include "courgette/assembly_program.h" #include "courgette/ensemble.h" diff --git a/courgette/patcher_x86_32.h b/courgette/patcher_x86_32.h index e984579..3461d79 100644 --- a/courgette/patcher_x86_32.h +++ b/courgette/patcher_x86_32.h @@ -5,6 +5,9 @@ #ifndef COURGETTE_WIN32_X86_PATCHER_H_ #define COURGETTE_WIN32_X86_PATCHER_H_ +#include + +#include "base/macros.h" #include "courgette/ensemble.h" namespace courgette { @@ -90,8 +93,8 @@ class PatcherX86_32 : public TransformationPatcher { private: Region ensemble_region_; - uint32 base_offset_; - uint32 base_length_; + uint32_t base_offset_; + uint32_t base_length_; DISALLOW_COPY_AND_ASSIGN(PatcherX86_32); }; diff --git a/courgette/region.h b/courgette/region.h index 4aafbca..b0100cf 100644 --- a/courgette/region.h +++ b/courgette/region.h @@ -5,9 +5,11 @@ #ifndef COURGETTE_REGION_H_ #define COURGETTE_REGION_H_ +#include +#include + #include -#include "base/basictypes.h" namespace courgette { @@ -21,16 +23,13 @@ class Region { // Usual constructor for regions given a |start| address and |length|. Region(const void* start, size_t length) - : start_(static_cast(start)), - length_(length) { - } + : start_(static_cast(start)), length_(length) {} // String constructor. Region is owned by the string, so the string should // have a lifetime greater than the region. explicit Region(const std::string& string) - : start_(reinterpret_cast(string.c_str())), - length_(string.length()) { - } + : start_(reinterpret_cast(string.c_str())), + length_(string.length()) {} // Copy constructor. Region(const Region& other) : start_(other.start_), length_(other.length_) {} @@ -43,16 +42,16 @@ class Region { } // Returns the starting address of the region. - const uint8* start() const { return start_; } + const uint8_t* start() const { return start_; } // Returns the length of the region. size_t length() const { return length_; } // Returns the address after the last byte of the region. - const uint8* end() const { return start_ + length_; } + const uint8_t* end() const { return start_ + length_; } private: - const uint8* start_; + const uint8_t* start_; size_t length_; void operator=(const Region&); // Disallow assignment operator. diff --git a/courgette/rel32_finder_win32_x86.cc b/courgette/rel32_finder_win32_x86.cc index 09419e9..171b781 100644 --- a/courgette/rel32_finder_win32_x86.cc +++ b/courgette/rel32_finder_win32_x86.cc @@ -2,6 +2,8 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +#include + #include "courgette/rel32_finder_win32_x86.h" namespace courgette { @@ -34,20 +36,19 @@ Rel32FinderWin32X86_Basic::Rel32FinderWin32X86_Basic( Rel32FinderWin32X86_Basic::~Rel32FinderWin32X86_Basic() { } -void Rel32FinderWin32X86_Basic::Find( - const uint8* start_pointer, - const uint8* end_pointer, - RVA start_rva, - RVA end_rva, - const std::vector& abs32_locations) { +void Rel32FinderWin32X86_Basic::Find(const uint8_t* start_pointer, + const uint8_t* end_pointer, + RVA start_rva, + RVA end_rva, + const std::vector& abs32_locations) { // Quick way to convert from Pointer to RVA within a single Section is to // subtract 'pointer_to_rva'. - const uint8* const adjust_pointer_to_rva = start_pointer - start_rva; + const uint8_t* const adjust_pointer_to_rva = start_pointer - start_rva; std::vector::const_iterator abs32_pos = abs32_locations.begin(); // Find the rel32 relocations. - const uint8* p = start_pointer; + const uint8_t* p = start_pointer; while (p < end_pointer) { RVA current_rva = static_cast(p - adjust_pointer_to_rva); if (current_rva == relocs_start_rva_) { @@ -63,7 +64,7 @@ void Rel32FinderWin32X86_Basic::Find( // Heuristic discovery of rel32 locations in instruction stream: are the // next few bytes the start of an instruction containing a rel32 // addressing mode? - const uint8* rel32 = NULL; + const uint8_t* rel32 = NULL; if (p + 5 <= end_pointer) { if (*p == 0xE8 || *p == 0xE9) { // jmp rel32 and call rel32 diff --git a/courgette/rel32_finder_win32_x86.h b/courgette/rel32_finder_win32_x86.h index 84dfe0b..24523d3 100644 --- a/courgette/rel32_finder_win32_x86.h +++ b/courgette/rel32_finder_win32_x86.h @@ -5,12 +5,13 @@ #ifndef COURGETTE_REL32_FINDER_WIN32_X86_H_ #define COURGETTE_REL32_FINDER_WIN32_X86_H_ +#include + #if COURGETTE_HISTOGRAM_TARGETS #include #endif #include -#include "base/basictypes.h" #include "courgette/image_utils.h" namespace courgette { @@ -38,8 +39,8 @@ class Rel32FinderWin32X86 { // - Do not collide with |base_relocation_table|'s RVA range, // - Whose targets are in [|start_rva|, |end_rva|). // The sorted results are written to |rel32_locations_|. - virtual void Find(const uint8* start_pointer, - const uint8* end_pointer, + virtual void Find(const uint8_t* start_pointer, + const uint8_t* end_pointer, RVA start_rva, RVA end_rva, const std::vector& abs32_locations) = 0; @@ -65,8 +66,8 @@ class Rel32FinderWin32X86_Basic : public Rel32FinderWin32X86 { virtual ~Rel32FinderWin32X86_Basic(); // Rel32FinderWin32X86 implementation. - void Find(const uint8* start_pointer, - const uint8* end_pointer, + void Find(const uint8_t* start_pointer, + const uint8_t* end_pointer, RVA start_rva, RVA end_rva, const std::vector& abs32_locations) override; diff --git a/courgette/rel32_finder_win32_x86_unittest.cc b/courgette/rel32_finder_win32_x86_unittest.cc index 08eb5c2..aed5c13 100644 --- a/courgette/rel32_finder_win32_x86_unittest.cc +++ b/courgette/rel32_finder_win32_x86_unittest.cc @@ -4,6 +4,9 @@ #include "courgette/rel32_finder_win32_x86.h" +#include +#include + #include #include #include @@ -47,7 +50,7 @@ class Rel32FinderWin32X86TestCase { RVA relocs_start_rva_; RVA relocs_end_rva_; RVA image_end_rva_; - std::vector text_data_; + std::vector text_data_; std::vector abs32_locations_; std::vector expected_rel32_locations_; @@ -71,9 +74,9 @@ class Rel32FinderWin32X86TestCase { return true; } - // Scans |iss| for the next non-empty line, and reads (hex) uint32 into |v|. + // Scans |iss| for the next non-empty line, and reads (hex) uint32_t into |v|. // Returns true iff successful. - bool ReadHexUInt32(std::istringstream& iss, uint32* v) { + bool ReadHexUInt32(std::istringstream& iss, uint32_t* v) { std::string line; if (!ReadNonEmptyLine(iss, &line)) return false; @@ -103,11 +106,11 @@ class Rel32FinderWin32X86TestCase { ASSERT_EQ("Program:", line); while (ReadNonEmptyLine(iss, &line) && line != "Abs32:") { std::string toks = line.substr(kBytesBegin, kBytesEnd); - uint32 vals[6]; + uint32_t vals[6]; int num_read = sscanf(toks.c_str(), "%X %X %X %X %X %X", &vals[0], &vals[1], &vals[2], &vals[3], &vals[4], &vals[5]); for (int i = 0; i < num_read; ++i) - text_data_.push_back(static_cast(vals[i] & 0xFF)); + text_data_.push_back(static_cast(vals[i] & 0xFF)); } ASSERT_FALSE(text_data_.empty()); diff --git a/courgette/simple_delta.cc b/courgette/simple_delta.cc index 37b910d..23f8430 100644 --- a/courgette/simple_delta.cc +++ b/courgette/simple_delta.cc @@ -7,7 +7,6 @@ #include "courgette/simple_delta.h" -#include "base/basictypes.h" #include "base/logging.h" #include "courgette/third_party/bsdiff.h" diff --git a/courgette/streams.cc b/courgette/streams.cc index fcac593..d6bebf9 100644 --- a/courgette/streams.cc +++ b/courgette/streams.cc @@ -19,8 +19,9 @@ #include "courgette/streams.h" #include +#include +#include -#include "base/basictypes.h" #include "base/logging.h" namespace courgette { @@ -35,19 +36,20 @@ static const unsigned int kStreamsSerializationFormatVersion = 20090218; // class Varint { public: - // Maximum lengths of varint encoding of uint32 + // Maximum lengths of varint encoding of uint32_t static const int kMax32 = 5; // Parses a Varint32 encoded value from |source| and stores it in |output|, // and returns a pointer to the following byte. Returns NULL if a valid // varint value was not found before |limit|. - static const uint8* Parse32WithLimit(const uint8* source, const uint8* limit, - uint32* output); + static const uint8_t* Parse32WithLimit(const uint8_t* source, + const uint8_t* limit, + uint32_t* output); // Writes the Varint32 encoded representation of |value| to buffer // |destination|. |destination| must have sufficient length to hold kMax32 // bytes. Returns a pointer to the byte just past the last encoded byte. - static uint8* Encode32(uint8* destination, uint32 value); + static uint8_t* Encode32(uint8_t* destination, uint32_t value); }; // Parses a Varint32 encoded unsigned number from |source|. The Varint32 @@ -59,10 +61,10 @@ class Varint { // // The digit loop is unrolled for performance. It usually exits after the first // one or two digits. -const uint8* Varint::Parse32WithLimit(const uint8* source, - const uint8* limit, - uint32* output) { - uint32 digit, result; +const uint8_t* Varint::Parse32WithLimit(const uint8_t* source, + const uint8_t* limit, + uint32_t* output) { + uint32_t digit, result; if (source >= limit) return NULL; digit = *(source++); @@ -113,12 +115,12 @@ const uint8* Varint::Parse32WithLimit(const uint8* source, // Write the base-128 digits in little-endian order. All except the last digit // have the high bit set to indicate more digits. -inline uint8* Varint::Encode32(uint8* destination, uint32 value) { +inline uint8_t* Varint::Encode32(uint8_t* destination, uint32_t value) { while (value >= 128) { - *(destination++) = static_cast(value) | 128; + *(destination++) = static_cast(value) | 128; value = value >> 7; } - *(destination++) = static_cast(value); + *(destination++) = static_cast(value); return destination; } @@ -134,24 +136,24 @@ bool SourceStream::Read(void* destination, size_t count) { return true; } -bool SourceStream::ReadVarint32(uint32* output_value) { - const uint8* after = Varint::Parse32WithLimit(current_, end_, output_value); +bool SourceStream::ReadVarint32(uint32_t* output_value) { + const uint8_t* after = Varint::Parse32WithLimit(current_, end_, output_value); if (!after) return false; current_ = after; return true; } -bool SourceStream::ReadVarint32Signed(int32* output_value) { +bool SourceStream::ReadVarint32Signed(int32_t* output_value) { // Signed numbers are encoded as unsigned numbers so that numbers nearer zero // have shorter varint encoding. // 0000xxxx encoded as 000xxxx0. // 1111xxxx encoded as 000yyyy1 where yyyy is complement of xxxx. - uint32 unsigned_value; + uint32_t unsigned_value; if (!ReadVarint32(&unsigned_value)) return false; if (unsigned_value & 1) - *output_value = ~static_cast(unsigned_value >> 1); + *output_value = ~static_cast(unsigned_value >> 1); else *output_value = (unsigned_value >> 1); return true; @@ -185,13 +187,13 @@ CheckBool SinkStream::Write(const void* data, size_t byte_count) { return buffer_.append(static_cast(data), byte_count); } -CheckBool SinkStream::WriteVarint32(uint32 value) { - uint8 buffer[Varint::kMax32]; - uint8* end = Varint::Encode32(buffer, value); +CheckBool SinkStream::WriteVarint32(uint32_t value) { + uint8_t buffer[Varint::kMax32]; + uint8_t* end = Varint::Encode32(buffer, value); return Write(buffer, end - buffer); } -CheckBool SinkStream::WriteVarint32Signed(int32 value) { +CheckBool SinkStream::WriteVarint32Signed(int32_t value) { // Encode signed numbers so that numbers nearer zero have shorter // varint encoding. // 0000xxxx encoded as 000xxxx0. @@ -205,7 +207,7 @@ CheckBool SinkStream::WriteVarint32Signed(int32 value) { } CheckBool SinkStream::WriteSizeVarint32(size_t value) { - uint32 narrowed_value = static_cast(value); + uint32_t narrowed_value = static_cast(value); // On 32-bit, the compiler should figure out this test always fails. LOG_ASSERT(value == narrowed_value); return WriteVarint32(narrowed_value); @@ -239,11 +241,11 @@ SourceStreamSet::~SourceStreamSet() { // ... // bool SourceStreamSet::Init(const void* source, size_t byte_count) { - const uint8* start = static_cast(source); - const uint8* end = start + byte_count; + const uint8_t* start = static_cast(source); + const uint8_t* end = start + byte_count; unsigned int version; - const uint8* finger = Varint::Parse32WithLimit(start, end, &version); + const uint8_t* finger = Varint::Parse32WithLimit(start, end, &version); if (finger == NULL) return false; if (version != kStreamsSerializationFormatVersion) @@ -287,12 +289,12 @@ bool SourceStreamSet::Init(SourceStream* source) { } bool SourceStreamSet::ReadSet(SourceStreamSet* set) { - uint32 stream_count = 0; + uint32_t stream_count = 0; SourceStream* control_stream = this->stream(0); if (!control_stream->ReadVarint32(&stream_count)) return false; - uint32 lengths[kMaxStreams] = {}; // i.e. all zero. + uint32_t lengths[kMaxStreams] = {}; // i.e. all zero. for (size_t i = 0; i < stream_count; ++i) { if (!control_stream->ReadVarint32(&lengths[i])) @@ -364,13 +366,13 @@ CheckBool SinkStreamSet::CopyTo(SinkStream *combined_stream) { } CheckBool SinkStreamSet::WriteSet(SinkStreamSet* set) { - uint32 lengths[kMaxStreams]; + uint32_t lengths[kMaxStreams]; // 'stream_count' includes all non-empty streams and all empty stream numbered // lower than a non-empty stream. size_t stream_count = 0; for (size_t i = 0; i < kMaxStreams; ++i) { SinkStream* stream = set->stream(i); - lengths[i] = static_cast(stream->Length()); + lengths[i] = static_cast(stream->Length()); if (lengths[i] > 0) stream_count = i + 1; } diff --git a/courgette/streams.h b/courgette/streams.h index ff65d13..c23d710 100644 --- a/courgette/streams.h +++ b/courgette/streams.h @@ -10,15 +10,17 @@ // writing. Streams are aggregated into Sets which allows several streams to be // used at once. Example: we can write A1, B1, A2, B2 but achieve the memory // layout A1 A2 B1 B2 by writing 'A's to one stream and 'B's to another. + #ifndef COURGETTE_STREAMS_H_ #define COURGETTE_STREAMS_H_ +#include +#include #include // for FILE* #include -#include "base/basictypes.h" #include "base/compiler_specific.h" - +#include "base/macros.h" #include "courgette/memory_allocator.h" #include "courgette/region.h" @@ -41,7 +43,7 @@ class SourceStream { // still owns the memory at |pointer| and should free the memory only after // the last use of the stream. void Init(const void* pointer, size_t length) { - start_ = static_cast(pointer); + start_ = static_cast(pointer); end_ = start_ + length; current_ = start_; } @@ -67,7 +69,7 @@ class SourceStream { // Returns initial length of stream before any data consumed by reading. size_t OriginalLength() const { return end_ - start_; } - const uint8* Buffer() const { return current_; } + const uint8_t* Buffer() const { return current_; } bool Empty() const { return current_ == end_; } // Copies bytes from stream to memory at |destination|. Returns 'false' if @@ -76,11 +78,11 @@ class SourceStream { // Reads a varint formatted unsigned integer from stream. Returns 'false' if // the read failed due to insufficient data or malformed Varint32. - bool ReadVarint32(uint32* output_value); + bool ReadVarint32(uint32_t* output_value); // Reads a varint formatted signed integer from stream. Returns 'false' if // the read failed due to insufficient data or malformed Varint32. - bool ReadVarint32Signed(int32* output_value); + bool ReadVarint32Signed(int32_t* output_value); // Initializes |substream| to yield |length| bytes from |this| stream, // starting at |offset| bytes from the current position. Returns 'false' if @@ -103,9 +105,9 @@ class SourceStream { bool Skip(size_t byte_count); private: - const uint8* start_; // Points to start of buffer. - const uint8* end_; // Points to first location after buffer. - const uint8* current_; // Points into buffer at current read location. + const uint8_t* start_; // Points to start of buffer. + const uint8_t* end_; // Points to first location after buffer. + const uint8_t* current_; // Points into buffer at current read location. DISALLOW_COPY_AND_ASSIGN(SourceStream); }; @@ -124,13 +126,13 @@ class SinkStream { CheckBool Write(const void* data, size_t byte_count) WARN_UNUSED_RESULT; // Appends the 'varint32' encoding of |value| to the stream. - CheckBool WriteVarint32(uint32 value) WARN_UNUSED_RESULT; + CheckBool WriteVarint32(uint32_t value) WARN_UNUSED_RESULT; // Appends the 'varint32' encoding of |value| to the stream. - CheckBool WriteVarint32Signed(int32 value) WARN_UNUSED_RESULT; + CheckBool WriteVarint32Signed(int32_t value) WARN_UNUSED_RESULT; // Appends the 'varint32' encoding of |value| to the stream. - // On platforms where sizeof(size_t) != sizeof(int32), do a safety check. + // On platforms where sizeof(size_t) != sizeof(int32_t), do a safety check. CheckBool WriteSizeVarint32(size_t value) WARN_UNUSED_RESULT; // Contents of |other| are appended to |this| stream. The |other| stream @@ -143,8 +145,8 @@ class SinkStream { // Returns a pointer to contiguously allocated Length() bytes in the stream. // Writing to the stream invalidates the pointer. The SinkStream continues to // own the memory. - const uint8* Buffer() const { - return reinterpret_cast(buffer_.data()); + const uint8_t* Buffer() const { + return reinterpret_cast(buffer_.data()); } // Hints that the stream will grow by an additional |length| bytes. diff --git a/courgette/streams_unittest.cc b/courgette/streams_unittest.cc index d0903c9..67fd6b0 100644 --- a/courgette/streams_unittest.cc +++ b/courgette/streams_unittest.cc @@ -4,6 +4,9 @@ #include "courgette/streams.h" +#include +#include + #include #include "testing/gtest/include/gtest/gtest.h" @@ -14,7 +17,7 @@ TEST(StreamsTest, SimpleWriteRead) { EXPECT_TRUE(sink.WriteVarint32(kValue1)); - const uint8* sink_buffer = sink.Buffer(); + const uint8_t* sink_buffer = sink.Buffer(); size_t length = sink.Length(); courgette::SourceStream source; @@ -32,7 +35,7 @@ TEST(StreamsTest, SimpleWriteRead2) { EXPECT_TRUE(sink.Write("Hello", 5)); - const uint8* sink_buffer = sink.Buffer(); + const uint8_t* sink_buffer = sink.Buffer(); size_t sink_length = sink.Length(); courgette::SourceStream source; @@ -57,14 +60,14 @@ TEST(StreamsTest, StreamSetWriteRead) { EXPECT_TRUE(out.CopyTo(&collected)); - const uint8* collected_buffer = collected.Buffer(); + const uint8_t* collected_buffer = collected.Buffer(); size_t collected_length = collected.Length(); courgette::SourceStreamSet in; bool can_init = in.Init(collected_buffer, collected_length); EXPECT_TRUE(can_init); - uint32 value; + uint32_t value; bool can_read = in.stream(3)->ReadVarint32(&value); EXPECT_TRUE(can_read); EXPECT_EQ(kValue1, value); @@ -104,7 +107,7 @@ TEST(StreamsTest, StreamSetWriteRead2) { for (size_t i = 0; data[i] != kEnd; i += 2) { size_t id = data[i]; size_t datum = data[i + 1]; - uint32 value = 77; + uint32_t value = 77; bool can_read = in.stream(id)->ReadVarint32(&value); EXPECT_TRUE(can_read); EXPECT_EQ(datum, value); @@ -118,16 +121,13 @@ TEST(StreamsTest, StreamSetWriteRead2) { TEST(StreamsTest, SignedVarint32) { courgette::SinkStream out; - static const int32 data[] = { - 0, 64, 128, 8192, 16384, - 1 << 20, 1 << 21, 1 << 22, - 1 << 27, 1 << 28, - 0x7fffffff, -0x7fffffff - }; + static const int32_t data[] = {0, 64, 128, 8192, + 16384, 1 << 20, 1 << 21, 1 << 22, + 1 << 27, 1 << 28, 0x7fffffff, -0x7fffffff}; - std::vector values; + std::vector values; for (size_t i = 0; i < sizeof(data)/sizeof(data[0]); ++i) { - int32 basis = data[i]; + int32_t basis = data[i]; for (int delta = -4; delta <= 4; ++delta) { EXPECT_TRUE(out.WriteVarint32Signed(basis + delta)); values.push_back(basis + delta); @@ -141,7 +141,7 @@ TEST(StreamsTest, SignedVarint32) { for (size_t i = 0; i < values.size(); ++i) { int written_value = values[i]; - int32 datum; + int32_t datum; bool can_read = in.ReadVarint32Signed(&datum); EXPECT_TRUE(can_read); EXPECT_EQ(written_value, datum); @@ -188,7 +188,7 @@ TEST(StreamsTest, StreamSetReadWrite) { EXPECT_FALSE(subset1.Empty()); EXPECT_FALSE(subset1.Empty()); - uint32 datum; + uint32_t datum; EXPECT_TRUE(subset1.stream(3)->ReadVarint32(&datum)); EXPECT_EQ(30000U, datum); EXPECT_TRUE(subset1.stream(5)->ReadVarint32(&datum)); diff --git a/courgette/third_party/bsdiff.h b/courgette/third_party/bsdiff.h index 7c4888c..1a7e025 100644 --- a/courgette/third_party/bsdiff.h +++ b/courgette/third_party/bsdiff.h @@ -37,7 +37,8 @@ #ifndef COURGETTE_BSDIFF_H_ #define COURGETTE_BSDIFF_H_ -#include "base/basictypes.h" +#include + #include "base/files/file_util.h" namespace courgette { @@ -79,9 +80,9 @@ BSDiffStatus ApplyBinaryPatch(const base::FilePath& old_stream, // The patch stream starts with a MBSPatchHeader. typedef struct MBSPatchHeader_ { char tag[8]; // Contains MBS_PATCH_HEADER_TAG - uint32 slen; // Length of the file to be patched. - uint32 scrc32; // CRC32 of the file to be patched. - uint32 dlen; // Length of the result file. + uint32_t slen; // Length of the file to be patched. + uint32_t scrc32; // CRC32 of the file to be patched. + uint32_t dlen; // Length of the result file. } MBSPatchHeader; // This is the value for the tag field. Must match length exactly, not counting diff --git a/courgette/third_party/bsdiff_apply.cc b/courgette/third_party/bsdiff_apply.cc index 48ee1be..537f194 100644 --- a/courgette/third_party/bsdiff_apply.cc +++ b/courgette/third_party/bsdiff_apply.cc @@ -36,6 +36,9 @@ #include "courgette/third_party/bsdiff.h" +#include +#include + #include "base/files/memory_mapped_file.h" #include "courgette/crc.h" #include "courgette/streams.h" @@ -57,11 +60,12 @@ BSDiffStatus MBS_ReadHeader(SourceStream* stream, MBSPatchHeader* header) { return OK; } -BSDiffStatus MBS_ApplyPatch(const MBSPatchHeader *header, +BSDiffStatus MBS_ApplyPatch(const MBSPatchHeader* header, SourceStream* patch_stream, - const uint8* old_start, size_t old_size, + const uint8_t* old_start, + size_t old_size, SinkStream* new_stream) { - const uint8* old_end = old_start + old_size; + const uint8_t* old_end = old_start + old_size; SourceStreamSet patch_streams; if (!patch_streams.Init(patch_stream)) @@ -74,22 +78,22 @@ BSDiffStatus MBS_ApplyPatch(const MBSPatchHeader *header, SourceStream* diff_bytes = patch_streams.stream(4); SourceStream* extra_bytes = patch_streams.stream(5); - const uint8* extra_start = extra_bytes->Buffer(); - const uint8* extra_end = extra_start + extra_bytes->Remaining(); - const uint8* extra_position = extra_start; + const uint8_t* extra_start = extra_bytes->Buffer(); + const uint8_t* extra_end = extra_start + extra_bytes->Remaining(); + const uint8_t* extra_position = extra_start; - const uint8* old_position = old_start; + const uint8_t* old_position = old_start; if (header->dlen && !new_stream->Reserve(header->dlen)) return MEM_ERROR; - uint32 pending_diff_zeros = 0; + uint32_t pending_diff_zeros = 0; if (!diff_skips->ReadVarint32(&pending_diff_zeros)) return UNEXPECTED_ERROR; while (!control_stream_copy_counts->Empty()) { - uint32 copy_count, extra_count; - int32 seek_adjustment; + uint32_t copy_count, extra_count; + int32_t seek_adjustment; if (!control_stream_copy_counts->ReadVarint32(©_count)) return UNEXPECTED_ERROR; if (!control_stream_extra_counts->ReadVarint32(&extra_count)) @@ -108,7 +112,7 @@ BSDiffStatus MBS_ApplyPatch(const MBSPatchHeader *header, // Add together bytes from the 'old' file and the 'diff' stream. for (size_t i = 0; i < copy_count; ++i) { - uint8 diff_byte = 0; + uint8_t diff_byte = 0; if (pending_diff_zeros) { --pending_diff_zeros; } else { @@ -117,7 +121,7 @@ BSDiffStatus MBS_ApplyPatch(const MBSPatchHeader *header, if (!diff_bytes->Read(&diff_byte, 1)) return UNEXPECTED_ERROR; } - uint8 byte = old_position[i] + diff_byte; + uint8_t byte = old_position[i] + diff_byte; if (!new_stream->Write(&byte, 1)) return MEM_ERROR; } @@ -158,7 +162,7 @@ BSDiffStatus ApplyBinaryPatch(SourceStream* old_stream, BSDiffStatus ret = MBS_ReadHeader(patch_stream, &header); if (ret != OK) return ret; - const uint8* old_start = old_stream->Buffer(); + const uint8_t* old_start = old_stream->Buffer(); size_t old_size = old_stream->Remaining(); if (old_size != header.slen) return UNEXPECTED_ERROR; diff --git a/courgette/third_party/bsdiff_create.cc b/courgette/third_party/bsdiff_create.cc index b883f73..61b36cf 100644 --- a/courgette/third_party/bsdiff_create.cc +++ b/courgette/third_party/bsdiff_create.cc @@ -28,6 +28,8 @@ #include "courgette/third_party/bsdiff.h" +#include +#include #include #include @@ -67,10 +69,10 @@ BSDiffStatus CreateBinaryPatch(SourceStream* old_stream, SinkStream* diff_bytes = patch_streams.stream(4); SinkStream* extra_bytes = patch_streams.stream(5); - const uint8* old = old_stream->Buffer(); + const uint8_t* old = old_stream->Buffer(); const int oldsize = static_cast(old_stream->Remaining()); - uint32 pending_diff_zeros = 0; + uint32_t pending_diff_zeros = 0; PagedArray I; PagedArray V; @@ -93,7 +95,7 @@ BSDiffStatus CreateBinaryPatch(SourceStream* old_stream, << (base::Time::Now() - q_start_time).InSecondsF(); V.clear(); - const uint8* newbuf = new_stream->Buffer(); + const uint8_t* newbuf = new_stream->Buffer(); const int newsize = static_cast(new_stream->Remaining()); int control_length = 0; @@ -224,7 +226,7 @@ BSDiffStatus CreateBinaryPatch(SourceStream* old_stream, }; for (int i = 0; i < lenf; i++) { - uint8 diff_byte = newbuf[lastscan + i] - old[lastpos + i]; + uint8_t diff_byte = newbuf[lastscan + i] - old[lastpos + i]; if (diff_byte) { ++diff_bytes_nonzero; if (!diff_skips->WriteVarint32(pending_diff_zeros)) @@ -245,9 +247,9 @@ BSDiffStatus CreateBinaryPatch(SourceStream* old_stream, diff_bytes_length += lenf; extra_bytes_length += gap; - uint32 copy_count = lenf; - uint32 extra_count = gap; - int32 seek_adjustment = ((pos - lenb) - (lastpos + lenf)); + uint32_t copy_count = lenf; + uint32_t extra_count = gap; + int32_t seek_adjustment = ((pos - lenb) - (lastpos + lenf)); if (!control_stream_copy_counts->WriteVarint32(copy_count) || !control_stream_extra_counts->WriteVarint32(extra_count) || diff --git a/courgette/third_party/paged_array.h b/courgette/third_party/paged_array.h index 76cb879..48a92f1 100644 --- a/courgette/third_party/paged_array.h +++ b/courgette/third_party/paged_array.h @@ -11,7 +11,9 @@ #ifndef COURGETTE_BSDIFF_PAGED_ARRAY_H_ #define COURGETTE_BSDIFF_PAGED_ARRAY_H_ -#include "base/basictypes.h" +#include + +#include "base/macros.h" #include "base/process/memory.h" namespace courgette { diff --git a/courgette/third_party/qsufsort_unittest.cc b/courgette/third_party/qsufsort_unittest.cc index 675eac4..e0ece01 100644 --- a/courgette/third_party/qsufsort_unittest.cc +++ b/courgette/third_party/qsufsort_unittest.cc @@ -4,6 +4,8 @@ #include "courgette/third_party/qsufsort.h" +#include + #include #include #include diff --git a/courgette/typedrva_unittest.cc b/courgette/typedrva_unittest.cc index dc30fa9..d0ad833 100644 --- a/courgette/typedrva_unittest.cc +++ b/courgette/typedrva_unittest.cc @@ -2,6 +2,8 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +#include + #include "courgette/base_test_unittest.h" #include "courgette/disassembler_elf_32_arm.h" #include "courgette/disassembler_elf_32_x86.h" @@ -14,12 +16,12 @@ class TypedRVATest : public BaseTest { void TestRelativeTargetARM(courgette::ARM_RVA arm_rva, courgette::RVA rva, - uint32 op, + uint32_t op, courgette::RVA expected) const; void TestARMOPEncode(courgette::ARM_RVA arm_rva, courgette::RVA rva, - uint32 op, + uint32_t op, courgette::RVA expected) const; }; @@ -27,7 +29,7 @@ void TypedRVATest::TestRelativeTargetX86(courgette::RVA word, courgette::RVA expected) const { courgette::DisassemblerElf32X86::TypedRVAX86* typed_rva = new courgette::DisassemblerElf32X86::TypedRVAX86(0); - const uint8* op_pointer = reinterpret_cast(&word); + const uint8_t* op_pointer = reinterpret_cast(&word); EXPECT_TRUE(typed_rva->ComputeRelativeTarget(op_pointer)); EXPECT_EQ(typed_rva->relative_target(), expected); @@ -35,17 +37,17 @@ void TypedRVATest::TestRelativeTargetX86(courgette::RVA word, delete typed_rva; } -uint32 Read32LittleEndian(const void* address) { - return *reinterpret_cast(address); +uint32_t Read32LittleEndian(const void* address) { + return *reinterpret_cast(address); } void TypedRVATest::TestRelativeTargetARM(courgette::ARM_RVA arm_rva, courgette::RVA rva, - uint32 op, + uint32_t op, courgette::RVA expected) const { courgette::DisassemblerElf32ARM::TypedRVAARM* typed_rva = new courgette::DisassemblerElf32ARM::TypedRVAARM(arm_rva, rva); - uint8* op_pointer = reinterpret_cast(&op); + uint8_t* op_pointer = reinterpret_cast(&op); EXPECT_TRUE(typed_rva->ComputeRelativeTarget(op_pointer)); EXPECT_EQ(rva + typed_rva->relative_target(), expected); @@ -54,16 +56,16 @@ void TypedRVATest::TestRelativeTargetARM(courgette::ARM_RVA arm_rva, } void TypedRVATest::TestARMOPEncode(courgette::ARM_RVA arm_rva, - courgette::RVA rva, - uint32 op, - courgette::RVA expected) const { - uint16 c_op; - uint32 addr; + courgette::RVA rva, + uint32_t op, + courgette::RVA expected) const { + uint16_t c_op; + uint32_t addr; EXPECT_TRUE(courgette::DisassemblerElf32ARM::Compress(arm_rva, op, rva, &c_op, &addr)); EXPECT_EQ(rva + addr, expected); - uint32 new_op; + uint32_t new_op; EXPECT_TRUE(courgette::DisassemblerElf32ARM::Decompress(arm_rva, c_op, addr, &new_op)); EXPECT_EQ(new_op, op); diff --git a/courgette/types_elf.h b/courgette/types_elf.h index eb054ee..a98fd8b 100644 --- a/courgette/types_elf.h +++ b/courgette/types_elf.h @@ -5,17 +5,18 @@ #ifndef COURGETTE_ELF_TYPES_H_ #define COURGETTE_ELF_TYPES_H_ +#include + // // This header defines various types from the ELF file spec, but no code // related to using them. // -typedef uint32 Elf32_Addr; // Unsigned program address -typedef uint16 Elf32_Half; // Unsigned medium integer -typedef uint32 Elf32_Off; // Unsigned file offset -typedef int32 Elf32_Sword; // Signed large integer -typedef uint32 Elf32_Word; // Unsigned large integer - +typedef uint32_t Elf32_Addr; // Unsigned program address +typedef uint16_t Elf32_Half; // Unsigned medium integer +typedef uint32_t Elf32_Off; // Unsigned file offset +typedef int32_t Elf32_Sword; // Signed large integer +typedef uint32_t Elf32_Word; // Unsigned large integer // The header at the top of the file struct Elf32_Ehdr { diff --git a/courgette/types_win_pe.h b/courgette/types_win_pe.h index eed88af..f926b5f 100644 --- a/courgette/types_win_pe.h +++ b/courgette/types_win_pe.h @@ -5,8 +5,8 @@ #ifndef TYPES_WIN_PE_H_ #define TYPES_WIN_PE_H_ -#include "base/basictypes.h" - +#include +#include namespace courgette { @@ -17,15 +17,15 @@ namespace courgette { #pragma pack(push, 1) // Supported by MSVC and GCC. Ensures no gaps in packing. struct Section { char name[8]; - uint32 virtual_size; - uint32 virtual_address; - uint32 size_of_raw_data; - uint32 file_offset_of_raw_data; - uint32 pointer_to_relocations; // Always zero in an image. - uint32 pointer_to_line_numbers; // Always zero in an image. - uint16 number_of_relocations; // Always zero in an image. - uint16 number_of_line_numbers; // Always zero in an image. - uint32 characteristics; + uint32_t virtual_size; + uint32_t virtual_address; + uint32_t size_of_raw_data; + uint32_t file_offset_of_raw_data; + uint32_t pointer_to_relocations; // Always zero in an image. + uint32_t pointer_to_line_numbers; // Always zero in an image. + uint16_t number_of_relocations; // Always zero in an image. + uint16_t number_of_line_numbers; // Always zero in an image. + uint32_t characteristics; }; #pragma pack(pop) @@ -39,7 +39,7 @@ class ImageDataDirectory { public: ImageDataDirectory() : address_(0), size_(0) {} RVA address_; - uint32 size_; + uint32_t size_; }; static_assert(sizeof(ImageDataDirectory) == 8, @@ -54,8 +54,8 @@ static_assert(sizeof(ImageDataDirectory) == 8, // This is FIELD_OFFSET(IMAGE_DOS_HEADER, e_lfanew): const size_t kOffsetOfFileAddressOfNewExeHeader = 0x3c; -const uint16 kImageNtOptionalHdr32Magic = 0x10b; -const uint16 kImageNtOptionalHdr64Magic = 0x20b; +const uint16_t kImageNtOptionalHdr32Magic = 0x10b; +const uint16_t kImageNtOptionalHdr64Magic = 0x20b; const size_t kSizeOfCoffHeader = 20; const size_t kOffsetOfDataDirectoryFromImageOptionalHeader32 = 96; diff --git a/courgette/versioning_unittest.cc b/courgette/versioning_unittest.cc index 91154d8..655aa93 100644 --- a/courgette/versioning_unittest.cc +++ b/courgette/versioning_unittest.cc @@ -4,9 +4,10 @@ #include "courgette/base_test_unittest.h" +#include + #include -#include "base/basictypes.h" #include "courgette/courgette.h" #include "courgette/streams.h" #include "courgette/third_party/bsdiff.h" -- cgit v1.1