[Interpreter] Fixes VisitObjectLiteral to reserve consecutive registers in innerscope.

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/control-flow-builders.h"
 #include "src/objects.h"
@@ skipping 911 matching lines @@
 }
 
 
 void BytecodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
   // Deep-copy the literal boilerplate.
   builder()->CreateObjectLiteral(expr->constant_properties(),
                                  expr->literal_index(),
                                  expr->ComputeFlags(true));
 
   TemporaryRegisterScope temporary_register_scope(builder());
   Register literal;

[rmcilroy, 2016/01/14 14:04:23]

As discussed offline, let's just always put literal into a register and move it
to a temporary consecutive register in the inner scopes.

[mythria, 2016/01/15 16:48:24]

Done.

 
   // Store computed values into the literal.
   bool literal_in_accumulator = true;
   int property_index = 0;
   AccessorTable accessor_table(zone());
   for (; property_index < expr->properties()->length(); property_index++) {
     TemporaryRegisterScope inner_temporary_register_scope(builder());
     ObjectLiteral::Property* property = expr->properties()->at(property_index);
     if (property->is_computed_name()) break;
     if (property->IsCompileTimeValue()) continue;
 
     if (literal_in_accumulator) {
-      literal = temporary_register_scope.NewRegister();
+      // We reserve for 5 though we use only one in this scope. This register
+      // is used as a parameter along with other registers allocated in the
+      // inner scope. Since they have to be contiguous, reserving 5 registers
+      // lets inner scope allocate consecutive registers starting with this
+      // register.
+      temporary_register_scope.PrepareForConsecutiveAllocations(5);

[mythria, 2016/01/14 10:08:55]

This increases the number of registers used. So alternately, we could also move
literal to a different register in the inner scope. I am not sure which is
better. 

+      literal = temporary_register_scope.NextConsecutiveRegister();
       builder()->StoreAccumulatorInRegister(literal);
       literal_in_accumulator = false;
     }
 
     Literal* literal_key = property->key()->AsLiteral();
     switch (property->kind()) {
       case ObjectLiteral::Property::CONSTANT:
         UNREACHABLE();
       case ObjectLiteral::Property::MATERIALIZED_LITERAL:
         DCHECK(!CompileTimeValue::IsCompileTimeValue(property->value()));
@@ skipping 13 matching lines @@
         } else {
           inner_temporary_register_scope.PrepareForConsecutiveAllocations(3);
           Register key =
               inner_temporary_register_scope.NextConsecutiveRegister();
           Register value =
               inner_temporary_register_scope.NextConsecutiveRegister();
           Register language =
               inner_temporary_register_scope.NextConsecutiveRegister();
           // TODO(oth): This is problematic - can't assume contiguous here.
           // literal is allocated in temporary_register_scope, whereas
           // key, value, language are in another.

[rmcilroy, 2016/01/14 14:04:23]

Remove this TODO

[mythria, 2016/01/15 16:48:24]

Done.

           DCHECK(Register::AreContiguous(literal, key, value, language));
           VisitForAccumulatorValue(property->key());
           builder()->StoreAccumulatorInRegister(key);
           VisitForAccumulatorValue(property->value());
           builder()->StoreAccumulatorInRegister(value);
           if (property->emit_store()) {
             builder()
                 ->LoadLiteral(Smi::FromInt(SLOPPY))
                 .StoreAccumulatorInRegister(language)
                 .CallRuntime(Runtime::kSetProperty, literal, 4);
@@ skipping 1159 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8