[Courgette] Reduce AssemblyProgram to reduce Courgette-apply RAM floor and disk churn.

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>
@@ skipping 109 matching lines @@
 
   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;
 }
 
+/******** InstructionStoreReceptor ********/
+
+// An InstructionReceptor that stores emitted instructions.
+class InstructionStoreReceptor : public InstructionReceptor {
+ public:
+  explicit InstructionStoreReceptor(ExecutableType exe_type,
+                                    EncodedProgram* encoded)
+      : exe_type_(exe_type), encoded_(encoded) {
+    CHECK(encoded_);
+  }
+
+  CheckBool EmitPeRelocs() override {
+    return encoded_->AddPeMakeRelocs(exe_type_);
+  }
+  CheckBool EmitElfRelocation() override {
+    return encoded_->AddElfMakeRelocs();
+  }
+  CheckBool EmitElfARMRelocation() override {
+    return encoded_->AddElfARMMakeRelocs();
+  }
+  CheckBool EmitOrigin(RVA rva) override { return encoded_->AddOrigin(rva); }
+  CheckBool EmitSingleByte(uint8_t byte) override {
+    return encoded_->AddCopy(1, &byte);
+  }
+  CheckBool EmitMultipleBytes(const uint8_t* bytes, size_t len) override {
+    return encoded_->AddCopy(len, bytes);
+  }
+  CheckBool EmitRel32(Label* label) override {
+    return encoded_->AddRel32(label->index_);
+  }
+  CheckBool EmitRel32ARM(uint16_t op,
+                         Label* label,
+                         const uint8_t* arm_op,
+                         uint16_t op_size) override {
+    return encoded_->AddRel32ARM(op, label->index_);
+  }
+  CheckBool EmitAbs32(Label* label) override {
+    return encoded_->AddAbs32(label->index_);
+  }
+  CheckBool EmitAbs64(Label* label) override {
+    return encoded_->AddAbs64(label->index_);
+  }
+
+ private:
+  ExecutableType exe_type_;
+  EncodedProgram* encoded_;
+
+  DISALLOW_COPY_AND_ASSIGN(InstructionStoreReceptor);
+};
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Constructor is here rather than in the header. Although the constructor
 // appears to do nothing it is fact quite large because of the implicit calls to
 // field constructors. Ditto for the destructor.
 EncodedProgram::EncodedProgram() {}
 EncodedProgram::~EncodedProgram() {}
 
@@ skipping 526 matching lines @@
   if (ix_copy_bytes != copy_bytes_.size())
     return false;
   if (ix_abs32_ix != abs32_ix_.size())
     return false;
   if (ix_rel32_ix != rel32_ix_.size())
     return false;
 
   return true;
 }
 
+CheckBool EncodedProgram::GenerateInstructions(
+    ExecutableType exe_type,
+    const InstructionGenerator& gen) {
+  InstructionStoreReceptor store_receptor(exe_type, this);
+  return gen.Run(&store_receptor);
+}
+
 // RelocBlock has the layout of a block of relocations in the base relocation
 // table file format.
 struct RelocBlockPOD {
   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");
 
@@ skipping 119 matching lines @@
 }
 
 Status Assemble(EncodedProgram* encoded, SinkStream* buffer) {
   bool assembled = encoded->AssembleTo(buffer);
   if (assembled)
     return C_OK;
   return C_ASSEMBLY_FAILED;
 }
 
 }  // namespace courgette