[builtins] Add EmitFastNewObject

src/builtins/builtins-constructor.cc

 // Copyright 2016 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/builtins/builtins-constructor.h"
 #include "src/ast/ast.h"
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
@@ skipping 143 matching lines @@
   Node* context = Parameter(FastNewClosureDescriptor::kContext);
   Return(EmitFastNewClosure(shared, context));
 }
 
 TF_BUILTIN(FastNewObject, ConstructorBuiltinsAssembler) {
   typedef FastNewObjectDescriptor Descriptor;
   Node* context = Parameter(Descriptor::kContext);
   Node* target = Parameter(Descriptor::kTarget);
   Node* new_target = Parameter(Descriptor::kNewTarget);
 
+  Label call_runtime(this);
+
+  Node* result = EmitFastNewObject(context, target, new_target, &call_runtime);
+  Return(result);
+
+  Bind(&call_runtime);
+  TailCallRuntime(Runtime::kNewObject, context, target, new_target);
+}
+
+Node* ConstructorBuiltinsAssembler::EmitFastNewObject(Node* context,
+                                                      Node* target,
+                                                      Node* new_target) {
+  Variable var_obj(this, MachineRepresentation::kTagged);
+  Label call_runtime(this), end(this);
+
+  Node* result = EmitFastNewObject(context, target, new_target, &call_runtime);
+  var_obj.Bind(result);
+  Goto(&end);
+
+  Bind(&call_runtime);
+  var_obj.Bind(CallRuntime(Runtime::kNewObject, context, target, new_target));
+  Goto(&end);
+
+  Bind(&end);
+  return var_obj.value();
+}
+
+Node* ConstructorBuiltinsAssembler::EmitFastNewObject(
+    Node* context, Node* target, Node* new_target,
+    CodeAssemblerLabel* call_runtime) {
   CSA_ASSERT(this, HasInstanceType(target, JS_FUNCTION_TYPE));
   CSA_ASSERT(this, IsJSReceiver(new_target));
 
   // Verify that the new target is a JSFunction.
-  Label runtime(this), fast(this);
+  Label fast(this), end(this);
   GotoIf(HasInstanceType(new_target, JS_FUNCTION_TYPE), &fast);
-  Goto(&runtime);
-
-  Bind(&runtime);
-  TailCallRuntime(Runtime::kNewObject, context, target, new_target);
+  Goto(call_runtime);
 
   Bind(&fast);
 
   // Load the initial map and verify that it's in fact a map.
   Node* initial_map =
       LoadObjectField(new_target, JSFunction::kPrototypeOrInitialMapOffset);
-  GotoIf(TaggedIsSmi(initial_map), &runtime);
-  GotoIf(DoesntHaveInstanceType(initial_map, MAP_TYPE), &runtime);
+  GotoIf(TaggedIsSmi(initial_map), call_runtime);
+  GotoIf(DoesntHaveInstanceType(initial_map, MAP_TYPE), call_runtime);
 
   // Fall back to runtime if the target differs from the new target's
   // initial map constructor.
   Node* new_target_constructor =
       LoadObjectField(initial_map, Map::kConstructorOrBackPointerOffset);
-  GotoIf(WordNotEqual(target, new_target_constructor), &runtime);
+  GotoIf(WordNotEqual(target, new_target_constructor), call_runtime);
 
   Node* instance_size_words = ChangeUint32ToWord(LoadObjectField(
       initial_map, Map::kInstanceSizeOffset, MachineType::Uint8()));
   Node* instance_size =
       WordShl(instance_size_words, IntPtrConstant(kPointerSizeLog2));
 
   Node* object = Allocate(instance_size);
   StoreMapNoWriteBarrier(object, initial_map);
   Node* empty_array = LoadRoot(Heap::kEmptyFixedArrayRootIndex);
   StoreObjectFieldNoWriteBarrier(object, JSObject::kPropertiesOffset,
                                  empty_array);
   StoreObjectFieldNoWriteBarrier(object, JSObject::kElementsOffset,
                                  empty_array);
 
   instance_size_words = ChangeUint32ToWord(LoadObjectField(
       initial_map, Map::kInstanceSizeOffset, MachineType::Uint8()));
   instance_size =
       WordShl(instance_size_words, IntPtrConstant(kPointerSizeLog2));
 
   // Perform in-object slack tracking if requested.
   Node* bit_field3 = LoadMapBitField3(initial_map);
   Label slack_tracking(this), finalize(this, Label::kDeferred), done(this);
   GotoIf(IsSetWord32<Map::ConstructionCounter>(bit_field3), &slack_tracking);
 
   // Initialize remaining fields.
   {
     Comment("no slack tracking");
     InitializeFieldsWithRoot(object, IntPtrConstant(JSObject::kHeaderSize),
                              instance_size, Heap::kUndefinedValueRootIndex);
-    Return(object);
+    Goto(&end);
   }
 
   {
     Bind(&slack_tracking);
 
     // Decrease generous allocation count.
     STATIC_ASSERT(Map::ConstructionCounter::kNext == 32);
     Comment("update allocation count");
     Node* new_bit_field3 = Int32Sub(
         bit_field3, Int32Constant(1 << Map::ConstructionCounter::kShift));
     StoreObjectFieldNoWriteBarrier(initial_map, Map::kBitField3Offset,
                                    new_bit_field3,
                                    MachineRepresentation::kWord32);
     GotoIf(IsClearWord32<Map::ConstructionCounter>(new_bit_field3), &finalize);
 
     Node* unused_fields = LoadObjectField(
         initial_map, Map::kUnusedPropertyFieldsOffset, MachineType::Uint8());
     Node* used_size =
         IntPtrSub(instance_size, WordShl(ChangeUint32ToWord(unused_fields),
                                          IntPtrConstant(kPointerSizeLog2)));
 
     Comment("initialize filler fields (no finalize)");
     InitializeFieldsWithRoot(object, used_size, instance_size,
                              Heap::kOnePointerFillerMapRootIndex);
 
     Comment("initialize undefined fields (no finalize)");
     InitializeFieldsWithRoot(object, IntPtrConstant(JSObject::kHeaderSize),
                              used_size, Heap::kUndefinedValueRootIndex);
-    Return(object);
+    Goto(&end);
   }
 
   {
     // Finalize the instance size.
     Bind(&finalize);
 
     Node* unused_fields = LoadObjectField(
         initial_map, Map::kUnusedPropertyFieldsOffset, MachineType::Uint8());
     Node* used_size =
         IntPtrSub(instance_size, WordShl(ChangeUint32ToWord(unused_fields),
                                          IntPtrConstant(kPointerSizeLog2)));
 
     Comment("initialize filler fields (finalize)");
     InitializeFieldsWithRoot(object, used_size, instance_size,
                              Heap::kOnePointerFillerMapRootIndex);
 
     Comment("initialize undefined fields (finalize)");
     InitializeFieldsWithRoot(object, IntPtrConstant(JSObject::kHeaderSize),
                              used_size, Heap::kUndefinedValueRootIndex);
 
     CallRuntime(Runtime::kFinalizeInstanceSize, context, initial_map);
-    Return(object);
+    Goto(&end);
   }
+
+  Bind(&end);
+  return object;
 }
 
 Node* ConstructorBuiltinsAssembler::EmitFastNewFunctionContext(
     Node* function, Node* slots, Node* context, ScopeType scope_type) {
   slots = ChangeUint32ToWord(slots);
 
   // TODO(ishell): Use CSA::OptimalParameterMode() here.
   CodeStubAssembler::ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
   Node* min_context_slots = IntPtrConstant(Context::MIN_CONTEXT_SLOTS);
   Node* length = IntPtrAdd(slots, min_context_slots);
@@ skipping 453 matching lines @@
     case 6:
       return FastCloneShallowObject6();
     default:
       UNREACHABLE();
   }
   return Handle<Code>::null();
 }
 
 }  // namespace internal
 }  // namespace v8