[interpreter] Move temporary register allocator into own file.

src/interpreter/constant-array-builder.cc

 // Copyright 2015 the V8 project 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 "src/interpreter/constant-array-builder.h"
 
 #include "src/isolate.h"
 #include "src/objects-inl.h"
 
 namespace v8 {
@@ skipping 67 matching lines @@
 Handle<Object> ConstantArrayBuilder::At(size_t index) const {
   if (index >= idx16_slice_.start_index()) {
     return idx16_slice_.At(index);
   } else if (index < idx8_slice_.size()) {
     return idx8_slice_.At(index);
   } else {
     return isolate_->factory()->the_hole_value();
   }
 }
 
-
-Handle<FixedArray> ConstantArrayBuilder::ToFixedArray() const {
+Handle<FixedArray> ConstantArrayBuilder::ToFixedArray() {
   Handle<FixedArray> fixed_array = isolate_->factory()->NewFixedArray(
       static_cast<int>(size()), PretenureFlag::TENURED);
   for (int i = 0; i < fixed_array->length(); i++) {
     fixed_array->set(i, *At(static_cast<size_t>(i)));
   }
+  constants_map()->Clear();
   return fixed_array;
 }
 
 
 size_t ConstantArrayBuilder::Insert(Handle<Object> object) {
-  index_t* entry = constants_map_.Find(object);
+  index_t* entry = constants_map()->Find(object);
   return (entry == nullptr) ? AllocateEntry(object) : *entry;
 }
 
 
 ConstantArrayBuilder::index_t ConstantArrayBuilder::AllocateEntry(
     Handle<Object> object) {
   DCHECK(!object->IsOddball());
   size_t index;
-  index_t* entry = constants_map_.Get(object);
+  index_t* entry = constants_map()->Get(object);
   if (idx8_slice_.available() > 0) {
     index = idx8_slice_.Allocate(object);
   } else {
     index = idx16_slice_.Allocate(object);
   }
   CHECK_LT(index, kMaxCapacity);
   *entry = static_cast<index_t>(index);
   return *entry;
 }
 
 
 OperandSize ConstantArrayBuilder::CreateReservedEntry() {
   if (idx8_slice_.available() > 0) {
     idx8_slice_.Reserve();
     return OperandSize::kByte;
   } else if (idx16_slice_.available() > 0) {
     idx16_slice_.Reserve();
     return OperandSize::kShort;
   } else {
     UNREACHABLE();
     return OperandSize::kNone;
   }
 }
 
 
 size_t ConstantArrayBuilder::CommitReservedEntry(OperandSize operand_size,
                                                  Handle<Object> object) {
   DiscardReservedEntry(operand_size);
   size_t index;
-  index_t* entry = constants_map_.Find(object);
+  index_t* entry = constants_map()->Find(object);
   if (nullptr == entry) {
     index = AllocateEntry(object);
   } else {
     if (operand_size == OperandSize::kByte &&
         *entry >= idx8_slice_.capacity()) {
       // The object is already in the constant array, but has an index
       // outside the range of an idx8 operand so we need to create a
       // duplicate entry in the idx8 operand range to satisfy the
       // commitment.
       *entry = static_cast<index_t>(idx8_slice_.Allocate(object));
@@ skipping 15 matching lines @@
       idx16_slice_.Unreserve();
       return;
     default:
       UNREACHABLE();
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8