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

courgette/assembly_program.h

 // 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.
 
 #ifndef COURGETTE_ASSEMBLY_PROGRAM_H_
 #define COURGETTE_ASSEMBLY_PROGRAM_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <vector>
 
+#include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/free_deleter.h"
 #include "courgette/courgette.h"
 #include "courgette/image_utils.h"
 #include "courgette/label_manager.h"
 #include "courgette/memory_allocator.h"
 
 namespace courgette {
 
 class EncodedProgram;
@@ skipping 46 matching lines @@
 //
 // The optional step is to modify the AssemblyProgram.  One form of modification
 // is to assign indexes in such a way as to make the EncodedProgram for this
 // AssemblyProgram look more like the EncodedProgram for some other
 // AssemblyProgram.  The modification process should call UnassignIndexes, do
 // its own assignment, and then call AssignRemainingIndexes to ensure all
 // indexes are assigned.
 //
 class AssemblyProgram {
  public:
+  using LabelHandler = base::Callback<void(Label*)>;
+  using LabelDispatcherMap = std::map<OP, LabelHandler>;

[chrisha, 2016/10/28 20:39:14]

LabelHandlerMap, for consistency?

[huangs, 2016/10/28 21:48:13]

Done.

+
   explicit AssemblyProgram(ExecutableType kind);
   ~AssemblyProgram();
 
   ExecutableType kind() const { return kind_; }
 
   void set_image_base(uint64_t image_base) { image_base_ = image_base; }
 
   // Instructions will be assembled in the order they are emitted.
 
   // Generates an entire base relocation table.
@@ skipping 43 matching lines @@
   void AssignRemainingIndexes();
 
   // Looks up abs32 label. Returns null if none found.
   Label* FindAbs32Label(RVA rva);
 
   // Looks up rel32 label. Returns null if none found.
   Label* FindRel32Label(RVA rva);
 
   std::unique_ptr<EncodedProgram> Encode() const;
 
-  // Accessor for instruction list.
-  const InstructionVector& instructions() const {
-    return instructions_;
-  }
-
-  // Returns the label if the instruction contains an absolute 32-bit address,
-  // otherwise returns NULL.
-  Label* InstructionAbs32Label(const Instruction* instruction) const;
-
-  // Returns the label if the instruction contains an absolute 64-bit address,
-  // otherwise returns NULL.
-  Label* InstructionAbs64Label(const Instruction* instruction) const;
-
-  // Returns the label if the instruction contains a rel32 offset,
-  // otherwise returns NULL.
-  Label* InstructionRel32Label(const Instruction* instruction) const;
+  // For each |instruction| in |instructions_|, looks up its opcode from
+  // |dispatcher| for a handler. If a handler exists, invoke it by passing the
+  // |instruction|'s label. We assume that |dispatcher| has correct keys, i.e.,
+  // opcodes for an instruction that have label.
+  void DispatchInstructionLabels(const LabelDispatcherMap& dispatcher) const;

[chrisha, 2016/10/28 20:39:14]

HandleInstructionLabels?

Are we "dispatching" anything? Are messages being routed?

[huangs, 2016/10/28 21:48:13]

Done.

 
  private:
   using ScopedInstruction =
       std::unique_ptr<Instruction, UncheckedDeleter<Instruction>>;
 
   ExecutableType kind_;
 
   CheckBool Emit(ScopedInstruction instruction) WARN_UNUSED_RESULT;
   CheckBool EmitShared(Instruction* instruction) WARN_UNUSED_RESULT;
 
@@ skipping 25 matching lines @@
 
 // Converts |program| into encoded form, returning it as |*output|.
 // Returns C_OK if succeeded, otherwise returns an error status and sets
 // |*output| to null.
 Status Encode(const AssemblyProgram& program,
               std::unique_ptr<EncodedProgram>* output);
 
 }  // namespace courgette
 
 #endif  // COURGETTE_ASSEMBLY_PROGRAM_H_