Implementation of an STL compatible allocator for Courgette on Windows....

courgette/encoded_program.cc

 // Copyright (c) 2010 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 <algorithm>
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 21 matching lines @@
 
 const int kStreamLimit = 9;
 
 // Constructor is here rather than in the header.  Although the constructor
 // appears to do nothing it is fact quite large because of the implict calls to
 // field constructors.  Ditto for the destructor.
 EncodedProgram::EncodedProgram() : image_base_(0) {}
 EncodedProgram::~EncodedProgram() {}
 
 // Serializes a vector of integral values using Varint32 coding.
-template<typename T>
-void WriteVector(const std::vector<T>& items, SinkStream* buffer) {
+template<typename T, typename A>
+void WriteVector(const std::vector<T, A>& items, SinkStream* buffer) {
   size_t count = items.size();
   buffer->WriteSizeVarint32(count);
   for (size_t i = 0;  i < count;  ++i) {
-    COMPILE_ASSERT(sizeof(T) <= sizeof(uint32), T_must_fit_in_uint32);
+    COMPILE_ASSERT(sizeof(T) <= sizeof(uint32),  // NOLINT
+                   T_must_fit_in_uint32);
     buffer->WriteSizeVarint32(items[i]);
   }
 }
 
-template<typename T>
-bool ReadVector(std::vector<T>* items, SourceStream* buffer) {
+template<typename T, typename A>
+bool ReadVector(std::vector<T, A>* items, SourceStream* buffer) {
   uint32 count;
   if (!buffer->ReadVarint32(&count))
     return false;
 
   items->clear();
   items->reserve(count);
   for (size_t i = 0;  i < count;  ++i) {
     uint32 item;
     if (!buffer->ReadVarint32(&item))
       return false;
     items->push_back(static_cast<T>(item));
   }
 
   return true;
 }
 
 // Serializes a vector, using delta coding followed by Varint32 coding.
-void WriteU32Delta(const std::vector<uint32>& set, SinkStream* buffer) {
+template<typename A>
+void WriteU32Delta(const std::vector<uint32, A>& set, SinkStream* buffer) {
   size_t count = set.size();
   buffer->WriteSizeVarint32(count);
   uint32 prev = 0;
   for (size_t i = 0;  i < count;  ++i) {
     uint32 current = set[i];
     uint32 delta = current - prev;
     buffer->WriteVarint32(delta);
     prev = current;
   }
 }
 
-static bool ReadU32Delta(std::vector<uint32>* set, SourceStream* buffer) {
+template <typename A>
+static bool ReadU32Delta(std::vector<uint32, A>* set, SourceStream* buffer) {
   uint32 count;
 
   if (!buffer->ReadVarint32(&count))
     return false;
 
   set->clear();
   set->reserve(count);
   uint32 prev = 0;
 
   for (size_t i = 0;  i < count;  ++i) {
     uint32 delta;
     if (!buffer->ReadVarint32(&delta))
       return false;
     uint32 current = prev + delta;
     set->push_back(current);
     prev = current;
   }
 
   return true;
 }
 
 // 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
 // serilized representation is not endian-agnositic.  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 T>
-void WriteVectorU8(const std::vector<T>& items, SinkStream* buffer) {
+template<typename T, typename A>
+void WriteVectorU8(const std::vector<T, A>& items, SinkStream* buffer) {
   size_t count = items.size();
   buffer->WriteSizeVarint32(count);
   if (count != 0) {
     size_t byte_count = count * sizeof(T);
     buffer->Write(static_cast<const void*>(&items[0]), byte_count);
   }
 }
 
-template<typename T>
-bool ReadVectorU8(std::vector<T>* items, SourceStream* buffer) {
+template<typename T, typename A>
+bool ReadVectorU8(std::vector<T, A>* items, SourceStream* buffer) {
   uint32 count;
   if (!buffer->ReadVarint32(&count))
     return false;
 
   items->clear();
   items->resize(count);
   if (count != 0) {
     size_t byte_count = count * sizeof(T);
     return buffer->Read(static_cast<void*>(&((*items)[0])), byte_count);
   }
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void EncodedProgram::DefineRel32Label(int index, RVA value) {
   DefineLabelCommon(&rel32_rva_, index, value);
 }
 
 void EncodedProgram::DefineAbs32Label(int index, RVA value) {
   DefineLabelCommon(&abs32_rva_, index, value);
 }
 
 static const RVA kUnassignedRVA = static_cast<RVA>(-1);
 
-void EncodedProgram::DefineLabelCommon(std::vector<RVA>* rvas,
+void EncodedProgram::DefineLabelCommon(RvaVector* rvas,
                                        int index,
                                        RVA rva) {
   if (static_cast<int>(rvas->size()) <= index) {
     rvas->resize(index + 1, kUnassignedRVA);
   }
   if ((*rvas)[index] != kUnassignedRVA) {
     NOTREACHED() << "DefineLabel double assigned " << index;
   }
   (*rvas)[index] = rva;
 }
 
 void EncodedProgram::EndLabels() {
   FinishLabelsCommon(&abs32_rva_);
   FinishLabelsCommon(&rel32_rva_);
 }
 
-void EncodedProgram::FinishLabelsCommon(std::vector<RVA>* rvas) {
+void EncodedProgram::FinishLabelsCommon(RvaVector* rvas) {
   // Replace all unassigned slots with the value at the previous index so they
   // delta-encode to zero.  (There might be better values than zero.  The way to
   // get that is have the higher level assembly program assign the unassigned
   // slots.)
   RVA previous = 0;
   size_t size = rvas->size();
   for (size_t i = 0;  i < size;  ++i) {
     if ((*rvas)[i] == kUnassignedRVA)
       (*rvas)[i] = previous;
     else
       previous = (*rvas)[i];
   }
 }
 
 void EncodedProgram::AddOrigin(RVA origin) {
   ops_.push_back(ORIGIN);
   origins_.push_back(origin);
 }
 
-void EncodedProgram::AddCopy(int count, const void* bytes) {
+void EncodedProgram::AddCopy(uint32 count, const void* bytes) {
   const uint8* source = static_cast<const uint8*>(bytes);
 
   // 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_.size() > 0) {
     if (ops_.back() == COPY1) {
       ops_.back() = COPY;
       copy_counts_.push_back(1);
     }
     if (ops_.back() == COPY) {
       copy_counts_.back() += count;
-      for (int i = 0;  i < count;  ++i) {
+      for (uint32 i = 0;  i < count;  ++i) {
         copy_bytes_.push_back(source[i]);
       }
       return;
     }
   }
 
   if (count == 1) {
     ops_.push_back(COPY1);
     copy_bytes_.push_back(source[0]);
   } else {
     ops_.push_back(COPY);
     copy_counts_.push_back(count);
-    for (int i = 0;  i < count;  ++i) {
+    for (uint32 i = 0;  i < count;  ++i) {
       copy_bytes_.push_back(source[i]);
     }
   }
 }
 
 void EncodedProgram::AddAbs32(int label_index) {
   ops_.push_back(ABS32);
   abs32_ix_.push_back(label_index);
 }
 
@@ skipping 116 matching lines @@
   for (int i = 0;  i < kStreamLimit;  ++i) {
     if (streams->stream(i)->Remaining() > 0)
       return false;
   }
 
   return true;
 }
 
 // Safe, non-throwing version of std::vector::at().  Returns 'true' for success,
 // 'false' for out-of-bounds index error.
-template<typename T>
-bool VectorAt(const std::vector<T>& v, size_t index, T* output) {
+template<typename T, typename A>
+bool VectorAt(const std::vector<T, A>& v, size_t index, T* output) {
   if (index >= v.size())
     return false;
   *output = v[index];
   return true;
 }
 
 bool 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;
@@ skipping 19 matching lines @@
       case ORIGIN: {
         RVA section_rva;
         if (!VectorAt(origins_, ix_origins, &section_rva))
           return false;
         ++ix_origins;
         current_rva = section_rva;
         break;
       }
 
       case COPY: {
-        int count;
+        uint32 count;
         if (!VectorAt(copy_counts_, ix_copy_counts, &count))
           return false;
         ++ix_copy_counts;
-        for (int i = 0;  i < count;  ++i) {
+        for (uint32 i = 0;  i < count;  ++i) {
           uint8 b;
           if (!VectorAt(copy_bytes_, ix_copy_bytes, &b))
             return false;
           ++ix_copy_bytes;
           output->Write(&b, 1);
         }
         current_rva += count;
         break;
       }
 
@@ skipping 152 matching lines @@
   if (assembled)
     return C_OK;
   return C_ASSEMBLY_FAILED;
 }
 
 void DeleteEncodedProgram(EncodedProgram* encoded) {
   delete encoded;
 }
 
 }  // end namespace