[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 19 matching lines @@
   }
 }
 
 
 // A helper class to construct inline allocations on the simplified operator
 // level. This keeps track of the effect chain for initial stores on a newly
 // allocated object and also provides helpers for commonly allocated objects.
 class AllocationBuilder final {
  public:
   AllocationBuilder(JSGraph* jsgraph, SimplifiedOperatorBuilder* simplified,
-                    Node* effect, Node* control)
+                    Node* node, Node* effect, Node* control)
       : jsgraph_(jsgraph),
         simplified_(simplified),
         allocation_(nullptr),
+        node_(node),
         effect_(effect),
         control_(control) {}
 
+  ~AllocationBuilder() {
+    // Make sure we are finished.
+    DCHECK_EQ(IrOpcode::kFinishRegion, node_->opcode());
+  }
+
   // 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() {

[Benedikt Meurer, 2015/10/13 19:12:09]

Nit: I think this helper should return the Reduction (always Changed(node) for
now) to make it explicit that it does mutate the graph.

Also I'm not convinced that this helper improves the readability of the code
below. I think I'd be fine with this, but Michi should have a look as well.

[Jarin, 2015/10/14 06:37:20]

Ack. I will leave the decision to Michi, I do not have a strong preference here.
For now, I changed the Finish method to take the node (and removed the node from
the constructor).

+    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_;
+  Node* node_;
   Node* effect_;
   Node* control_;
 };
 
 
 // A helper class to simplify the process of reducing a single binop node with a
 // JSOperator. This class manages the rewriting of context, control, and effect
 // dependencies during lowering of a binop and contains numerous helper
 // functions for matching the types of inputs to an operation.
 class JSBinopReduction final {
@@ skipping 1161 matching lines @@
     // JSCreateFunctionContext[slot_count < limit]](fun)
     Node* const effect = NodeProperties::GetEffectInput(node);
     Node* const control = NodeProperties::GetControlInput(node);
     Node* const closure = NodeProperties::GetValueInput(node, 0);
     Node* const context = NodeProperties::GetContextInput(node);
     Node* const extension = jsgraph()->ZeroConstant();
     Node* const load = graph()->NewNode(
         simplified()->LoadField(
             AccessBuilder::ForContextSlot(Context::GLOBAL_OBJECT_INDEX)),
         context, effect, control);
-    AllocationBuilder a(jsgraph(), simplified(), effect, control);
+    RelaxControls(node);
+    AllocationBuilder a(jsgraph(), simplified(), node, effect, control);
     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));
+    a.Finish();
     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 17 matching lines @@
   if (FLAG_turbo_allocate && input_type->Is(Type::Receiver())) {
     // JSCreateWithContext(o:receiver, fun)
     Node* const effect = NodeProperties::GetEffectInput(node);
     Node* const control = NodeProperties::GetControlInput(node);
     Node* const closure = NodeProperties::GetValueInput(node, 1);
     Node* const context = NodeProperties::GetContextInput(node);
     Node* const load = graph()->NewNode(
         simplified()->LoadField(
             AccessBuilder::ForContextSlot(Context::GLOBAL_OBJECT_INDEX)),
         context, effect, control);
-    AllocationBuilder a(jsgraph(), simplified(), effect, control);
+    RelaxControls(node);
+    AllocationBuilder a(jsgraph(), simplified(), node, 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));
+    a.Finish();
     return Changed(node);
   }
 
   return NoChange();
 }
 
 
 Reduction JSTypedLowering::ReduceJSCreateBlockContext(Node* node) {
   DCHECK_EQ(IrOpcode::kJSCreateBlockContext, node->opcode());
   Handle<ScopeInfo> scope_info = OpParameter<Handle<ScopeInfo>>(node);
   int context_length = scope_info->ContextLength();
 
   // Use inline allocation for block contexts up to a size limit.
   if (FLAG_turbo_allocate && context_length < kBlockContextAllocationLimit) {
     // JSCreateBlockContext[scope[length < limit]](fun)
     Node* const effect = NodeProperties::GetEffectInput(node);
     Node* const control = NodeProperties::GetControlInput(node);
     Node* const closure = NodeProperties::GetValueInput(node, 1);
     Node* const context = NodeProperties::GetContextInput(node);
     Node* const extension = jsgraph()->Constant(scope_info);
     Node* const load = graph()->NewNode(
         simplified()->LoadField(
             AccessBuilder::ForContextSlot(Context::GLOBAL_OBJECT_INDEX)),
         context, effect, control);
-    AllocationBuilder a(jsgraph(), simplified(), effect, control);
+    RelaxControls(node);
+    AllocationBuilder a(jsgraph(), simplified(), node, 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));
+    a.Finish();
     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