[Courgette] Refactor: Add AssemblyProgram::DispatchInstructionLabels() to hide InstructionVector us…

courgette/adjustment_method.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/adjustment_method.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "courgette/assembly_program.h"
 #include "courgette/courgette.h"
 #include "courgette/encoded_program.h"
 
 namespace courgette {
 
@@ skipping 558 matching lines @@
     prog_->UnassignIndexes();
     CollectTraces(model_, &model_abs32_, &model_rel32_, true);
     CollectTraces(prog_,  &prog_abs32_,  &prog_rel32_,  false);
     Solve(model_abs32_, prog_abs32_);
     Solve(model_rel32_, prog_rel32_);
     prog_->AssignRemainingIndexes();
     return true;
   }
 
  private:
-
   void CollectTraces(const AssemblyProgram* program, Trace* abs32, Trace* rel32,
                      bool is_model) {
-    const InstructionVector& instructions = program->instructions();
-    for (size_t i = 0;  i < instructions.size();  ++i) {
-      Instruction* instruction = instructions[i];
-      if (Label* label = program->InstructionAbs32Label(instruction))
-        ReferenceLabel(abs32, label, is_model);
-      if (Label* label = program->InstructionRel32Label(instruction))
-        ReferenceLabel(rel32, label, is_model);
-    }
+    AssemblyProgram::LabelHandler abs32_handler =
+        base::Bind(&GraphAdjuster::ReferenceLabel, base::Unretained(this),
+                   abs32, is_model);
+    AssemblyProgram::LabelHandler rel32_handler =
+        base::Bind(&GraphAdjuster::ReferenceLabel, base::Unretained(this),
+                   rel32, is_model);
+
+    program->HandleInstructionLabels({{ABS32, abs32_handler},
+                                      {REL32, rel32_handler},
+                                      {REL32ARM, rel32_handler}});
+
     // TODO(sra): we could simply append all the labels in index order to
     // incorporate some costing for entropy (bigger deltas) that will be
     // introduced into the label address table by non-monotonic ordering.  This
     // would have some knock-on effects to parts of the algorithm that work on
     // single-occurrence labels.
   }
 
   void Solve(const Trace& model, const Trace& problem) {
     LinkLabelInfos(model);
     LinkLabelInfos(problem);
@@ skipping 11 matching lines @@
       LabelInfo* curr = *p;
       if (prev) prev->next_addr_ = curr;
       curr->prev_addr_ = prev;
       prev = curr;
 
       if (curr->positions_.size() != curr->refs_)
         NOTREACHED();
     }
   }
 
-  void ReferenceLabel(Trace* trace, Label* label, bool is_model) {
+  void ReferenceLabel(Trace* trace, bool is_model, Label* label) {
     trace->push_back(
         MakeLabelInfo(label, is_model, static_cast<uint32_t>(trace->size())));
   }
 
   LabelInfo* MakeLabelInfo(Label* label, bool is_model, uint32_t position) {
     LabelInfo& slot = label_infos_[label];
     if (slot.label_ == NULL) {
       slot.label_ = label;
       slot.is_model_ = is_model;
       slot.debug_index_ = ++debug_label_index_gen_;
@@ skipping 38 matching lines @@
   AdjustmentMethod* method = AdjustmentMethod::MakeProductionAdjustmentMethod();
   bool ok = method->Adjust(model, program);
   method->Destroy();
   if (ok)
     return C_OK;
   else
     return C_ADJUSTMENT_FAILED;
 }
 
 }  // namespace courgette