[Courgette] Simple AssemblyProgram and Disassembler cleanups.

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/callback_forward.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 98 matching lines @@
   using LabelHandlerMap = std::map<OP, LabelHandler>;
 
   // A callback for GenerateInstructions() to emit instructions. The first
   // argument (AssemblyProgram*) is provided for Label-related feature access.
   // The second argument (InstructionReceptor*) is a receptor for instructions.
   // The callback (which gets called in 2 passes) should return true on success,
   // and false otherwise.
   using InstructionGenerator =
       base::Callback<CheckBool(AssemblyProgram*, InstructionReceptor*)>;
 
-  explicit AssemblyProgram(ExecutableType kind);
+  AssemblyProgram(ExecutableType kind, uint64_t image_base);
   ~AssemblyProgram();
 
   ExecutableType kind() const { return kind_; }
 
-  void set_image_base(uint64_t image_base) { image_base_ = image_base; }
-
   // Traverses RVAs in |abs32_visitor| and |rel32_visitor| to precompute Labels.
   void PrecomputeLabels(RvaVisitor* abs32_visitor, RvaVisitor* rel32_visitor);
 
   // Removes underused Labels. Thresholds used (0 = no trimming) is
   // architecture-dependent.
   void TrimLabels();
 
   void UnassignIndexes();
   void DefaultAssignIndexes();
   void AssignRemainingIndexes();
@@ skipping 53 matching lines @@
 
   // Generates an 8-byte absolute reference to address of 'label'.
   CheckBool EmitAbs64(Label* label) WARN_UNUSED_RESULT;
 
  private:
   using InstructionVector = NoThrowBuffer<Instruction*>;
 
   using ScopedInstruction =
       std::unique_ptr<Instruction, UncheckedDeleter<Instruction>>;
 
-  ExecutableType kind_;
-
   CheckBool Emit(ScopedInstruction instruction) WARN_UNUSED_RESULT;
   CheckBool EmitShared(Instruction* instruction) WARN_UNUSED_RESULT;
 
   static const int kLabelLowerLimit;
 
   // Looks up a label or creates a new one.  Might return NULL.
   Label* FindLabel(RVA rva, RVAToLabel* labels);
 
-  // Helper methods for the public versions.
-  static void UnassignIndexes(RVAToLabel* labels);
-  static void DefaultAssignIndexes(RVAToLabel* labels);
-  static void AssignRemainingIndexes(RVAToLabel* labels);
-
   // Sharing instructions that emit a single byte saves a lot of space.
   Instruction* GetByteInstruction(uint8_t byte);
+
+  const ExecutableType kind_;
+  const uint64_t image_base_;  // Desired or mandated base address of image.
+
   std::unique_ptr<Instruction* [], base::FreeDeleter> byte_instruction_cache_;
 
-  uint64_t image_base_;  // Desired or mandated base address of image.
-
   InstructionVector instructions_;  // All the instructions in program.
 
   // Storage and lookup of Labels associated with target addresses. We use
   // separate abs32 and rel32 labels.
   LabelManager abs32_label_manager_;
   LabelManager rel32_label_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(AssemblyProgram);
 };
 
 // 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_