[turbofan] Unify frame state inputs.

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/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/operator-properties.h"
@@ skipping 193 matching lines @@
     // Avoid introducing too many eager ToString() operations.
     Reduction reduced = lowering_->ReduceJSToStringInput(node);
     if (reduced.Changed()) return reduced.replacement();
     Node* n = graph()->NewNode(javascript()->ToString(), node, context(),
                                effect(), control());
     update_effect(n);
     return n;
   }
 
   Node* CreateFrameStateForLeftInput(Node* frame_state) {
-    if (!FLAG_turbo_deoptimization) return nullptr;
+    // TODO(bmeurer): if (!FLAG_turbo_deoptimization) return nullptr;

[Jarin, 2015/04/23 08:33:08]

Remove the TODO and perhaps consider short-circuiting for BailoutId::None (just
like the CreateFrameStateForRightInput method).

[Benedikt Meurer, 2015/04/23 08:35:34]

Done.

 
     FrameStateCallInfo state_info =
         OpParameter<FrameStateCallInfo>(frame_state);
     // If the frame state is already the right one, just return it.
     if (state_info.state_combine().kind() == OutputFrameStateCombine::kPokeAt &&
         state_info.state_combine().GetOffsetToPokeAt() == 1) {
       return frame_state;
     }
 
     // Here, we smash the result of the conversion into the slot just below
     // the stack top. This is the slot that full code uses to store the
     // left operand.
     const Operator* op = jsgraph()->common()->FrameState(
         state_info.type(), state_info.bailout_id(),
         OutputFrameStateCombine::PokeAt(1));
 
     return graph()->NewNode(op, frame_state->InputAt(0),
                             frame_state->InputAt(1), frame_state->InputAt(2),
                             frame_state->InputAt(3), frame_state->InputAt(4));
   }
 
   Node* CreateFrameStateForRightInput(Node* frame_state, Node* converted_left) {
-    if (!FLAG_turbo_deoptimization) return nullptr;
+    // TODO(bmeurer): if (!FLAG_turbo_deoptimization) return nullptr;

[Jarin, 2015/04/23 08:33:08]

Remove the TODO.

[Benedikt Meurer, 2015/04/23 08:35:35]

Done.

 
     FrameStateCallInfo state_info =
         OpParameter<FrameStateCallInfo>(frame_state);
 
     if (state_info.bailout_id() == BailoutId::None()) {
       // Dummy frame state => just leave it as is.
       return frame_state;
     }
 
     // Create a frame state that stores the result of the operation to the
@@ skipping 24 matching lines @@
                             frame_state->InputAt(3), frame_state->InputAt(4));
   }
 
   Node* ConvertPrimitiveToNumber(Node* node) {
     return lowering_->ConvertPrimitiveToNumber(node);
   }
 
   Node* ConvertToNumber(Node* node, Node* frame_state) {
     if (NodeProperties::GetBounds(node).upper->Is(Type::PlainPrimitive())) {
       return ConvertPrimitiveToNumber(node);
-    } else if (!FLAG_turbo_deoptimization) {
-      // We cannot use ConvertToPrimitiveNumber here because we need context
-      // for converting general values.
-      Node* const n = graph()->NewNode(javascript()->ToNumber(), node,
-                                       context(), effect(), control());
-      update_effect(n);
-      return n;
     } else {
       Node* const n =
           graph()->NewNode(javascript()->ToNumber(), node, context(),
                            frame_state, effect(), control());
       update_effect(n);
       return n;
     }
   }
 
   Node* ConvertToUI32(Node* node, Signedness signedness) {
@@ skipping 19 matching lines @@
 
 
 Reduction JSTypedLowering::ReduceJSAdd(Node* node) {
   JSBinopReduction r(this, node);
   if (r.BothInputsAre(Type::Number())) {
     // JSAdd(x:number, y:number) => NumberAdd(x, y)
     return r.ChangeToPureOperator(simplified()->NumberAdd(), Type::Number());
   }
   if (r.NeitherInputCanBe(Type::StringOrReceiver())) {
     // JSAdd(x:-string, y:-string) => NumberAdd(ToNumber(x), ToNumber(y))
-    Node* frame_state = FLAG_turbo_deoptimization
-                            ? NodeProperties::GetFrameStateInput(node, 1)
-                            : nullptr;
+    Node* frame_state = NodeProperties::GetFrameStateInput(node, 1);
     r.ConvertInputsToNumber(frame_state);
     return r.ChangeToPureOperator(simplified()->NumberAdd(), Type::Number());
   }
 #if 0
   // TODO(turbofan): Lowering of StringAdd is disabled for now because:
   //   a) The inserted ToString operation screws up valueOf vs. toString order.
   //   b) Deoptimization at ToString doesn't have corresponding bailout id.
   //   c) Our current StringAddStub is actually non-pure and requires context.
   if (r.OneInputIs(Type::String())) {
     // JSAdd(x:string, y:string) => StringAdd(x, y)
     // JSAdd(x:string, y) => StringAdd(x, ToString(y))
     // JSAdd(x, y:string) => StringAdd(ToString(x), y)
     r.ConvertInputsToString();
     return r.ChangeToPureOperator(simplified()->StringAdd());
   }
 #endif
   return NoChange();
 }
 
 
 Reduction JSTypedLowering::ReduceNumberBinop(Node* node,
                                              const Operator* numberOp) {
   JSBinopReduction r(this, node);
-  Node* frame_state = FLAG_turbo_deoptimization
-                          ? NodeProperties::GetFrameStateInput(node, 1)
-                          : nullptr;
+  Node* frame_state = NodeProperties::GetFrameStateInput(node, 1);
   r.ConvertInputsToNumber(frame_state);
   return r.ChangeToPureOperator(numberOp, Type::Number());
 }
 
 
 Reduction JSTypedLowering::ReduceInt32Binop(Node* node, const Operator* intOp) {
   JSBinopReduction r(this, node);
-  Node* frame_state = FLAG_turbo_deoptimization
-                          ? NodeProperties::GetFrameStateInput(node, 1)
-                          : nullptr;
+  Node* frame_state = NodeProperties::GetFrameStateInput(node, 1);
   r.ConvertInputsToNumber(frame_state);
   r.ConvertInputsToUI32(kSigned, kSigned);
   return r.ChangeToPureOperator(intOp, Type::Integral32());
 }
 
 
 Reduction JSTypedLowering::ReduceUI32Shift(Node* node,
                                            Signedness left_signedness,
                                            const Operator* shift_op) {
   JSBinopReduction r(this, node);
@@ skipping 316 matching lines @@
     if (NodeProperties::GetContextInput(node) !=
             jsgraph()->NoContextConstant() ||
         NodeProperties::GetEffectInput(node) != graph()->start() ||
         NodeProperties::GetControlInput(node) != graph()->start()) {
       // JSToNumber(x:plain-primitive,context,effect,control)
       //   => JSToNumber(x,no-context,start,start)
       RelaxEffectsAndControls(node);
       NodeProperties::ReplaceContextInput(node, jsgraph()->NoContextConstant());
       NodeProperties::ReplaceControlInput(node, graph()->start());
       NodeProperties::ReplaceEffectInput(node, graph()->start());
-      if (FLAG_turbo_deoptimization) {
-        DCHECK_EQ(1, OperatorProperties::GetFrameStateInputCount(node->op()));
-        NodeProperties::ReplaceFrameStateInput(node, 0,
-                                               jsgraph()->EmptyFrameState());
-      }
+      DCHECK_EQ(1, OperatorProperties::GetFrameStateInputCount(node->op()));
+      NodeProperties::ReplaceFrameStateInput(node, 0,
+                                             jsgraph()->EmptyFrameState());
       return Changed(node);
     }
   }
   return NoChange();
 }
 
 
 Reduction JSTypedLowering::ReduceJSToStringInput(Node* input) {
   if (input->opcode() == IrOpcode::kJSToString) {
     // Recursively try to reduce the input first.
@@ skipping 116 matching lines @@
       Node* length = jsgraph()->Constant(byte_length);
       Node* context = NodeProperties::GetContextInput(node);
       Node* effect = NodeProperties::GetEffectInput(node);
       Node* control = NodeProperties::GetControlInput(node);
       // Convert to a number first.
       if (!value_type->Is(Type::Number())) {
         Reduction number_reduction = ReduceJSToNumberInput(value);
         if (number_reduction.Changed()) {
           value = number_reduction.replacement();
         } else {
-          DCHECK(FLAG_turbo_deoptimization ==
-                 (OperatorProperties::GetFrameStateInputCount(
-                      javascript()->ToNumber()) == 1));
-          if (FLAG_turbo_deoptimization) {
-            Node* frame_state_for_to_number =
-                NodeProperties::GetFrameStateInput(node, 1);
-            value = effect =
-                graph()->NewNode(javascript()->ToNumber(), value, context,
-                                 frame_state_for_to_number, effect, control);
-          } else {
-            value = effect = graph()->NewNode(javascript()->ToNumber(), value,
-                                              context, effect, control);
-          }
+          Node* frame_state_for_to_number =
+              NodeProperties::GetFrameStateInput(node, 1);
+          value = effect =
+              graph()->NewNode(javascript()->ToNumber(), value, context,
+                               frame_state_for_to_number, effect, control);
         }
       }
       // For integer-typed arrays, convert to the integer type.
       if (TypeOf(access.machine_type()) == kTypeInt32 &&
           !value_type->Is(Type::Signed32())) {
         value = graph()->NewNode(simplified()->NumberToInt32(), value);
       } else if (TypeOf(access.machine_type()) == kTypeUint32 &&
                  !value_type->Is(Type::Unsigned32())) {
         value = graph()->NewNode(simplified()->NumberToUint32(), value);
       }
@@ skipping 162 matching lines @@
   return NoChange();
 }
 
 
 Node* JSTypedLowering::ConvertPrimitiveToNumber(Node* input) {
   DCHECK(NodeProperties::GetBounds(input).upper->Is(Type::PlainPrimitive()));
   // Avoid inserting too many eager ToNumber() operations.
   Reduction const reduction = ReduceJSToNumberInput(input);
   if (reduction.Changed()) return reduction.replacement();
   // TODO(jarin) Use PlainPrimitiveToNumber once we have it.
-  Node* const conversion =
-      FLAG_turbo_deoptimization
-          ? graph()->NewNode(javascript()->ToNumber(), input,
-                             jsgraph()->NoContextConstant(),
-                             jsgraph()->EmptyFrameState(), graph()->start(),
-                             graph()->start())
-          : graph()->NewNode(javascript()->ToNumber(), input,
-                             jsgraph()->NoContextConstant(), graph()->start(),
-                             graph()->start());
+  Node* const conversion = graph()->NewNode(
+      javascript()->ToNumber(), input, jsgraph()->NoContextConstant(),
+      jsgraph()->EmptyFrameState(), graph()->start(), graph()->start());
   InsertConversion(conversion);
   return conversion;
 }
 
 
 template <IrOpcode::Value kOpcode>
 Node* JSTypedLowering::FindConversion(Node* input) {
   size_t const input_id = input->id();
   if (input_id < conversions_.size()) {
     Node* const conversion = conversions_[input_id];
@@ skipping 38 matching lines @@
 }
 
 
 MachineOperatorBuilder* JSTypedLowering::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8