[interpreter] Inline Star on dispatch for some bytecodes

src/interpreter/interpreter.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/interpreter.h"
 
 #include <fstream>
 
 #include "src/ast/prettyprinter.h"
 #include "src/code-factory.h"
@@ skipping 1600 matching lines @@
 // Creates an object literal for literal index <literal_idx> with
 // CreateObjectLiteralFlags <flags> and constant elements in <element_idx>.
 void Interpreter::DoCreateObjectLiteral(InterpreterAssembler* assembler) {
   Node* literal_index_raw = __ BytecodeOperandIdx(1);
   Node* literal_index = __ SmiTag(literal_index_raw);
   Node* bytecode_flags = __ BytecodeOperandFlag(2);
   Node* closure = __ LoadRegister(Register::function_closure());
 
   // Check if we can do a fast clone or have to call the runtime.
   Label if_fast_clone(assembler),
-      if_not_fast_clone(assembler, Label::kDeferred);
+      if_not_fast_clone(assembler, Label::kDeferred), dispatch(assembler);
   Node* fast_clone_properties_count =
       __ BitFieldDecode<CreateObjectLiteralFlags::FastClonePropertiesCountBits>(
           bytecode_flags);
   __ BranchIf(fast_clone_properties_count, &if_fast_clone, &if_not_fast_clone);
 
   __ Bind(&if_fast_clone);
   {
     // If we can do a fast clone do the fast-path in FastCloneShallowObjectStub.
     Node* result = FastCloneShallowObjectStub::GenerateFastPath(
         assembler, &if_not_fast_clone, closure, literal_index,
         fast_clone_properties_count);
     __ SetAccumulator(result);
-    __ Dispatch();
+    __ Goto(&dispatch);
   }
 
   __ Bind(&if_not_fast_clone);
   {
     // If we can't do a fast clone, call into the runtime.
     Node* index = __ BytecodeOperandIdx(0);
     Node* constant_elements = __ LoadConstantPoolEntry(index);
     Node* context = __ GetContext();
 
     STATIC_ASSERT(CreateObjectLiteralFlags::FlagsBits::kShift == 0);
     Node* flags_raw = __ Word32And(
         bytecode_flags,
         __ Int32Constant(CreateObjectLiteralFlags::FlagsBits::kMask));
     Node* flags = __ SmiTag(flags_raw);
 
     Node* result =
         __ CallRuntime(Runtime::kCreateObjectLiteral, context, closure,
                        literal_index, constant_elements, flags);
     __ SetAccumulator(result);
-    __ Dispatch();
+    __ Goto(&dispatch);
   }
+  __ Bind(&dispatch);
+  __ Dispatch();

[rmcilroy, 2016/07/19 10:03:56]

Can we do this change separately (if at all) - as mentioned, the Dispatch in the
fast-path is actually faster because there hasn't been a call before it happens
(so doesn't need to reload the bytecode array), and since the slow path isn't
run so often, the added instruction size doesn't necessarily hurt us. 

It should eventually be possible to make the second dispatch as fast as the
first eventually, so feel free to add a TODO to make this change when that
happens.

[klaasb, 2016/07/19 14:24:13]

Done.

 }
 
 // CreateClosure <index> <tenured>
 //
 // Creates a new closure for SharedFunctionInfo at position |index| in the
 // constant pool and with the PretenureFlag <tenured>.
 void Interpreter::DoCreateClosure(InterpreterAssembler* assembler) {
   Node* index = __ BytecodeOperandIdx(0);
   Node* shared = __ LoadConstantPoolEntry(index);
   Node* flags = __ BytecodeOperandFlag(1);
@@ skipping 21 matching lines @@
 
 // CreateMappedArguments
 //
 // Creates a new mapped arguments object.
 void Interpreter::DoCreateMappedArguments(InterpreterAssembler* assembler) {
   Node* closure = __ LoadRegister(Register::function_closure());
   Node* context = __ GetContext();
 
   Label if_duplicate_parameters(assembler, Label::kDeferred);
   Label if_not_duplicate_parameters(assembler);
+  Label dispatch(assembler);
 
   // Check if function has duplicate parameters.
   // TODO(rmcilroy): Remove this check when FastNewSloppyArgumentsStub supports
   // duplicate parameters.
   Node* shared_info =
       __ LoadObjectField(closure, JSFunction::kSharedFunctionInfoOffset);
   Node* compiler_hints = __ LoadObjectField(
       shared_info, SharedFunctionInfo::kHasDuplicateParametersByteOffset,
       MachineType::Uint8());
   Node* duplicate_parameters_bit = __ Int32Constant(
       1 << SharedFunctionInfo::kHasDuplicateParametersBitWithinByte);
   Node* compare = __ Word32And(compiler_hints, duplicate_parameters_bit);
   __ BranchIf(compare, &if_duplicate_parameters, &if_not_duplicate_parameters);
 
   __ Bind(&if_not_duplicate_parameters);
   {
     // TODO(rmcilroy): Inline FastNewSloppyArguments when it is a TurboFan stub.
     Callable callable = CodeFactory::FastNewSloppyArguments(isolate_, true);
     Node* target = __ HeapConstant(callable.code());
     Node* result = __ CallStub(callable.descriptor(), target, context, closure);
     __ SetAccumulator(result);
-    __ Dispatch();
+    __ Goto(&dispatch);
   }
 
   __ Bind(&if_duplicate_parameters);
   {
     Node* result =
         __ CallRuntime(Runtime::kNewSloppyArguments_Generic, context, closure);
     __ SetAccumulator(result);
-    __ Dispatch();
+    __ Goto(&dispatch);
   }
+  __ Bind(&dispatch);
+  __ Dispatch();

[rmcilroy, 2016/07/19 10:03:56]

Ditto (same will apply once we can inline FastNewSloppyArguments)

[klaasb, 2016/07/19 14:24:13]

Done.

 }
 
 // CreateUnmappedArguments
 //
 // Creates a new unmapped arguments object.
 void Interpreter::DoCreateUnmappedArguments(InterpreterAssembler* assembler) {
   // TODO(rmcilroy): Inline FastNewStrictArguments when it is a TurboFan stub.
   Callable callable = CodeFactory::FastNewStrictArguments(isolate_, true);
   Node* target = __ HeapConstant(callable.code());
   Node* context = __ GetContext();
@@ skipping 286 matching lines @@
   __ StoreObjectField(generator, JSGeneratorObject::kContinuationOffset,
       __ SmiTag(new_state));
   __ SetAccumulator(old_state);
 
   __ Dispatch();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8