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}
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 <stddef.h>
+#include <stdint.h>
+
#include <algorithm>
#include <list>
#include <map>
@@ -11,8 +14,8 @@
#include <string>
#include <vector>
-#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 @@
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 @@
LabelInfo* next_addr_; // Label(Info) at next highest address.
LabelInfo* prev_addr_; // Label(Info) at next lowest address.
- std::vector<uint32> positions_; // Offsets into the trace of references.
+ std::vector<uint32_t> 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 @@
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 @@
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 @@
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 @@
}
}
- 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 @@
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 @@
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 @@
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 @@
}
void ReferenceLabel(Trace* trace, Label* label, bool is_model) {
- trace->push_back(MakeLabelInfo(label, is_model,
- static_cast<uint32>(trace->size())));
+ trace->push_back(
+ MakeLabelInfo(label, is_model, static_cast<uint32_t>(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..d783cdac 100644
--- a/courgette/adjustment_method_2.cc
+++ b/courgette/adjustment_method_2.cc
@@ -4,6 +4,9 @@
#include "courgette/adjustment_method.h"
+#include <stddef.h>
+#include <stdint.h>
+
#include <algorithm>
#include <limits>
#include <list>
@@ -12,9 +15,9 @@
#include <string>
#include <vector>
-#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 @@
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<uint32> positions_; // Offsets into the trace of references.
+ std::vector<uint32_t> positions_; // Offsets into the trace of references.
private:
AssignmentCandidates* candidates_;
@@ -213,7 +216,7 @@
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 @@
// 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 @@
LabelInfo* at(size_t i) const { return trace_[exemplar_position_ + i]; }
void add_position(size_t position) {
- positions_.push_back(static_cast<uint32>(position));
+ positions_.push_back(static_cast<uint32_t>(position));
}
int position_count() const { return static_cast<int>(positions_.size()); }
@@ -414,7 +417,7 @@
const Trace& trace_; // The shingle lives inside trace_.
size_t exemplar_position_; // At this position (and other positions).
- std::vector<uint32> positions_; // Includes exemplar_position_.
+ std::vector<uint32_t> positions_; // Includes exemplar_position_.
ShinglePattern* pattern_; // Pattern changes as LabelInfos are assigned.
@@ -430,7 +433,7 @@
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 @@
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 @@
// --> <kFixed+0, kVariable+1, kFixed+2, kVariable+1, kFixed+0>
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 @@
} 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 @@
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 @@
}
};
-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 @@
// 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 @@
// 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 @@
}
void ReferenceLabel(Trace* trace, Label* label, bool is_model) {
- trace->push_back(
- label_info_maker_.MakeLabelInfo(label, is_model,
- static_cast<uint32>(trace->size())));
+ trace->push_back(label_info_maker_.MakeLabelInfo(
+ label, is_model, static_cast<uint32_t>(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 <memory.h>
+#include <stddef.h>
+#include <stdint.h>
#include <algorithm>
#include <map>
#include <set>
@@ -52,22 +54,20 @@
// 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 @@
// 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 @@
return Emit(ScopedInstruction(UncheckedNew<OriginInstruction>(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<BytesInstruction>(values, len)));
}
@@ -157,8 +163,10 @@
ScopedInstruction(UncheckedNew<InstructionWithLabel>(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<InstructionWithLabelARM>(
REL32ARM, op, label, arm_op, op_size)));
}
@@ -324,7 +332,7 @@
if (prev)
prev_index = prev->index_;
else
- prev_index = static_cast<uint32>(available.size());
+ prev_index = static_cast<uint32_t>(available.size());
if (prev_index != 0 &&
prev_index != Label::kNoIndex &&
available.at(prev_index - 1)) {
@@ -400,14 +408,14 @@
break;
}
case DEFBYTE: {
- uint8 b = static_cast<ByteInstruction*>(instruction)->byte_value();
+ uint8_t b = static_cast<ByteInstruction*>(instruction)->byte_value();
if (!encoded->AddCopy(1, &b))
return NULL;
break;
}
case DEFBYTES: {
- const uint8* byte_values =
- static_cast<BytesInstruction*>(instruction)->byte_values();
+ const uint8_t* byte_values =
+ static_cast<BytesInstruction*>(instruction)->byte_values();
size_t len = static_cast<BytesInstruction*>(instruction)->len();
if (!encoded->AddCopy(len, byte_values))
@@ -423,9 +431,8 @@
case REL32ARM: {
Label* label =
static_cast<InstructionWithLabelARM*>(instruction)->label();
- uint16 compressed_op =
- static_cast<InstructionWithLabelARM*>(instruction)->
- compressed_op();
+ uint16_t compressed_op =
+ static_cast<InstructionWithLabelARM*>(instruction)->compressed_op();
if (!encoded->AddRel32ARM(compressed_op, label->index_))
return NULL;
break;
@@ -466,7 +473,7 @@
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 @@
for (int i = 0; i < 256; ++i) {
byte_instruction_cache_[i] =
- UncheckedNew<ByteInstruction>(static_cast<uint8>(i));
+ UncheckedNew<ByteInstruction>(static_cast<uint8_t>(i));
if (!byte_instruction_cache_[i]) {
for (int j = 0; j < i; ++j)
UncheckedDelete(byte_instruction_cache_[j]);
@@ -526,9 +533,9 @@
Label* label =
static_cast<InstructionWithLabelARM*>(instruction)->label();
if (label->count_ <= lower_limit) {
- const uint8* arm_op =
+ const uint8_t* arm_op =
static_cast<InstructionWithLabelARM*>(instruction)->arm_op();
- uint16 op_size =
+ uint16_t op_size =
static_cast<InstructionWithLabelARM*>(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 <stddef.h>
+#include <stdint.h>
+
#include <map>
#include <set>
#include <vector>
-#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 @@
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 @@
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 @@
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 @@
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<Instruction* [], base::FreeDeleter> 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 <stddef.h>
+
#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 <stddef.h>
+
#include <iterator>
#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 <stddef.h>
+
#include <string>
#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 <stddef.h>
+#include <stdint.h>
+
#include <string>
#include <vector>
#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 @@
}
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 <stdint.h>
+#include <stddef.h>
+
#ifdef COURGETTE_USE_CRC_LIB
# include "zlib.h"
#else
@@ -12,12 +15,11 @@
}
#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..b0c33239 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 <stddef.h>
+#include <stdint.h>
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 <stddef.h>
+#include <stdint.h>
+
#include "base/containers/hash_tables.h"
+#include "base/macros.h"
namespace courgette {
@@ -21,9 +25,9 @@
static_assert(kTupleSize >= 4 && kTupleSize <= 8,
"kTupleSize should be between 4 and 8");
-size_t HashTuple(const uint8* source) {
- size_t hash1 = *reinterpret_cast<const uint32*>(source);
- size_t hash2 = *reinterpret_cast<const uint32*>(source + kTupleSize - 4);
+size_t HashTuple(const uint8_t* source) {
+ size_t hash1 = *reinterpret_cast<const uint32_t*>(source);
+ size_t hash2 = *reinterpret_cast<const uint32_t*>(source + kTupleSize - 4);
size_t hash = ((hash1 * 17 + hash2 * 37) + (hash1 >> 17)) ^ (hash2 >> 23);
return hash;
}
@@ -43,9 +47,9 @@
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 @@
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..690c8404 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 <stddef.h>
+
#include <vector>
+#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 <stddef.h>
+#include <stdint.h>
+
#include <algorithm>
#include <string>
#include <vector>
-#include "base/basictypes.h"
#include "base/logging.h"
#include "courgette/assembly_program.h"
@@ -101,15 +103,14 @@
Disassembler::Disassembler(const void* start, size_t length)
: failure_reason_("uninitialized") {
-
- start_ = reinterpret_cast<const uint8*>(start);
+ start_ = reinterpret_cast<const uint8_t*>(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 <stddef.h>
+#include <stdint.h>
+#include "base/macros.h"
#include "courgette/courgette.h"
#include "courgette/image_utils.h"
@@ -34,12 +36,12 @@
// 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 @@
// 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 <stddef.h>
+#include <stdint.h>
+
#include <algorithm>
#include <string>
#include <vector>
-#include "base/basictypes.h"
#include "base/logging.h"
#include "base/memory/scoped_vector.h"
@@ -182,7 +184,7 @@
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::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<size_t> abs_offsets;
@@ -370,8 +372,7 @@
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 @@
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 608c73a0..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 <stddef.h>
+#include <stdint.h>
+
+#include "base/macros.h"
#include "base/memory/scoped_vector.h"
#include "courgette/assembly_program.h"
#include "courgette/disassembler.h"
@@ -56,13 +59,13 @@
}
// 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 @@
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..f6490d94 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 <stddef.h>
+#include <stdint.h>
+
#include <algorithm>
#include <string>
#include <vector>
-#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 @@
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<uint16>(arm_op >> 8) | 0x1000;
+ (*c_op) = static_cast<uint16_t>(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<uint16>(arm_op >> 11) | 0x2000;
+ (*c_op) = static_cast<uint16_t>(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 @@
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 @@
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<uint16>(temp2);
+ (*c_op) = static_cast<uint16_t>(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 @@
temp += 4;
(*addr) = temp;
- uint32 temp2 = 0x5000;
+ uint32_t temp2 = 0x5000;
temp2 |= (arm_op & 0x03C00000) >> 22; // just save the cond
- (*c_op) = static_cast<uint16>(temp2);
+ (*c_op) = static_cast<uint16_t>(temp2);
break;
}
default:
@@ -131,8 +136,10 @@
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 @@
(*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 @@
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 @@
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 @@
}
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 @@
// 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 @@
(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 @@
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 @@
if (!abs32_locations_.empty()) {
std::vector<RVA>::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::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 @@
// 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<RVA>(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 @@
RVA rva = static_cast<RVA>(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 @@
// 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 @@
RVA rva = static_cast<RVA>(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 @@
RVA rva = static_cast<RVA>(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 @@
// 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<RVA>(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..17ebb2557 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 <stddef.h>
+#include <stdint.h>
+
+#include "base/macros.h"
#include "courgette/disassembler_elf_32.h"
#include "courgette/memory_allocator.h"
#include "courgette/types_elf.h"
@@ -28,22 +31,20 @@
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 @@
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 da389a42..98084c15 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 <stddef.h>
+#include <stdint.h>
+
#include <algorithm>
#include <string>
#include <vector>
-#include "base/basictypes.h"
#include "base/logging.h"
#include "courgette/assembly_program.h"
@@ -29,7 +31,7 @@
(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 @@
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::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<RVA>(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 <stddef.h>
+#include <stdint.h>
+
+#include "base/macros.h"
#include "courgette/disassembler_elf_32.h"
#include "courgette/memory_allocator.h"
#include "courgette/types_elf.h"
@@ -21,7 +24,7 @@
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 @@
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 <stddef.h>
+#include <stdint.h>
+
#include "courgette/assembly_program.h"
#include "courgette/base_test_unittest.h"
#include "courgette/disassembler_elf_32_x86.h"
@@ -30,7 +33,7 @@
// 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<const void*>(file1.c_str()),
reinterpret_cast<const void*>(offset_p));
EXPECT_EQ(0x7F, offset_p[0]);
diff --git a/courgette/disassembler_win32_x64.cc b/courgette/disassembler_win32_x64.cc
index 58e787b6..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 <stddef.h>
+#include <stdint.h>
+
#include <algorithm>
#include <string>
#include <vector>
-#include "base/basictypes.h"
#include "base/logging.h"
#include "base/numerics/safe_conversions.h"
@@ -55,13 +57,12 @@
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 @@
// 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 @@
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 @@
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 @@
// "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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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<RVA>::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<RVA>(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 @@
// 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 @@
}
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 @@
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<RVA>::iterator rel32_pos = rel32_locations_.begin();
std::vector<RVA>::iterator abs32_pos = abs32_locations_.begin();
@@ -566,7 +567,7 @@
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<RVA>(p - adjust_pointer_to_rva);
@@ -577,7 +578,7 @@
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 @@
++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<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.
@@ -690,7 +691,8 @@
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 @@
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 @@
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 @@
// TODO(sra): validate RVA.
directory->address_ = rva;
- directory->size_ = static_cast<uint32>(size);
+ directory->size_ = static_cast<uint32_t>(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 <stddef.h>
+#include <stdint.h>
+
+#include "base/macros.h"
#include "courgette/disassembler.h"
#include "courgette/memory_allocator.h"
#include "courgette/types_win_pe.h"
@@ -36,7 +39,7 @@
//
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 @@
// 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 @@
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<RVA, int>& map);
@@ -76,7 +82,7 @@
// 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 @@
// 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 @@
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 f67e8009..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 <stdint.h>
+
#include "base/memory/scoped_ptr.h"
#include "base/stl_util.h"
#include "courgette/base_test_unittest.h"
@@ -44,13 +46,13 @@
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<const void*>(file1.c_str()),
reinterpret_cast<const void*>(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<const void*>(file1.c_str()),
reinterpret_cast<const void*>(rva_p));
EXPECT_EQ('M', rva_p[0]);
diff --git a/courgette/disassembler_win32_x86.cc b/courgette/disassembler_win32_x86.cc
index 85d99f4..bc41ff0c 100644
--- a/courgette/disassembler_win32_x86.cc
+++ b/courgette/disassembler_win32_x86.cc
@@ -4,11 +4,13 @@
#include "courgette/disassembler_win32_x86.h"
+#include <stddef.h>
+#include <stdint.h>
+
#include <algorithm>
#include <string>
#include <vector>
-#include "base/basictypes.h"
#include "base/logging.h"
#include "courgette/assembly_program.h"
@@ -55,13 +57,12 @@
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 @@
// 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 @@
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 @@
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 @@
// "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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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<RVA>::iterator rel32_pos = rel32_locations_.begin();
std::vector<RVA>::iterator abs32_pos = abs32_locations_.begin();
@@ -494,7 +495,7 @@
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<RVA>(p - adjust_pointer_to_rva);
@@ -505,7 +506,7 @@
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 @@
++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 @@
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 @@
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 @@
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 @@
// TODO(sra): validate RVA.
directory->address_ = rva;
- directory->size_ = static_cast<uint32>(size);
+ directory->size_ = static_cast<uint32_t>(size);
return true;
} else {
directory->address_ = 0;
diff --git a/courgette/disassembler_win32_x86.h b/courgette/disassembler_win32_x86.h
index 52ce520..891636c8 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 <stddef.h>
+#include <stdint.h>
+
+#include "base/macros.h"
#include "courgette/disassembler.h"
#include "courgette/memory_allocator.h"
#include "courgette/types_win_pe.h"
@@ -36,7 +39,7 @@
//
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 @@
// 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 @@
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<RVA, int>& map);
@@ -76,7 +82,7 @@
// 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<uint32>(image_base_); }
+ uint32_t image_base() const { return static_cast<uint32_t>(image_base_); }
const ImageDataDirectory& base_relocation_table() const {
return base_relocation_table_;
@@ -87,15 +93,14 @@
// 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 @@
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 40cc412d..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 <stdint.h>
+
#include "base/memory/scoped_ptr.h"
#include "base/stl_util.h"
#include "courgette/base_test_unittest.h"
@@ -44,13 +46,13 @@
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<const void*>(file1.c_str()),
reinterpret_cast<const void*>(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<const void*>(file1.c_str()),
reinterpret_cast<const void*>(rva_p));
EXPECT_EQ('M', rva_p[0]);
diff --git a/courgette/encode_decode_unittest.cc b/courgette/encode_decode_unittest.cc
index 2cf5cd4..9e89c20e 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 <stddef.h>
+
#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 <stddef.h>
+#include <stdint.h>
+
#include <algorithm>
#include <map>
#include <string>
@@ -42,7 +45,7 @@
template<typename V>
bool ReadVector(V* items, SourceStream* buffer) {
- uint32 count;
+ uint32_t count;
if (!buffer->ReadVarint32(&count))
return false;
@@ -50,7 +53,7 @@
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<typename V::value_type>(item));
@@ -64,10 +67,10 @@
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 @@
template <typename V>
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<uint32>(prev + delta);
+ uint32_t current = static_cast<uint32_t>(prev + delta);
ok = set->push_back(current);
prev = current;
}
@@ -116,7 +119,7 @@
template<typename V>
bool ReadVectorU8(V* items, SourceStream* buffer) {
- uint32 count;
+ uint32_t count;
if (!buffer->ReadVarint32(&count))
return false;
@@ -190,7 +193,7 @@
}
CheckBool EncodedProgram::AddCopy(size_t count, const void* bytes) {
- const uint8* source = static_cast<const uint8*>(bytes);
+ const uint8_t* source = static_cast<const uint8_t*>(bytes);
bool ok = true;
@@ -240,7 +243,7 @@
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>(op)) &&
rel32_ix_.push_back(label_index);
}
@@ -295,7 +298,7 @@
scoped_ptr<base::Environment> 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<FieldSelect>(~0);
return static_cast<FieldSelect>(fields);
@@ -314,8 +317,8 @@
// the rest can be interleaved.
if (select & INCLUDE_MISC) {
- uint32 high = static_cast<uint32>(image_base_ >> 32);
- uint32 low = static_cast<uint32>(image_base_ & 0xffffffffU);
+ uint32_t high = static_cast<uint32_t>(image_base_ >> 32);
+ uint32_t low = static_cast<uint32_t>(image_base_ & 0xffffffffU);
if (!streams->stream(kStreamMisc)->WriteVarint32(high) ||
!streams->stream(kStreamMisc)->WriteVarint32(low)) {
@@ -360,14 +363,14 @@
}
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<uint64>(high) << 32) | low;
+ image_base_ = (static_cast<uint64_t>(high) << 32) | low;
if (!ReadSigned32Delta(&abs32_rva_, streams->stream(kStreamAbs32Addresses)))
return false;
@@ -411,58 +414,56 @@
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<uint16>(op),
- static_cast<uint32>(rva -
- current_rva),
- &decompressed_op)) {
+ uint32_t decompressed_op;
+ if (!DisassemblerElf32ARM::Decompress(
+ ARM_OFF8, static_cast<uint16_t>(op),
+ static_cast<uint32_t>(rva - current_rva), &decompressed_op)) {
return false;
}
- uint16 op16 = static_cast<uint16>(decompressed_op);
+ uint16_t op16 = static_cast<uint16_t>(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<uint16>(decompressed_op);
+ uint16_t op16 = static_cast<uint16_t>(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 @@
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 @@
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 @@
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 @@
}
case COPY1: {
- uint8 b;
+ uint8_t b;
if (!VectorAt(copy_bytes_, ix_copy_bytes, &b))
return false;
++ix_copy_bytes;
@@ -583,14 +584,14 @@
}
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 @@
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 @@
if (!VectorAt(abs32_rva_, index, &rva))
return false;
if (op == ABS32) {
- base::CheckedNumeric<uint32> abs32 = image_base_;
+ base::CheckedNumeric<uint32_t> 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<uint64> abs64 = image_base_;
+ base::CheckedNumeric<uint64_t> 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 @@
// 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 @@
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 @@
};
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<uint16>(type)) << 12) | (rva & 0xFFF));
+ block.Add(((static_cast<uint16_t>(type)) << 12) | (rva & 0xFFF));
}
ok &= block.Flush(buffer);
return ok;
diff --git a/courgette/encoded_program.h b/courgette/encoded_program.h
index 641f523..81e1639a 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 <stddef.h>
+#include <stdint.h>
+
#include <vector>
-#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 @@
// 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 @@
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 @@
typedef NoThrowBuffer<RVA> RvaVector;
typedef NoThrowBuffer<size_t> SizeTVector;
- typedef NoThrowBuffer<uint32> UInt32Vector;
- typedef NoThrowBuffer<uint8> UInt8Vector;
+ typedef NoThrowBuffer<uint32_t> UInt32Vector;
+ typedef NoThrowBuffer<uint8_t> UInt8Vector;
typedef NoThrowBuffer<OP> 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 @@
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 <stddef.h>
+
#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 <stddef.h>
+#include <stdint.h>
+
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "courgette/disassembler.h"
@@ -15,7 +18,7 @@
using courgette::EncodedProgram;
struct AddressSpec {
- int32 index;
+ int32_t index;
courgette::RVA rva;
};
@@ -27,7 +30,7 @@
size_t num_rel32_specs) {
scoped_ptr<EncodedProgram> 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 @@
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 @@
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 @@
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 @@
// 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 @@
// 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 <stddef.h>
+#include <stdint.h>
+
#include "base/strings/string_number_conversions.h"
#include "courgette/region.h"
@@ -33,7 +35,7 @@
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 e538bd6d..adb4b079 100644
--- a/courgette/ensemble.h
+++ b/courgette/ensemble.h
@@ -17,11 +17,13 @@
#ifndef COURGETTE_ENSEMBLE_H_
#define COURGETTE_ENSEMBLE_H_
-#include <vector>
+#include <stddef.h>
+#include <stdint.h>
+
#include <string>
+#include <vector>
-#include "base/basictypes.h"
-
+#include "base/macros.h"
#include "courgette/courgette.h"
#include "courgette/region.h"
#include "courgette/streams.h"
@@ -130,9 +132,9 @@
// 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..f740ba98 100644
--- a/courgette/ensemble_apply.cc
+++ b/courgette/ensemble_apply.cc
@@ -6,10 +6,13 @@
#include "courgette/ensemble.h"
-#include "base/basictypes.h"
+#include <stddef.h>
+#include <stdint.h>
+
#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 @@
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<TransformationPatcher*> patchers_;
@@ -85,14 +88,14 @@
}
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::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::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 <stddef.h>
+
#include <limits>
#include <vector>
-#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..9a077fd7 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 <stddef.h>
+#include <stdint.h>
// 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 @@
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<const uint16*>(address + offset);
+inline uint16_t ReadU16(const uint8_t* address, size_t offset) {
+ return *reinterpret_cast<const uint16_t*>(address + offset);
}
-inline uint32 ReadU32(const uint8* address, size_t offset) {
- return *reinterpret_cast<const uint32*>(address + offset);
+inline uint32_t ReadU32(const uint8_t* address, size_t offset) {
+ return *reinterpret_cast<const uint32_t*>(address + offset);
}
-inline uint64 ReadU64(const uint8* address, size_t offset) {
- return *reinterpret_cast<const uint64*>(address + offset);
+inline uint64_t ReadU64(const uint8_t* address, size_t offset) {
+ return *reinterpret_cast<const uint64_t*>(address + offset);
}
-inline uint16 Read16LittleEndian(const void* address) {
- return *reinterpret_cast<const uint16*>(address);
+inline uint16_t Read16LittleEndian(const void* address) {
+ return *reinterpret_cast<const uint16_t*>(address);
}
-inline uint32 Read32LittleEndian(const void* address) {
- return *reinterpret_cast<const uint32*>(address);
+inline uint32_t Read32LittleEndian(const void* address) {
+ return *reinterpret_cast<const uint32_t*>(address);
}
-inline uint64 Read64LittleEndian(const void* address) {
- return *reinterpret_cast<const uint64*>(address);
+inline uint64_t Read64LittleEndian(const void* address) {
+ return *reinterpret_cast<const uint64_t*>(address);
}
} // namespace courgette
diff --git a/courgette/image_utils_unittest.cc b/courgette/image_utils_unittest.cc
index a90c19b..5b914c58 100644
--- a/courgette/image_utils_unittest.cc
+++ b/courgette/image_utils_unittest.cc
@@ -4,6 +4,8 @@
#include "courgette/image_utils.h"
+#include <stdint.h>
+
#include "testing/gtest/include/gtest/gtest.h"
namespace courgette {
@@ -11,7 +13,7 @@
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 14b6b4fb..f19975d 100644
--- a/courgette/label_manager.cc
+++ b/courgette/label_manager.cc
@@ -4,6 +4,9 @@
#include "courgette/label_manager.h"
+#include <stddef.h>
+#include <stdint.h>
+
#include <algorithm>
#include "base/logging.h"
@@ -47,12 +50,12 @@
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<uint32> count = it.repeat();
+ base::CheckedNumeric<uint32_t> 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 <stddef.h>
+#include <stdint.h>
+
#include <vector>
#include "base/macros.h"
@@ -43,7 +46,7 @@
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 23871623..acc6240 100644
--- a/courgette/label_manager_unittest.cc
+++ b/courgette/label_manager_unittest.cc
@@ -4,6 +4,9 @@
#include "courgette/label_manager.h"
+#include <stddef.h>
+#include <stdint.h>
+
#include <iterator>
#include <map>
#include <utility>
@@ -42,7 +45,7 @@
};
void CheckLabelManagerContent(TestLabelManager* label_manager,
- const std::map<RVA, int32>& expected) {
+ const std::map<RVA, int32_t>& 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 @@
TestLabelManager label_manager;
label_manager.Read(&visitor);
- static const std::pair<RVA, int32> kExpected1Raw[] = {
- {0x00000110, 1},
- {0x04000010, 3},
- {0x04000020, 1},
- {0x04000030, 2},
- {0xABCD1234, 1},
- {0xFEEDF00D, 2}
- };
- std::map<RVA, int32> expected1(std::begin(kExpected1Raw),
- std::end(kExpected1Raw));
+ static const std::pair<RVA, int32_t> kExpected1Raw[] = {
+ {0x00000110, 1}, {0x04000010, 3}, {0x04000020, 1},
+ {0x04000030, 2}, {0xABCD1234, 1}, {0xFEEDF00D, 2}};
+ std::map<RVA, int32_t> expected1(std::begin(kExpected1Raw),
+ std::end(kExpected1Raw));
CheckLabelManagerContent(&label_manager, expected1);
@@ -98,13 +96,10 @@
// Remove Labels with |count_| < 2.
label_manager.RemoveUnderusedLabels(2);
- static const std::pair<RVA, int32> kExpected2Raw[] = {
- {0x04000010, 3},
- {0x04000030, 2},
- {0xFEEDF00D, 2}
- };
- std::map<RVA, int32> expected2(std::begin(kExpected2Raw),
- std::end(kExpected2Raw));
+ static const std::pair<RVA, int32_t> kExpected2Raw[] = {
+ {0x04000010, 3}, {0x04000030, 2}, {0xFEEDF00D, 2}};
+ std::map<RVA, int32_t> 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 <stddef.h>
+#include <stdint.h>
+
#include <map>
#include "base/files/file_util.h"
@@ -108,7 +111,7 @@
}
void* TempMapping::memory() const {
- uint8* mem = reinterpret_cast<uint8*>(mapping_.view());
+ uint8_t* mem = reinterpret_cast<uint8_t*>(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 59d3ec84..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 <stddef.h>
+#include <stdint.h>
#include <stdlib.h>
-#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/files/file.h"
#include "base/files/file_path.h"
@@ -194,12 +195,12 @@
}
void deallocate(pointer ptr, size_type size) {
- uint8* mem = reinterpret_cast<uint8*>(ptr);
+ uint8_t* mem = reinterpret_cast<uint8_t*>(ptr);
mem -= sizeof(T);
if (mem[0] == HEAP_ALLOCATION) {
free(mem);
} else {
- DCHECK_EQ(static_cast<uint8>(FILE_ALLOCATION), mem[0]);
+ DCHECK_EQ(static_cast<uint8_t>(FILE_ALLOCATION), mem[0]);
UncheckedDelete(TempMapping::GetMappingFromPtr(mem));
}
}
@@ -215,20 +216,20 @@
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<void**>(&mem))) {
- mem[0] = static_cast<uint8>(HEAP_ALLOCATION);
+ mem[0] = static_cast<uint8_t>(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<TempMapping>();
if (mapping) {
if (mapping->Initialize(bytes)) {
- mem = reinterpret_cast<uint8*>(mapping->memory());
- mem[0] = static_cast<uint8>(FILE_ALLOCATION);
+ mem = reinterpret_cast<uint8_t*>(mapping->memory());
+ mem[0] = static_cast<uint8_t>(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 <stddef.h>
+
#include <algorithm>
#include "base/macros.h"
diff --git a/courgette/memory_monitor.cc b/courgette/memory_monitor.cc
index 2769cdc3..a480531b 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 <stddef.h>
#include <stdio.h>
#include <map>
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 e984579f..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 <stdint.h>
+
+#include "base/macros.h"
#include "courgette/ensemble.h"
namespace courgette {
@@ -90,8 +93,8 @@
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 4aafbca8b..b0100cf 100644
--- a/courgette/region.h
+++ b/courgette/region.h
@@ -5,9 +5,11 @@
#ifndef COURGETTE_REGION_H_
#define COURGETTE_REGION_H_
+#include <stddef.h>
+#include <stdint.h>
+
#include <string>
-#include "base/basictypes.h"
namespace courgette {
@@ -21,16 +23,13 @@
// Usual constructor for regions given a |start| address and |length|.
Region(const void* start, size_t length)
- : start_(static_cast<const uint8*>(start)),
- length_(length) {
- }
+ : start_(static_cast<const uint8_t*>(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<const uint8*>(string.c_str())),
- length_(string.length()) {
- }
+ : start_(reinterpret_cast<const uint8_t*>(string.c_str())),
+ length_(string.length()) {}
// Copy constructor.
Region(const Region& other) : start_(other.start_), length_(other.length_) {}
@@ -43,16 +42,16 @@
}
// 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 <stdint.h>
+
#include "courgette/rel32_finder_win32_x86.h"
namespace courgette {
@@ -34,20 +36,19 @@
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<RVA>& 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<RVA>& 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<RVA>::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<RVA>(p - adjust_pointer_to_rva);
if (current_rva == relocs_start_rva_) {
@@ -63,7 +64,7 @@
// 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 <stdint.h>
+
#if COURGETTE_HISTOGRAM_TARGETS
#include <map>
#endif
#include <vector>
-#include "base/basictypes.h"
#include "courgette/image_utils.h"
namespace courgette {
@@ -38,8 +39,8 @@
// - 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<RVA>& abs32_locations) = 0;
@@ -65,8 +66,8 @@
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<RVA>& 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 <stddef.h>
+#include <stdint.h>
+
#include <algorithm>
#include <sstream>
#include <string>
@@ -47,7 +50,7 @@
RVA relocs_start_rva_;
RVA relocs_end_rva_;
RVA image_end_rva_;
- std::vector<uint8> text_data_;
+ std::vector<uint8_t> text_data_;
std::vector<RVA> abs32_locations_;
std::vector<RVA> expected_rel32_locations_;
@@ -71,9 +74,9 @@
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 @@
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<uint8>(vals[i] & 0xFF));
+ text_data_.push_back(static_cast<uint8_t>(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 <memory.h>
+#include <stddef.h>
+#include <stdint.h>
-#include "base/basictypes.h"
#include "base/logging.h"
namespace courgette {
@@ -35,19 +36,20 @@
//
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 @@
//
// 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 @@
// 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<uint8>(value) | 128;
+ *(destination++) = static_cast<uint8_t>(value) | 128;
value = value >> 7;
}
- *(destination++) = static_cast<uint8>(value);
+ *(destination++) = static_cast<uint8_t>(value);
return destination;
}
@@ -134,24 +136,24 @@
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<int32>(unsigned_value >> 1);
+ *output_value = ~static_cast<int32_t>(unsigned_value >> 1);
else
*output_value = (unsigned_value >> 1);
return true;
@@ -185,13 +187,13 @@
return buffer_.append(static_cast<const char*>(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::WriteSizeVarint32(size_t value) {
- uint32 narrowed_value = static_cast<uint32>(value);
+ uint32_t narrowed_value = static_cast<uint32_t>(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 @@
// <bytes1><bytes2>...<bytesN>
//
bool SourceStreamSet::Init(const void* source, size_t byte_count) {
- const uint8* start = static_cast<const uint8*>(source);
- const uint8* end = start + byte_count;
+ const uint8_t* start = static_cast<const uint8_t*>(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::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::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<uint32>(stream->Length());
+ lengths[i] = static_cast<uint32_t>(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 <stddef.h>
+#include <stdint.h>
#include <stdio.h> // for FILE*
#include <string>
-#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 @@
// 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<const uint8*>(pointer);
+ start_ = static_cast<const uint8_t*>(pointer);
end_ = start_ + length;
current_ = start_;
}
@@ -67,7 +69,7 @@
// 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 @@
// 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 @@
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 @@
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 @@
// 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<const uint8*>(buffer_.data());
+ const uint8_t* Buffer() const {
+ return reinterpret_cast<const uint8_t*>(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 <stddef.h>
+#include <stdint.h>
+
#include <vector>
#include "testing/gtest/include/gtest/gtest.h"
@@ -14,7 +17,7 @@
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 @@
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 @@
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 @@
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, 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<int32> values;
+ std::vector<int32_t> 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 @@
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 @@
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..1a7e025d 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 <stdint.h>
+
#include "base/files/file_util.h"
namespace courgette {
@@ -79,9 +80,9 @@
// 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 48ee1be6..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 <stddef.h>
+#include <stdint.h>
+
#include "base/files/memory_mapped_file.h"
#include "courgette/crc.h"
#include "courgette/streams.h"
@@ -57,11 +60,12 @@
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 @@
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 @@
// 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 @@
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 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 b883f733a..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 <stddef.h>
+#include <stdint.h>
#include <stdlib.h>
#include <algorithm>
@@ -67,10 +69,10 @@
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<int>(old_stream->Remaining());
- uint32 pending_diff_zeros = 0;
+ uint32_t pending_diff_zeros = 0;
PagedArray<int> I;
PagedArray<int> V;
@@ -93,7 +95,7 @@
<< (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<int>(new_stream->Remaining());
int control_length = 0;
@@ -224,7 +226,7 @@
};
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 @@
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 76cb879b..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 <stddef.h>
+
+#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 <stddef.h>
+
#include <algorithm>
#include <cstring>
#include <string>
diff --git a/courgette/typedrva_unittest.cc b/courgette/typedrva_unittest.cc
index dc30fa9b..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 <stdint.h>
+
#include "courgette/base_test_unittest.h"
#include "courgette/disassembler_elf_32_arm.h"
#include "courgette/disassembler_elf_32_x86.h"
@@ -14,12 +16,12 @@
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 @@
courgette::RVA expected) const {
courgette::DisassemblerElf32X86::TypedRVAX86* typed_rva
= new courgette::DisassemblerElf32X86::TypedRVAX86(0);
- const uint8* op_pointer = reinterpret_cast<const uint8*>(&word);
+ const uint8_t* op_pointer = reinterpret_cast<const uint8_t*>(&word);
EXPECT_TRUE(typed_rva->ComputeRelativeTarget(op_pointer));
EXPECT_EQ(typed_rva->relative_target(), expected);
@@ -35,17 +37,17 @@
delete typed_rva;
}
-uint32 Read32LittleEndian(const void* address) {
- return *reinterpret_cast<const uint32*>(address);
+uint32_t Read32LittleEndian(const void* address) {
+ return *reinterpret_cast<const uint32_t*>(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<uint8*>(&op);
+ uint8_t* op_pointer = reinterpret_cast<uint8_t*>(&op);
EXPECT_TRUE(typed_rva->ComputeRelativeTarget(op_pointer));
EXPECT_EQ(rva + typed_rva->relative_target(), expected);
@@ -54,16 +56,16 @@
}
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 eb054ee5b..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 <stdint.h>
+
//
// 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 <stddef.h>
+#include <stdint.h>
namespace courgette {
@@ -17,15 +17,15 @@
#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 @@
public:
ImageDataDirectory() : address_(0), size_(0) {}
RVA address_;
- uint32 size_;
+ uint32_t size_;
};
static_assert(sizeof(ImageDataDirectory) == 8,
@@ -54,8 +54,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 91154d82..655aa93 100644
--- a/courgette/versioning_unittest.cc
+++ b/courgette/versioning_unittest.cc
@@ -4,9 +4,10 @@
#include "courgette/base_test_unittest.h"
+#include <stddef.h>
+
#include <string>
-#include "base/basictypes.h"
#include "courgette/courgette.h"
#include "courgette/streams.h"
#include "courgette/third_party/bsdiff.h"