[Courgette] Clean up EnsembleProgram.

courgette/encoded_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/encoded_program.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
-#include "courgette/courgette.h"
 #include "courgette/disassembler_elf_32_arm.h"
+#include "courgette/label_manager.h"
 #include "courgette/streams.h"
 
 namespace courgette {
 
 namespace {
 
 // Serializes a vector of integral values using Varint32 coding.
 template<typename V>
 CheckBool WriteVector(const V& items, SinkStream* buffer) {
   size_t count = items.size();
@@ skipping 329 matching lines @@
 // 'false' for out-of-bounds index error.
 template<typename V, typename T>
 bool VectorAt(const V& v, size_t index, T* output) {
   if (index >= v.size())
     return false;
   *output = v[index];
   return true;
 }
 
 CheckBool EncodedProgram::EvaluateRel32ARM(OP op,
-                                           size_t& ix_rel32_ix,
-                                           RVA& current_rva,
+                                           size_t* ix_rel32_ix,
+                                           RVA* current_rva,
                                            SinkStream* output) {
   switch (op & 0x0000F000) {
     case REL32ARM8: {
       uint32_t index;
-      if (!VectorAt(rel32_ix_, ix_rel32_ix, &index))
+      if (!VectorAt(rel32_ix_, *ix_rel32_ix, &index))
         return false;
-      ++ix_rel32_ix;
+      ++(*ix_rel32_ix);
       RVA rva;
       if (!VectorAt(rel32_rva_, index, &rva))
         return false;
       uint32_t decompressed_op;
       if (!DisassemblerElf32ARM::Decompress(
               ARM_OFF8, static_cast<uint16_t>(op),
-              static_cast<uint32_t>(rva - current_rva), &decompressed_op)) {
+              static_cast<uint32_t>(rva - *current_rva), &decompressed_op)) {
         return false;
       }
       uint16_t op16 = static_cast<uint16_t>(decompressed_op);
       if (!output->Write(&op16, 2))
         return false;
-      current_rva += 2;
+      *current_rva += 2;
       break;
     }
     case REL32ARM11: {
       uint32_t index;
-      if (!VectorAt(rel32_ix_, ix_rel32_ix, &index))
+      if (!VectorAt(rel32_ix_, *ix_rel32_ix, &index))
         return false;
-      ++ix_rel32_ix;
+      ++(*ix_rel32_ix);
       RVA rva;
       if (!VectorAt(rel32_rva_, index, &rva))
         return false;
       uint32_t decompressed_op;
       if (!DisassemblerElf32ARM::Decompress(ARM_OFF11, (uint16_t)op,
-                                            (uint32_t)(rva - current_rva),
+                                            (uint32_t)(rva - *current_rva),
                                             &decompressed_op)) {
         return false;
       }
       uint16_t op16 = static_cast<uint16_t>(decompressed_op);
       if (!output->Write(&op16, 2))
         return false;
-      current_rva += 2;
+      *current_rva += 2;
       break;
     }
     case REL32ARM24: {
       uint32_t index;
-      if (!VectorAt(rel32_ix_, ix_rel32_ix, &index))
+      if (!VectorAt(rel32_ix_, *ix_rel32_ix, &index))
         return false;
-      ++ix_rel32_ix;
+      ++(*ix_rel32_ix);
       RVA rva;
       if (!VectorAt(rel32_rva_, index, &rva))
         return false;
       uint32_t decompressed_op;
       if (!DisassemblerElf32ARM::Decompress(ARM_OFF24, (uint16_t)op,
-                                            (uint32_t)(rva - current_rva),
+                                            (uint32_t)(rva - *current_rva),
                                             &decompressed_op)) {
         return false;
       }
       if (!output->Write(&decompressed_op, 4))
         return false;
-      current_rva += 4;
+      *current_rva += 4;
       break;
     }
     case REL32ARM25: {
       uint32_t index;
-      if (!VectorAt(rel32_ix_, ix_rel32_ix, &index))
+      if (!VectorAt(rel32_ix_, *ix_rel32_ix, &index))
         return false;
-      ++ix_rel32_ix;
+      ++(*ix_rel32_ix);
       RVA rva;
       if (!VectorAt(rel32_rva_, index, &rva))
         return false;
       uint32_t decompressed_op;
       if (!DisassemblerElf32ARM::Decompress(ARM_OFF25, (uint16_t)op,
-                                            (uint32_t)(rva - current_rva),
+                                            (uint32_t)(rva - *current_rva),
                                             &decompressed_op)) {
         return false;
       }
       uint32_t words = (decompressed_op << 16) | (decompressed_op >> 16);
       if (!output->Write(&words, 4))
         return false;
-      current_rva += 4;
+      *current_rva += 4;
       break;
     }
     case REL32ARM21: {
       uint32_t index;
-      if (!VectorAt(rel32_ix_, ix_rel32_ix, &index))
+      if (!VectorAt(rel32_ix_, *ix_rel32_ix, &index))
         return false;
-      ++ix_rel32_ix;
+      ++(*ix_rel32_ix);
       RVA rva;
       if (!VectorAt(rel32_rva_, index, &rva))
         return false;
       uint32_t decompressed_op;
       if (!DisassemblerElf32ARM::Decompress(ARM_OFF21, (uint16_t)op,
-                                            (uint32_t)(rva - current_rva),
+                                            (uint32_t)(rva - *current_rva),
                                             &decompressed_op)) {
         return false;
       }
       uint32_t words = (decompressed_op << 16) | (decompressed_op >> 16);
       if (!output->Write(&words, 4))
         return false;
-      current_rva += 4;
+      *current_rva += 4;
       break;
     }
     default:
       return false;
   }
 
   return true;
 }
 
 CheckBool EncodedProgram::AssembleTo(SinkStream* final_buffer) {
@@ skipping 12 matching lines @@
   Elf32_Word pending_elf_relocation_table_type = 0;
   SinkStream bytes_following_relocation_table;
 
   SinkStream* output = final_buffer;
 
   for (size_t ix_ops = 0;  ix_ops < ops_.size();  ++ix_ops) {
     OP op = ops_[ix_ops];
 
     switch (op) {
       default:
-        if (!EvaluateRel32ARM(op, ix_rel32_ix, current_rva, output))
+        if (!EvaluateRel32ARM(op, &ix_rel32_ix, &current_rva, output))
           return false;
         break;
 
       case ORIGIN: {
         RVA section_rva;
         if (!VectorAt(origins_, ix_origins, &section_rva))
           return false;
         ++ix_origins;
         current_rva = section_rva;
         break;
@@ skipping 151 matching lines @@
   if (ix_abs32_ix != abs32_ix_.size())
     return false;
   if (ix_rel32_ix != rel32_ix_.size())
     return false;
 
   return true;
 }
 
 // RelocBlock has the layout of a block of relocations in the base relocation
 // table file format.
-//
 struct RelocBlockPOD {
   uint32_t page_rva;
   uint32_t block_size;
   uint16_t relocs[4096];  // Allow up to one relocation per byte of a 4k page.
 };
 
 static_assert(offsetof(RelocBlockPOD, relocs) == 8, "reloc block header size");
 
 class RelocBlock {
  public:
@@ skipping 117 matching lines @@
 }
 
 Status Assemble(EncodedProgram* encoded, SinkStream* buffer) {
   bool assembled = encoded->AssembleTo(buffer);
   if (assembled)
     return C_OK;
   return C_ASSEMBLY_FAILED;
 }
 
 }  // namespace courgette