[interpreter] Bytecode for StaDataPropertyInLiteral.

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/compile-time-value.h"
 #include "src/ast/scopes.h"
 #include "src/code-stubs.h"
 #include "src/compilation-info.h"
@@ skipping 1462 matching lines @@
       builder()
           ->LoadLiteral(Smi::FromInt(DONT_ENUM))
           .StoreAccumulatorInRegister(attr);
       attr_assigned = true;
     }
 
     switch (property->kind()) {
       case ClassLiteral::Property::METHOD: {
         builder()
             ->LoadLiteral(Smi::FromInt(property->NeedsSetFunctionName()))
-            .StoreAccumulatorInRegister(set_function_name)
-            .CallRuntime(Runtime::kDefineDataPropertyInLiteral, args);
+            .StoreAccumulatorInRegister(set_function_name);
+        builder()->LoadAccumulatorWithRegister(value);

[rmcilroy, 2016/11/17 17:18:17]

nit - rather than having value to be in the accumulator, how about just having
set_function_name be in the accumulator and keep value in a register, that way
the bytecode sequence could be:
 ->LoadLiteral(Smi::FromInt(property->NeedsSetFunctionName()))
  .StoreDataPropertyInLiteral(receiver, key, attr, value);

which would save two extra bytecodes.

[Franzi, 2016/11/18 09:11:53]

Done.

+        builder()->StoreDataPropertyInLiteral(receiver, key, attr,

[rmcilroy, 2016/11/17 17:18:17]

nit - just chain the builder calls together like those above.

[Franzi, 2016/11/18 09:11:53]

Done.

+                                              set_function_name);
         break;
       }
       case ClassLiteral::Property::GETTER: {
         builder()->CallRuntime(Runtime::kDefineGetterPropertyUnchecked,
                                args.Truncate(4));
         break;
       }
       case ClassLiteral::Property::SETTER: {
         builder()->CallRuntime(Runtime::kDefineSetterPropertyUnchecked,
                                args.Truncate(4));
@@ skipping 197 matching lines @@
       builder()->MoveRegister(literal, args[0]);
       VisitForRegisterValue(property->value(), args[1]);
       builder()->CallRuntime(Runtime::kInternalSetPrototype, args);
       continue;
     }
 
     switch (property->kind()) {
       case ObjectLiteral::Property::CONSTANT:
       case ObjectLiteral::Property::COMPUTED:
       case ObjectLiteral::Property::MATERIALIZED_LITERAL: {
         RegisterList args = register_allocator()->NewRegisterList(5);

[rmcilroy, 2016/11/17 17:18:17]

These no longer need to be a sequence of consecutive registers (since you aren't
doing a call). This allows you to avoid fixing the registers into a sequence and
having to move "literal" into a different register.
I.e., you can now just do the following:

Register attr = register_allocator()->NewRegister();
Register key = register_allocator()->NewRegister();

VisitForAccumulatorValue(property->key());
builder()->ConvertAccumulatorToName(key)
Register value = VisitForRegisterValue(property->value());
VisitSetHomeObject(value, literal, property);
builder()->LoadLiteral(Smi::FromInt(NONE))
   .StoreAccumulatorInRegister(attr)
   .LoadLiteral(Smi::FromInt(property->NeedsSetFunctionName()))
   .StoreDataPropertyInLiteral(literal, key, attr, value);

[Franzi, 2016/11/18 09:11:53]

Done.

         builder()->MoveRegister(literal, args[0]);
         VisitForAccumulatorValue(property->key());
         builder()->ConvertAccumulatorToName(args[1]);
         VisitForRegisterValue(property->value(), args[2]);
         VisitSetHomeObject(args[2], literal, property);
         builder()
             ->LoadLiteral(Smi::FromInt(NONE))
             .StoreAccumulatorInRegister(args[3])
             .LoadLiteral(Smi::FromInt(property->NeedsSetFunctionName()))
             .StoreAccumulatorInRegister(args[4]);
-        builder()->CallRuntime(Runtime::kDefineDataPropertyInLiteral, args);
+        builder()->LoadAccumulatorWithRegister(args[2]);
+        builder()->StoreDataPropertyInLiteral(args[0], args[1], args[3],

[rmcilroy, 2016/11/17 17:18:17]

ditto

[Franzi, 2016/11/18 09:11:53]

Done.

+                                              args[4]);
         break;
       }
       case ObjectLiteral::Property::GETTER:
       case ObjectLiteral::Property::SETTER: {
         RegisterList args = register_allocator()->NewRegisterList(4);
         builder()->MoveRegister(literal, args[0]);
         VisitForAccumulatorValue(property->key());
         builder()->ConvertAccumulatorToName(args[1]);
         VisitForRegisterValue(property->value(), args[2]);
         VisitSetHomeObject(args[2], literal, property);
@@ skipping 1461 matching lines @@
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreKeyedToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreKeyedToSuper_Strict
                                     : Runtime::kStoreKeyedToSuper_Sloppy;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8