[Courgette] Refactor: Add and use Instruction*Receptor classes; call ParseFile() in 2 passes.

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>
 
@@ skipping 87 matching lines @@
   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_t compressed_op_;
   const uint8_t* arm_op_;
   uint16_t op_size_;
 };
 
+/******** InstructionCountReceptor ********/
+
+// An InstructionReceptor that counts space occupied by emitted instructions.
+class InstructionCountReceptor : public InstructionReceptor {
+ public:
+  InstructionCountReceptor() = default;
+
+  size_t size() const { return size_; }
+
+  // InstructionReceptor:
+  // TODO(huangs): 2016/11: Populate these with size_ += ...
+  CheckBool EmitPeRelocs() override { return true; }
+  CheckBool EmitElfRelocation() override { return true; }
+  CheckBool EmitElfARMRelocation() override { return true; }
+  CheckBool EmitOrigin(RVA rva) override { return true; }
+  CheckBool EmitSingleByte(uint8_t byte) override { return true; }
+  CheckBool EmitMultipleBytes(const uint8_t* bytes, size_t len) override {
+    return true;
+  }
+  CheckBool EmitRel32(Label* label) override { return true; }
+  CheckBool EmitRel32ARM(uint16_t op,
+                         Label* label,
+                         const uint8_t* arm_op,
+                         uint16_t op_size) override {
+    return true;
+  }
+  CheckBool EmitAbs32(Label* label) override { return true; }
+  CheckBool EmitAbs64(Label* label) override { return true; }
+
+ private:
+  size_t size_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(InstructionCountReceptor);
+};
+
+/******** InstructionStoreReceptor ********/
+
+// An InstructionReceptor that stores emitted instructions.
+class InstructionStoreReceptor : public InstructionReceptor {
+ public:
+  explicit InstructionStoreReceptor(AssemblyProgram* program)
+      : program_(program) {
+    CHECK(program_);
+  }
+
+  // TODO(huangs): 2016/11: Add Reserve().
+
+  // InstructionReceptor:
+  // TODO(huangs): 2016/11: Replace stub with implementation.
+  CheckBool EmitPeRelocs() override { return program_->EmitPeRelocs(); }
+  CheckBool EmitElfRelocation() override {
+    return program_->EmitElfRelocation();
+  }
+  CheckBool EmitElfARMRelocation() override {
+    return program_->EmitElfARMRelocation();
+  }
+  CheckBool EmitOrigin(RVA rva) override { return program_->EmitOrigin(rva); }
+  CheckBool EmitSingleByte(uint8_t byte) override {
+    return program_->EmitSingleByte(byte);
+  }
+  CheckBool EmitMultipleBytes(const uint8_t* bytes, size_t len) override {
+    return program_->EmitMultipleBytes(bytes, len);
+  }
+  CheckBool EmitRel32(Label* label) override {
+    return program_->EmitRel32(label);
+  }
+  CheckBool EmitRel32ARM(uint16_t op,
+                         Label* label,
+                         const uint8_t* arm_op,
+                         uint16_t op_size) override {
+    return program_->EmitRel32ARM(op, label, arm_op, op_size);
+  }
+  CheckBool EmitAbs32(Label* label) override {
+    return program_->EmitAbs32(label);
+  }
+  CheckBool EmitAbs64(Label* label) override {
+    return program_->EmitAbs64(label);
+  }
+
+ private:
+  AssemblyProgram* program_;
+
+  DISALLOW_COPY_AND_ASSIGN(InstructionStoreReceptor);
+};
+
 }  // namespace
 
+/******** AssemblyProgram ********/
+
 AssemblyProgram::AssemblyProgram(ExecutableType kind)
   : kind_(kind), image_base_(0) {
 }
 
 AssemblyProgram::~AssemblyProgram() {
   for (size_t i = 0;  i < instructions_.size();  ++i) {
     Instruction* instruction = instructions_[i];
     if (instruction->op() != DEFBYTE)  // Owned by byte_instruction_cache_.
       UncheckedDelete(instruction);
   }
   if (byte_instruction_cache_.get()) {
     for (size_t i = 0;  i < 256;  ++i)
       UncheckedDelete(byte_instruction_cache_[i]);
   }
 }
 
-CheckBool AssemblyProgram::EmitPeRelocsInstruction() {
+CheckBool AssemblyProgram::EmitPeRelocs() {
   return Emit(ScopedInstruction(UncheckedNew<PeRelocsInstruction>()));
 }
 
-CheckBool AssemblyProgram::EmitElfRelocationInstruction() {
+CheckBool AssemblyProgram::EmitElfRelocation() {
   return Emit(ScopedInstruction(UncheckedNew<ElfRelocsInstruction>()));
 }
 
-CheckBool AssemblyProgram::EmitElfARMRelocationInstruction() {
+CheckBool AssemblyProgram::EmitElfARMRelocation() {
   return Emit(ScopedInstruction(UncheckedNew<ElfARMRelocsInstruction>()));
 }
 
-CheckBool AssemblyProgram::EmitOriginInstruction(RVA rva) {
+CheckBool AssemblyProgram::EmitOrigin(RVA rva) {
   return Emit(ScopedInstruction(UncheckedNew<OriginInstruction>(rva)));
 }
 
-CheckBool AssemblyProgram::EmitByteInstruction(uint8_t byte) {
+CheckBool AssemblyProgram::EmitSingleByte(uint8_t byte) {
   return EmitShared(GetByteInstruction(byte));
 }
 
-CheckBool AssemblyProgram::EmitBytesInstruction(const uint8_t* values,
-                                                size_t len) {
-  return Emit(ScopedInstruction(UncheckedNew<BytesInstruction>(values, len)));
+CheckBool AssemblyProgram::EmitMultipleBytes(const uint8_t* bytes, size_t len) {
+  return Emit(ScopedInstruction(UncheckedNew<BytesInstruction>(bytes, len)));
 }
 
 CheckBool AssemblyProgram::EmitRel32(Label* label) {
   return Emit(
       ScopedInstruction(UncheckedNew<InstructionWithLabel>(REL32, label)));
 }
 
 CheckBool AssemblyProgram::EmitRel32ARM(uint16_t op,
                                         Label* label,
                                         const uint8_t* arm_op,
@@ skipping 62 matching lines @@
     const AssemblyProgram::LabelHandlerMap& handler_map) const {
   for (const Instruction* instruction : instructions_) {
     LabelHandlerMap::const_iterator it = handler_map.find(instruction->op());
     if (it != handler_map.end()) {
       it->second.Run(
           static_cast<const InstructionWithLabel*>(instruction)->label());
     }
   }
 }
 
+CheckBool AssemblyProgram::GenerateInstructions(
+    const InstructionGenerator& gen) {
+  // Pass 1: Count the space needed to store instructions.
+  InstructionCountReceptor count_receptor;
+  if (!gen.Run(this, &count_receptor))
+    return false;
+
+  // Pass 2: Emit all instructions to preallocated buffer (uses Phase 1 count).
+  InstructionStoreReceptor store_receptor(this);
+  // TODO(huangs): 2016/11: Pass |count_receptor_->size()| to |store_receptor_|
+  // to reserve space for raw data.
+  return gen.Run(this, &store_receptor);
+}
+
 CheckBool AssemblyProgram::Emit(ScopedInstruction instruction) {
   if (!instruction || !instructions_.push_back(instruction.get()))
     return false;
   // Ownership successfully passed to instructions_.
   ignore_result(instruction.release());
   return true;
 }
 
 CheckBool AssemblyProgram::EmitShared(Instruction* instruction) {
   DCHECK(!instruction || instruction->op() == DEFBYTE);
   return instruction && instructions_.push_back(instruction);
 }
 
 void AssemblyProgram::UnassignIndexes(RVAToLabel* labels) {
   for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {
     Label* current = p->second;
     current->index_ = Label::kNoIndex;
   }
 }
 
 // DefaultAssignIndexes takes a set of labels and assigns indexes in increasing
 // address order.
-//
 void AssemblyProgram::DefaultAssignIndexes(RVAToLabel* labels) {
   int index = 0;
   for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {
     Label* current = p->second;
     if (current->index_ != Label::kNoIndex)
       NOTREACHED();
     current->index_ = index;
     ++index;
   }
 }
 
 // AssignRemainingIndexes assigns indexes to any addresses (labels) that are not
 // yet assigned an index.
-//
 void AssemblyProgram::AssignRemainingIndexes(RVAToLabel* labels) {
   // An address table compresses best when each index is associated with an
   // address that is slight larger than the previous index.
 
   // First see which indexes have not been used.  The 'available' vector could
   // grow even bigger, but the number of addresses is a better starting size
   // than empty.
   std::vector<bool> available(labels->size(), true);
   int used = 0;
 
   for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {
     int index = p->second->index_;
     if (index != Label::kNoIndex) {
       while (static_cast<size_t>(index) >= available.size())
         available.push_back(true);
       available.at(index) = false;
       ++used;
     }
   }
 
   VLOG(1) << used << " of " << labels->size() << " labels pre-assigned";
 
   // Are there any unused labels that happen to be adjacent following a used
   // label?
-  //
   int fill_forward_count = 0;
   Label* prev = 0;
   for (RVAToLabel::iterator p = labels->begin();  p != labels->end();  ++p) {
     Label* current = p->second;
     if (current->index_ == Label::kNoIndex) {
       int index = 0;
       if (prev  &&  prev->index_ != Label::kNoIndex)
         index = prev->index_ + 1;
       if (index < static_cast<int>(available.size()) && available.at(index)) {
         current->index_ = index;
         available.at(index) = false;
         ++fill_forward_count;
       }
     }
     prev = current;
   }
 
   // Are there any unused labels that happen to be adjacent preceeding a used
   // label?
-  //
   int fill_backward_count = 0;
   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_;
@@ skipping 144 matching lines @@
 Status Encode(const AssemblyProgram& program,
               std::unique_ptr<EncodedProgram>* output) {
   // Explicitly release any memory associated with the output before encoding.
   output->reset();
 
   *output = program.Encode();
   return (*output) ? C_OK : C_GENERAL_ERROR;
 }
 
 }  // namespace courgette