[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 89 matching lines @@
   uint16_t op_size() const { return op_size_; }
 
  private:
   uint16_t compressed_op_;
   const uint8_t* arm_op_;
   uint16_t op_size_;
 };
 
 }  // namespace
 
+/******** InstructionCountReceptor ********/
+
+// TODO(huangs): 2016/11: Populate these with size_ += ...
+CheckBool InstructionCountReceptor::EmitPeRelocs() {
+  return true;
+}
+
+CheckBool InstructionCountReceptor::EmitElfRelocation() {
+  return true;
+}
+
+CheckBool InstructionCountReceptor::EmitElfARMRelocation() {
+  return true;
+}
+
+CheckBool InstructionCountReceptor::EmitOrigin(RVA rva) {
+  return true;
+}
+
+CheckBool InstructionCountReceptor::EmitSingleByte(uint8_t byte) {
+  return true;
+}
+
+CheckBool InstructionCountReceptor::EmitMultipleBytes(const uint8_t* bytes,
+                                                      size_t len) {
+  return true;
+}
+
+CheckBool InstructionCountReceptor::EmitRel32(Label* label) {
+  return true;
+}
+
+CheckBool InstructionCountReceptor::EmitRel32ARM(uint16_t op,
+                                                 Label* label,
+                                                 const uint8_t* arm_op,
+                                                 uint16_t op_size) {
+  return true;
+}
+
+CheckBool InstructionCountReceptor::EmitAbs32(Label* label) {
+  return true;
+}
+
+CheckBool InstructionCountReceptor::EmitAbs64(Label* label) {
+  return true;
+}
+
+/******** InstructionStoreReceptor ********/
+
+// TODO(huangs): 2016/11: Populate these.
+InstructionStoreReceptor::InstructionStoreReceptor(AssemblyProgram* program)
+    : program_(program) {
+  CHECK(program_);
+}
+
+CheckBool InstructionStoreReceptor::EmitPeRelocs() {
+  return program_->EmitPeRelocs();
+}
+
+CheckBool InstructionStoreReceptor::EmitElfRelocation() {
+  return program_->EmitElfRelocation();
+}
+
+CheckBool InstructionStoreReceptor::EmitElfARMRelocation() {
+  return program_->EmitElfARMRelocation();
+}
+
+CheckBool InstructionStoreReceptor::EmitOrigin(RVA rva) {
+  return program_->EmitOrigin(rva);
+}
+
+CheckBool InstructionStoreReceptor::EmitSingleByte(uint8_t byte) {
+  return program_->EmitSingleByte(byte);
+}
+
+CheckBool InstructionStoreReceptor::EmitMultipleBytes(const uint8_t* bytes,
+                                                      size_t len) {
+  return program_->EmitMultipleBytes(bytes, len);
+}
+
+CheckBool InstructionStoreReceptor::EmitRel32(Label* label) {
+  return program_->EmitRel32(label);
+}
+
+CheckBool InstructionStoreReceptor::EmitRel32ARM(uint16_t op,
+                                                 Label* label,
+                                                 const uint8_t* arm_op,
+                                                 uint16_t op_size) {
+  return program_->EmitRel32ARM(op, label, arm_op, op_size);
+}
+
+CheckBool InstructionStoreReceptor::EmitAbs32(Label* label) {
+  return program_->EmitAbs32(label);
+}
+
+CheckBool InstructionStoreReceptor::EmitAbs64(Label* label) {
+  return program_->EmitAbs64(label);
+}
+
+/******** 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::CreateInstructionCountReceptor(
+    InstructionCountReceptor** ret) {
+  DCHECK(ret);
+  DCHECK(!count_receptor_);
+  count_receptor_.reset(new InstructionCountReceptor);
+  *ret = count_receptor_.get();
+  return true;
+}
+
+CheckBool AssemblyProgram::CreateInstructionStoreReceptor(
+    InstructionStoreReceptor** ret) {
+  DCHECK(ret);
+  DCHECK(count_receptor_);
+  DCHECK(!store_receptor_);
+  store_receptor_.reset(new InstructionStoreReceptor(this));
+  // TODO(huangs): 2016/11: Pass |count_receptor_->size()| to |store_receptor_|
+  // to reserve space for raw data.
+  *ret = store_receptor_.get();
+  return true;
+}
+
 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