[turbofan] Introduce node regions for protection from scheduling.

src/compiler/js-typed-lowering.cc

 // Copyright 2014 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/code-factory.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/node-matchers.h"
@@ skipping 28 matching lines @@
   AllocationBuilder(JSGraph* jsgraph, SimplifiedOperatorBuilder* simplified,
                     Node* effect, Node* control)
       : jsgraph_(jsgraph),
         simplified_(simplified),
         allocation_(nullptr),
         effect_(effect),
         control_(control) {}
 
   // Primitive allocation of static size.
   void Allocate(int size) {
+    effect_ = graph()->NewNode(jsgraph()->common()->BeginRegion(), effect_);
     allocation_ = graph()->NewNode(
         simplified()->Allocate(), jsgraph()->Constant(size), effect_, control_);
     effect_ = allocation_;
   }
 
   // Primitive store into a field.
   void Store(const FieldAccess& access, Node* value) {
     effect_ = graph()->NewNode(simplified()->StoreField(access), allocation_,
                                value, effect_, control_);
   }
 
   // Compound allocation of a FixedArray.
   void AllocateArray(int length, Handle<Map> map) {
     Allocate(FixedArray::SizeFor(length));
     Store(AccessBuilder::ForMap(), map);
     Store(AccessBuilder::ForFixedArrayLength(graph()->zone()),
           jsgraph()->Constant(length));
   }
 
   // Compound store of a constant into a field.
   void Store(const FieldAccess& access, Handle<Object> value) {
     Store(access, jsgraph()->Constant(value));
   }
 
-  Node* allocation() const { return allocation_; }
-  Node* effect() const { return effect_; }
+  void Finish(Node* node) {
+    NodeProperties::SetType(allocation_, NodeProperties::GetType(node));
+    node->ReplaceInput(0, allocation_);
+    node->ReplaceInput(1, effect_);
+    node->TrimInputCount(2);
+    NodeProperties::ChangeOp(node, jsgraph()->common()->FinishRegion());
+  }
 
  protected:
   JSGraph* jsgraph() { return jsgraph_; }
   Graph* graph() { return jsgraph_->graph(); }
   SimplifiedOperatorBuilder* simplified() { return simplified_; }
 
  private:
   JSGraph* const jsgraph_;
   SimplifiedOperatorBuilder* simplified_;
   Node* allocation_;
@@ skipping 1182 matching lines @@
     STATIC_ASSERT(Context::MIN_CONTEXT_SLOTS == 4);  // Ensure fully covered.
     int context_length = slot_count + Context::MIN_CONTEXT_SLOTS;
     a.AllocateArray(context_length, factory()->function_context_map());
     a.Store(AccessBuilder::ForContextSlot(Context::CLOSURE_INDEX), closure);
     a.Store(AccessBuilder::ForContextSlot(Context::PREVIOUS_INDEX), context);
     a.Store(AccessBuilder::ForContextSlot(Context::EXTENSION_INDEX), extension);
     a.Store(AccessBuilder::ForContextSlot(Context::GLOBAL_OBJECT_INDEX), load);
     for (int i = Context::MIN_CONTEXT_SLOTS; i < context_length; ++i) {
       a.Store(AccessBuilder::ForContextSlot(i), jsgraph()->TheHoleConstant());
     }
-    // TODO(mstarzinger): We could mutate {node} into the allocation instead.
-    NodeProperties::SetType(a.allocation(), NodeProperties::GetType(node));
-    ReplaceWithValue(node, node, a.effect());
-    node->ReplaceInput(0, a.allocation());
-    node->ReplaceInput(1, a.effect());
-    node->TrimInputCount(2);
-    NodeProperties::ChangeOp(node, common()->Finish(1));
+    RelaxControls(node);
+    a.Finish(node);
     return Changed(node);
   }
 
   // Use the FastNewContextStub only for function contexts up maximum size.
   if (slot_count <= FastNewContextStub::kMaximumSlots) {
     Isolate* isolate = jsgraph()->isolate();
     Callable callable = CodeFactory::FastNewContext(isolate, slot_count);
     CallDescriptor* desc = Linkage::GetStubCallDescriptor(
         isolate, graph()->zone(), callable.descriptor(), 0,
         CallDescriptor::kNoFlags);
@@ skipping 24 matching lines @@
         simplified()->LoadField(
             AccessBuilder::ForContextSlot(Context::GLOBAL_OBJECT_INDEX)),
         context, effect, control);
     AllocationBuilder a(jsgraph(), simplified(), effect, control);
     STATIC_ASSERT(Context::MIN_CONTEXT_SLOTS == 4);  // Ensure fully covered.
     a.AllocateArray(Context::MIN_CONTEXT_SLOTS, factory()->with_context_map());
     a.Store(AccessBuilder::ForContextSlot(Context::CLOSURE_INDEX), closure);
     a.Store(AccessBuilder::ForContextSlot(Context::PREVIOUS_INDEX), context);
     a.Store(AccessBuilder::ForContextSlot(Context::EXTENSION_INDEX), input);
     a.Store(AccessBuilder::ForContextSlot(Context::GLOBAL_OBJECT_INDEX), load);
-    // TODO(mstarzinger): We could mutate {node} into the allocation instead.
-    NodeProperties::SetType(a.allocation(), NodeProperties::GetType(node));
-    ReplaceWithValue(node, node, a.effect());
-    node->ReplaceInput(0, a.allocation());
-    node->ReplaceInput(1, a.effect());
-    node->TrimInputCount(2);
-    NodeProperties::ChangeOp(node, common()->Finish(1));
+    RelaxControls(node);
+    a.Finish(node);
     return Changed(node);
   }
 
   return NoChange();
 }
 
 
 Reduction JSTypedLowering::ReduceJSCreateBlockContext(Node* node) {
   DCHECK_EQ(IrOpcode::kJSCreateBlockContext, node->opcode());
   Handle<ScopeInfo> scope_info = OpParameter<Handle<ScopeInfo>>(node);
@@ skipping 14 matching lines @@
     AllocationBuilder a(jsgraph(), simplified(), effect, control);
     STATIC_ASSERT(Context::MIN_CONTEXT_SLOTS == 4);  // Ensure fully covered.
     a.AllocateArray(context_length, factory()->block_context_map());
     a.Store(AccessBuilder::ForContextSlot(Context::CLOSURE_INDEX), closure);
     a.Store(AccessBuilder::ForContextSlot(Context::PREVIOUS_INDEX), context);
     a.Store(AccessBuilder::ForContextSlot(Context::EXTENSION_INDEX), extension);
     a.Store(AccessBuilder::ForContextSlot(Context::GLOBAL_OBJECT_INDEX), load);
     for (int i = Context::MIN_CONTEXT_SLOTS; i < context_length; ++i) {
       a.Store(AccessBuilder::ForContextSlot(i), jsgraph()->TheHoleConstant());
     }
-    // TODO(mstarzinger): We could mutate {node} into the allocation instead.
-    NodeProperties::SetType(a.allocation(), NodeProperties::GetType(node));
-    ReplaceWithValue(node, node, a.effect());
-    node->ReplaceInput(0, a.allocation());
-    node->ReplaceInput(1, a.effect());
-    node->TrimInputCount(2);
-    NodeProperties::ChangeOp(node, common()->Finish(1));
+    RelaxControls(node);
+    a.Finish(node);
     return Changed(node);
   }
 
   return NoChange();
 }
 
 
 Reduction JSTypedLowering::ReduceJSCallFunction(Node* node) {
   DCHECK_EQ(IrOpcode::kJSCallFunction, node->opcode());
   CallFunctionParameters const& p = CallFunctionParametersOf(node->op());
@@ skipping 444 matching lines @@
 }
 
 
 MachineOperatorBuilder* JSTypedLowering::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8