Switch to standard integer types in courgette/.

courgette/encoded_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/encoded_program.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/numerics/safe_math.h"
@@ skipping 18 matching lines @@
   size_t count = items.size();
   bool ok = buffer->WriteSizeVarint32(count);
   for (size_t i = 0; ok && i < count;  ++i) {
     ok = buffer->WriteSizeVarint32(items[i]);
   }
   return ok;
 }
 
 template<typename V>
 bool ReadVector(V* items, SourceStream* buffer) {
-  uint32 count;
+  uint32_t count;
   if (!buffer->ReadVarint32(&count))
     return false;
 
   items->clear();
 
   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));
   }
 
   return ok;
 }
 
 // Serializes a vector, using delta coding followed by Varint32Signed coding.
 template<typename V>
 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;
   }
   return ok;
 }
 
 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;
     }
   }
   return ok;
 }
 
 // Write a vector as the byte representation of the contents.
 //
 // (This only really makes sense for a type T that has sizeof(T)==1, otherwise
 // serialized representation is not endian-agnostic.  But it is useful to keep
 // the possibility of a greater size for experiments comparing Varint32 encoding
 // of a vector of larger integrals vs a plain form.)
 //
 template<typename V>
 CheckBool WriteVectorU8(const V& items, SinkStream* buffer) {
   size_t count = items.size();
   bool ok = buffer->WriteSizeVarint32(count);
   if (count != 0 && ok) {
     size_t byte_count = count * sizeof(typename V::value_type);
     ok = buffer->Write(static_cast<const void*>(&items[0]), byte_count);
   }
   return ok;
 }
 
 template<typename V>
 bool ReadVectorU8(V* items, SourceStream* buffer) {
-  uint32 count;
+  uint32_t count;
   if (!buffer->ReadVarint32(&count))
     return false;
 
   items->clear();
   bool ok = items->resize(count, 0);
   if (ok && count != 0) {
     size_t byte_count = count * sizeof(typename V::value_type);
     return buffer->Read(static_cast<void*>(&((*items)[0])), byte_count);
   }
   return ok;
@@ skipping 53 matching lines @@
     else
       previous = (*rvas)[i];
   }
 }
 
 CheckBool EncodedProgram::AddOrigin(RVA origin) {
   return ops_.push_back(ORIGIN) && origins_.push_back(origin);
 }
 
 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;
 
   // Fold adjacent COPY instructions into one.  This nearly halves the size of
   // an EncodedProgram with only COPY1 instructions since there are approx plain
   // 16 bytes per reloc.  This has a working-set benefit during decompression.
   // For compression of files with large differences this makes a small (4%)
   // improvement in size.  For files with small differences this degrades the
   // compressed size by 1.3%
   if (!ops_.empty()) {
@@ skipping 29 matching lines @@
 }
 
 CheckBool EncodedProgram::AddAbs64(int label_index) {
   return ops_.push_back(ABS64) && abs32_ix_.push_back(label_index);
 }
 
 CheckBool EncodedProgram::AddRel32(int label_index) {
   return ops_.push_back(REL32) && rel32_ix_.push_back(label_index);
 }
 
-CheckBool EncodedProgram::AddRel32ARM(uint16 op, int label_index) {
+CheckBool EncodedProgram::AddRel32ARM(uint16_t op, int label_index) {
   return ops_.push_back(static_cast<OP>(op)) &&
       rel32_ix_.push_back(label_index);
 }
 
 CheckBool EncodedProgram::AddPeMakeRelocs(ExecutableType kind) {
   if (kind == EXE_WIN_32_X86)
     return ops_.push_back(MAKE_PE_RELOCATION_TABLE);
   return ops_.push_back(MAKE_PE64_RELOCATION_TABLE);
 }
 
@@ skipping 34 matching lines @@
   INCLUDE_BYTES           = 0x0200,
   INCLUDE_COPY_COUNTS     = 0x0400,
   INCLUDE_MISC            = 0x1000
 };
 
 static FieldSelect GetFieldSelect() {
   // TODO(sra): Use better configuration.
   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);
 }
 
 CheckBool EncodedProgram::WriteTo(SinkStreamSet* streams) {
   FieldSelect select = GetFieldSelect();
 
   // The order of fields must be consistent in WriteTo and ReadFrom, regardless
   // of the streams used.  The code can be configured with all kStreamXXX
   // constants the same.
   //
   // If we change the code to pipeline reading with assembly (to avoid temporary
   // storage vectors by consuming operands directly from the stream) then we
   // need to read the base address and the random access address tables first,
   // 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)) {
       return false;
     }
   }
 
   bool success = true;
 
   if (select & INCLUDE_ABS32_ADDRESSES) {
@@ skipping 24 matching lines @@
   if (select & INCLUDE_ABS32_INDEXES)
     success &= WriteVector(abs32_ix_, streams->stream(kStreamAbs32Indexes));
 
   if (select & INCLUDE_REL32_INDEXES)
     success &= WriteVector(rel32_ix_, streams->stream(kStreamRel32Indexes));
 
   return success;
 }
 
 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;
   if (!ReadSigned32Delta(&rel32_rva_, streams->stream(kStreamRel32Addresses)))
     return false;
   if (!ReadVector(&origins_, streams->stream(kStreamOriginAddresses)))
     return false;
   if (!ReadVector(&ops_, streams->stream(kStreamOps)))
     return false;
   if (!ReadVector(&copy_counts_, streams->stream(kStreamCopyCounts)))
@@ skipping 23 matching lines @@
   *output = v[index];
   return true;
 }
 
 CheckBool EncodedProgram::EvaluateRel32ARM(OP op,
                                            size_t& ix_rel32_ix,
                                            RVA& current_rva,
                                            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;
       }
       if (!output->Write(&decompressed_op, 4))
         return false;
       current_rva += 4;
       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;
       break;
     }
     default:
       return false;
   }
 
   return true;
 }
 
 CheckBool EncodedProgram::AssembleTo(SinkStream* final_buffer) {
   // For the most part, the assembly process walks the various tables.
   // ix_mumble is the index into the mumble table.
   size_t ix_origins = 0;
   size_t ix_copy_counts = 0;
   size_t ix_copy_bytes = 0;
   size_t ix_abs32_ix = 0;
   size_t ix_rel32_ix = 0;
 
   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;
 
   SinkStream* output = final_buffer;
 
   for (size_t ix_ops = 0;  ix_ops < ops_.size();  ++ix_ops) {
     OP op = ops_[ix_ops];
 
     switch (op) {
       default:
         if (!EvaluateRel32ARM(op, ix_rel32_ix, current_rva, output))
           return false;
         break;
 
       case ORIGIN: {
         RVA section_rva;
         if (!VectorAt(origins_, ix_origins, &section_rva))
           return false;
         ++ix_origins;
         current_rva = section_rva;
         break;
       }
 
       case COPY: {
         size_t count;
         if (!VectorAt(copy_counts_, ix_copy_counts, &count))
           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;
           if (!output->Write(&b, 1))
             return false;
         }
         current_rva += static_cast<RVA>(count);
         break;
       }
 
       case COPY1: {
-        uint8 b;
+        uint8_t b;
         if (!VectorAt(copy_bytes_, ix_copy_bytes, &b))
           return false;
         ++ix_copy_bytes;
         if (!output->Write(&b, 1))
           return false;
         current_rva += 1;
         break;
       }
 
       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;
         break;
       }
 
       case ABS32:
       case ABS64: {
-        uint32 index;
+        uint32_t index;
         if (!VectorAt(abs32_ix_, ix_abs32_ix, &index))
           return false;
         ++ix_abs32_ix;
         RVA rva;
         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;
           }
           current_rva += 8;
         }
         break;
       }
 
       case MAKE_PE_RELOCATION_TABLE: {
@@ skipping 76 matching lines @@
   if (ix_rel32_ix != rel32_ix_.size())
     return false;
 
   return true;
 }
 
 // RelocBlock has the layout of a block of relocations in the base relocation
 // 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");
 
 class RelocBlock {
  public:
   RelocBlock() {
     pod.page_rva = 0xFFFFFFFF;
     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;
   }
 
   CheckBool Flush(SinkStream* buffer) WARN_UNUSED_RESULT {
     bool ok = true;
     if (pod.block_size != 8) {
       if (pod.block_size % 4 != 0) {  // Pad to make size multiple of 4 bytes.
         Add(0);
       }
       ok = buffer->Write(&pod, pod.block_size);
       pod.block_size = 8;
     }
     return ok;
   }
   RelocBlockPOD pod;
 };
 
 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;
 }
 
 CheckBool EncodedProgram::GenerateElfRelocations(Elf32_Word r_info,
                                                  SinkStream* buffer) {
   std::sort(abs32_relocs_.begin(), abs32_relocs_.end());
 
   Elf32_Rel relocation_block;
@@ skipping 31 matching lines @@
   if (assembled)
     return C_OK;
   return C_ASSEMBLY_FAILED;
 }
 
 void DeleteEncodedProgram(EncodedProgram* encoded) {
   delete encoded;
 }
 
 }  // namespace courgette