[interpreter] Move temporary register allocator into own file.

src/interpreter/bytecode-generator.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/bytecode-generator.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
 #include "src/interpreter/bytecode-register-allocator.h"
 #include "src/interpreter/control-flow-builders.h"
@@ skipping 355 matching lines @@
   } while (current != nullptr);
   UNREACHABLE();
 }
 
 
 class BytecodeGenerator::RegisterAllocationScope {
  public:
   explicit RegisterAllocationScope(BytecodeGenerator* generator)
       : generator_(generator),
         outer_(generator->register_allocator()),
-        allocator_(builder()) {
+        allocator_(builder()->zone(),
+                   builder()->temporary_register_allocator()) {
     generator_->set_register_allocator(this);
   }
 
   virtual ~RegisterAllocationScope() {
     generator_->set_register_allocator(outer_);
   }
 
   Register NewRegister() {
     RegisterAllocationScope* current_scope = generator()->register_allocator();
     if ((current_scope == this) ||
         (current_scope->outer() == this &&
          !current_scope->allocator_.HasConsecutiveAllocations())) {
       // Regular case - Allocating registers in current or outer context.
       // VisitForRegisterValue allocates register in outer context.
       return allocator_.NewRegister();
     } else {
       // If it is required to allocate a register other than current or outer
       // scopes, allocate a new temporary register. It might be expensive to
       // walk the full context chain and compute the list of consecutive
       // reservations in the innerscopes.
       UNIMPLEMENTED();
-      return Register(-1);
+      return Register::invalid_value();
     }
   }
 
-  void PrepareForConsecutiveAllocations(size_t count) {
+  void PrepareForConsecutiveAllocations(int count) {
     allocator_.PrepareForConsecutiveAllocations(count);
   }
 
   Register NextConsecutiveRegister() {
     return allocator_.NextConsecutiveRegister();
   }
 
   bool RegisterIsAllocatedInThisScope(Register reg) const {
     return allocator_.RegisterIsAllocatedInThisScope(reg);
   }
@@ skipping 100 matching lines @@
       : ExpressionResultScope(generator, Expression::kValue) {}
 
   virtual void SetResultInAccumulator() {
     result_register_ = allocator()->outer()->NewRegister();
     builder()->StoreAccumulatorInRegister(result_register_);
     set_result_identified();
   }
 
   virtual void SetResultInRegister(Register reg) {
     DCHECK(builder()->RegisterIsParameterOrLocal(reg) ||
-           (builder()->RegisterIsTemporary(reg) &&
+           (builder()->TemporaryRegisterIsLive(reg) &&
             !allocator()->RegisterIsAllocatedInThisScope(reg)));
     result_register_ = reg;
     set_result_identified();
   }
 
   Register ResultRegister() const { return result_register_; }
 
  private:
   Register result_register_;
 };
 
 
 BytecodeGenerator::BytecodeGenerator(Isolate* isolate, Zone* zone)
     : isolate_(isolate),
       zone_(zone),
-      builder_(isolate, zone),
       info_(nullptr),
       scope_(nullptr),
       globals_(0, zone),
       execution_control_(nullptr),
       execution_context_(nullptr),
       execution_result_(nullptr),
       register_allocator_(nullptr) {
   InitializeAstVisitor(isolate);
 }
 
 
 Handle<BytecodeArray> BytecodeGenerator::MakeBytecode(CompilationInfo* info) {
   set_info(info);
   set_scope(info->scope());
 
   // Initialize the incoming context.
   ContextScope incoming_context(this, scope(), false);
 
   // Initialize control scope.
   ControlScopeForTopLevel control(this);
 
-  builder()->set_parameter_count(info->num_parameters_including_this());
-  builder()->set_locals_count(scope()->num_stack_slots());
-  builder()->set_context_count(scope()->MaxNestedContextChainLength());
+  // Initialize bytecode array builder.
+  set_builder(new (zone()) BytecodeArrayBuilder(
+      isolate(), zone(), info->num_parameters_including_this(),
+      scope()->MaxNestedContextChainLength(), scope()->num_stack_slots()));

[rmcilroy, 2016/02/02 10:53:28]

optional nit - could we do this before allocating ContextScope / ControlScopes?
Seems safer somehow...

[oth, 2016/02/02 11:20:24]

Done.

 
   // Build function context only if there are context allocated variables.
   if (scope()->NeedsContext()) {
     // Push a new inner context scope for the function.
     VisitNewLocalFunctionContext();
     ContextScope local_function_context(this, scope(), false);
     VisitBuildLocalActivationContext();
     MakeBytecodeBody();
   } else {
     MakeBytecodeBody();
   }
 
   set_scope(nullptr);
   set_info(nullptr);
-  return builder_.ToBytecodeArray();
+  return builder()->ToBytecodeArray();
 }
 
 
 void BytecodeGenerator::MakeBytecodeBody() {
   // Build the arguments object if it is used.
   VisitArgumentsObject(scope()->arguments());
 
   // TODO(mythria): Build rest arguments array if it is used.
   int rest_index;
   if (scope()->rest_parameter(&rest_index)) {
@@ skipping 1917 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8