Switch to standard integer types in courgette/.

courgette/assembly_program.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "courgette/assembly_program.h"
 
 #include <memory.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <algorithm>
 #include <map>
 #include <set>
 #include <sstream>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 
@@ skipping 27 matching lines @@
 
 // Emits an ELF ARM relocation table.
 class ElfARMRelocsInstruction : public Instruction {
  public:
   ElfARMRelocsInstruction() : Instruction(MAKEELFARMRELOCS) {}
 };
 
 // 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_;
 };
 
 // A ABS32 to REL32 instruction emits a reference to a label's address.
 class InstructionWithLabel : public Instruction {
  public:
   InstructionWithLabel(OP op, Label* label)
     : Instruction(op, 0), label_(label) {
     if (label == NULL) NOTREACHED();
   }
   Label* label() const { return label_; }
  protected:
   Label* label_;
 };
 
 // An ARM REL32 instruction emits a reference to a label's address and
 // 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
 
 AssemblyProgram::AssemblyProgram(ExecutableType kind)
   : kind_(kind), image_base_(0) {
 }
 
 static void DeleteContainedLabels(const RVAToLabel& labels) {
   for (RVAToLabel::const_iterator p = labels.begin();  p != labels.end();  ++p)
@@ skipping 23 matching lines @@
 }
 
 CheckBool AssemblyProgram::EmitElfARMRelocationInstruction() {
   return Emit(ScopedInstruction(UncheckedNew<ElfARMRelocsInstruction>()));
 }
 
 CheckBool AssemblyProgram::EmitOriginInstruction(RVA rva) {
   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)));
 }
 
 CheckBool AssemblyProgram::EmitRel32(Label* label) {
   return Emit(
       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)));
 }
 
 CheckBool AssemblyProgram::EmitAbs32(Label* label) {
   return Emit(
       ScopedInstruction(UncheckedNew<InstructionWithLabel>(ABS32, label)));
 }
 
 CheckBool AssemblyProgram::EmitAbs64(Label* label) {
@@ skipping 145 matching lines @@
   prev = 0;
   for (RVAToLabel::reverse_iterator p = labels->rbegin();
        p != labels->rend();
        ++p) {
     Label* current = p->second;
     if (current->index_ == Label::kNoIndex) {
       int prev_index;
       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)) {
         current->index_ = prev_index - 1;
         available.at(current->index_) = false;
         ++fill_backward_count;
       }
     }
     prev = current;
   }
@@ skipping 55 matching lines @@
     Instruction* instruction = instructions_[i];
 
     switch (instruction->op()) {
       case ORIGIN: {
         OriginInstruction* org = static_cast<OriginInstruction*>(instruction);
         if (!encoded->AddOrigin(org->origin_rva()))
           return NULL;
         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))
           return NULL;
         break;
       }
       case REL32: {
         Label* label = static_cast<InstructionWithLabel*>(instruction)->label();
         if (!encoded->AddRel32(label->index_))
           return NULL;
         break;
       }
       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;
       }
       case ABS32: {
         Label* label = static_cast<InstructionWithLabel*>(instruction)->label();
         if (!encoded->AddAbs32(label->index_))
           return NULL;
         break;
       }
@@ skipping 20 matching lines @@
       }
       default: {
         NOTREACHED() << "Unknown Insn OP kind";
       }
     }
   }
 
   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,
                                reinterpret_cast<void**>(&ram))) {
       return nullptr;
     }
     byte_instruction_cache_.reset(ram);
 
     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]);
         byte_instruction_cache_.reset();
         return nullptr;
       }
     }
   }
 
   return byte_instruction_cache_[byte];
@@ skipping 28 matching lines @@
 
   // Walk through the list of instructions, replacing trimmed labels
   // with the original machine instruction
   for (size_t i = 0; i < instructions_.size(); ++i) {
     Instruction* instruction = instructions_[i];
     switch (instruction->op()) {
       case REL32ARM: {
         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)
             return false;
           UncheckedDelete(instruction);
           instructions_[i] = UncheckedNew<BytesInstruction>(arm_op, op_size);
           if (!instructions_[i])
             return false;
         }
         break;
@@ skipping 20 matching lines @@
   EncodedProgram *encoded = program->Encode();
   if (encoded) {
     *output = encoded;
     return C_OK;
   } else {
     return C_GENERAL_ERROR;
   }
 }
 
 }  // namespace courgette