Revert of [turbofan] Remove left-over change bits from ChangeLowering.

src/compiler/effect-control-linearizer.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/compiler/effect-control-linearizer.h"
 
 #include "src/code-factory.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/linkage.h"
@@ skipping 272 matching lines @@
   if (TryWireInStateEffect(node, effect, control)) {
     return;
   }
 
   // Remove the end markers of 'atomic' allocation region because the
   // region should be wired-in now.
   if (node->opcode() == IrOpcode::kFinishRegion ||
       node->opcode() == IrOpcode::kBeginRegion) {
     // Update the value uses to the value input of the finish node and
     // the effect uses to the effect input.
-    return RemoveRegionNode(node);
+
+    // TODO(jarin) Enable this once we make sure everything with side effects
+    // is marked as effectful.
+    if (false) {
+      return RemoveRegionNode(node);
+    }
   }
 
   if (node->opcode() == IrOpcode::kIfSuccess) {
     // We always schedule IfSuccess with its call, so skip it here.
     DCHECK_EQ(IrOpcode::kCall, node->InputAt(0)->opcode());
     // The IfSuccess node should not belong to an exceptional call node
     // because such IfSuccess nodes should only start a basic block (and
     // basic block start nodes are not handled in the ProcessNode method).
     DCHECK(!NodeProperties::IsExceptionalCall(node->InputAt(0)));
     return;
@@ skipping 30 matching lines @@
       // Schedule the call's IfSuccess node (if there is no exception use).
       TryScheduleCallIfSuccess(node, control);
     }
   }
 }
 
 bool EffectControlLinearizer::TryWireInStateEffect(Node* node, Node** effect,
                                                    Node** control) {
   ValueEffectControl state(nullptr, nullptr, nullptr);
   switch (node->opcode()) {
-    case IrOpcode::kChangeBitToTagged:
-      state = LowerChangeBitToTagged(node, *effect, *control);
-      break;
-    case IrOpcode::kChangeInt31ToTaggedSigned:
-      state = LowerChangeInt31ToTaggedSigned(node, *effect, *control);
-      break;
     case IrOpcode::kChangeInt32ToTagged:
       state = LowerChangeInt32ToTagged(node, *effect, *control);
       break;
     case IrOpcode::kChangeUint32ToTagged:
       state = LowerChangeUint32ToTagged(node, *effect, *control);
       break;
     case IrOpcode::kChangeFloat64ToTagged:
       state = LowerChangeFloat64ToTagged(node, *effect, *control);
       break;
-    case IrOpcode::kChangeTaggedSignedToInt32:
-      state = LowerChangeTaggedSignedToInt32(node, *effect, *control);
-      break;
-    case IrOpcode::kChangeTaggedToBit:
-      state = LowerChangeTaggedToBit(node, *effect, *control);
-      break;
     case IrOpcode::kChangeTaggedToInt32:
       state = LowerChangeTaggedToInt32(node, *effect, *control);
       break;
     case IrOpcode::kChangeTaggedToUint32:
       state = LowerChangeTaggedToUint32(node, *effect, *control);
       break;
     case IrOpcode::kChangeTaggedToFloat64:
       state = LowerChangeTaggedToFloat64(node, *effect, *control);
       break;
     case IrOpcode::kTruncateTaggedToWord32:
       state = LowerTruncateTaggedToWord32(node, *effect, *control);
       break;
     case IrOpcode::kObjectIsCallable:
       state = LowerObjectIsCallable(node, *effect, *control);
       break;
     case IrOpcode::kObjectIsNumber:
       state = LowerObjectIsNumber(node, *effect, *control);
       break;
     case IrOpcode::kObjectIsReceiver:
       state = LowerObjectIsReceiver(node, *effect, *control);
       break;
-    case IrOpcode::kObjectIsSmi:
-      state = LowerObjectIsSmi(node, *effect, *control);
-      break;
     case IrOpcode::kObjectIsString:
       state = LowerObjectIsString(node, *effect, *control);
       break;
     case IrOpcode::kObjectIsUndetectable:
       state = LowerObjectIsUndetectable(node, *effect, *control);
       break;
     default:
       return false;
   }
   NodeProperties::ReplaceUses(node, state.value);
@@ skipping 65 matching lines @@
 
   control = graph()->NewNode(common()->Merge(2), if_smi, box.control);
   value = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
                            vsmi, box.value, control);
   effect =
       graph()->NewNode(common()->EffectPhi(2), effect, box.effect, control);
   return ValueEffectControl(value, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
-EffectControlLinearizer::LowerChangeBitToTagged(Node* node, Node* effect,
-                                                Node* control) {
-  Node* value = node->InputAt(0);
-
-  Node* branch = graph()->NewNode(common()->Branch(), value, control);
-
-  Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
-  Node* vtrue = jsgraph()->TrueConstant();
-
-  Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
-  Node* vfalse = jsgraph()->FalseConstant();
-
-  control = graph()->NewNode(common()->Merge(2), if_true, if_false);
-  value = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
-                           vtrue, vfalse, control);
-
-  return ValueEffectControl(value, effect, control);
-}
-
-EffectControlLinearizer::ValueEffectControl
-EffectControlLinearizer::LowerChangeInt31ToTaggedSigned(Node* node,
-                                                        Node* effect,
-                                                        Node* control) {
-  Node* value = node->InputAt(0);
-  value = ChangeInt32ToSmi(value);
-  return ValueEffectControl(value, effect, control);
-}
-
-EffectControlLinearizer::ValueEffectControl
 EffectControlLinearizer::LowerChangeInt32ToTagged(Node* node, Node* effect,
                                                   Node* control) {
   Node* value = node->InputAt(0);
 
   if (machine()->Is64()) {
     return ValueEffectControl(ChangeInt32ToSmi(value), effect, control);
   }
 
   Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(), value, value);
 
@@ skipping 37 matching lines @@
   Node* merge = graph()->NewNode(common()->Merge(2), if_true, alloc.control);
   Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
                                vtrue, alloc.value, merge);
   Node* ephi =
       graph()->NewNode(common()->EffectPhi(2), effect, alloc.effect, merge);
 
   return ValueEffectControl(phi, ephi, merge);
 }
 
 EffectControlLinearizer::ValueEffectControl
-EffectControlLinearizer::LowerChangeTaggedSignedToInt32(Node* node,
-                                                        Node* effect,
-                                                        Node* control) {
-  Node* value = node->InputAt(0);
-  value = ChangeSmiToInt32(value);
-  return ValueEffectControl(value, effect, control);
-}
-
-EffectControlLinearizer::ValueEffectControl
-EffectControlLinearizer::LowerChangeTaggedToBit(Node* node, Node* effect,
-                                                Node* control) {
-  Node* value = node->InputAt(0);
-  value = graph()->NewNode(machine()->WordEqual(), value,
-                           jsgraph()->TrueConstant());
-  return ValueEffectControl(value, effect, control);
-}
-
-EffectControlLinearizer::ValueEffectControl
 EffectControlLinearizer::LowerChangeTaggedToInt32(Node* node, Node* effect,
                                                   Node* control) {
   Node* value = node->InputAt(0);
 
-  Node* check = ObjectIsSmi(value);
+  Node* check = graph()->NewNode(simplified()->ObjectIsSmi(), value);
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kTrue), check, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* etrue = effect;
-  Node* vtrue = ChangeSmiToInt32(value);
+  Node* vtrue =
+      graph()->NewNode(simplified()->ChangeTaggedSignedToInt32(), value);
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* efalse = effect;
   Node* vfalse;
   {
     STATIC_ASSERT(HeapNumber::kValueOffset == Oddball::kToNumberRawOffset);
     vfalse = efalse = graph()->NewNode(
         simplified()->LoadField(AccessBuilder::ForHeapNumberValue()), value,
         efalse, if_false);
     vfalse = graph()->NewNode(machine()->ChangeFloat64ToInt32(), vfalse);
   }
 
   control = graph()->NewNode(common()->Merge(2), if_true, if_false);
   effect = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, control);
   value = graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 2),
                            vtrue, vfalse, control);
 
   return ValueEffectControl(value, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
 EffectControlLinearizer::LowerChangeTaggedToUint32(Node* node, Node* effect,
                                                    Node* control) {
   Node* value = node->InputAt(0);
 
-  Node* check = ObjectIsSmi(value);
+  Node* check = graph()->NewNode(simplified()->ObjectIsSmi(), value);
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kTrue), check, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* etrue = effect;
-  Node* vtrue = ChangeSmiToInt32(value);
+  Node* vtrue =
+      graph()->NewNode(simplified()->ChangeTaggedSignedToInt32(), value);
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* efalse = effect;
   Node* vfalse;
   {
     STATIC_ASSERT(HeapNumber::kValueOffset == Oddball::kToNumberRawOffset);
     vfalse = efalse = graph()->NewNode(
         simplified()->LoadField(AccessBuilder::ForHeapNumberValue()), value,
         efalse, if_false);
     vfalse = graph()->NewNode(machine()->ChangeFloat64ToUint32(), vfalse);
   }
 
   control = graph()->NewNode(common()->Merge(2), if_true, if_false);
   effect = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, control);
   value = graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 2),
                            vtrue, vfalse, control);
 
   return ValueEffectControl(value, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
 EffectControlLinearizer::LowerChangeTaggedToFloat64(Node* node, Node* effect,
                                                     Node* control) {
   Node* value = node->InputAt(0);
 
-  Node* check = ObjectIsSmi(value);
+  Node* check = graph()->NewNode(simplified()->ObjectIsSmi(), value);
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kTrue), check, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* etrue = effect;
   Node* vtrue;
   {
-    vtrue = ChangeSmiToInt32(value);
+    vtrue = graph()->NewNode(simplified()->ChangeTaggedSignedToInt32(), value);
     vtrue = graph()->NewNode(machine()->ChangeInt32ToFloat64(), vtrue);
   }
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* efalse = effect;
   Node* vfalse;
   {
     STATIC_ASSERT(HeapNumber::kValueOffset == Oddball::kToNumberRawOffset);
     vfalse = efalse = graph()->NewNode(
         simplified()->LoadField(AccessBuilder::ForHeapNumberValue()), value,
         efalse, if_false);
   }
 
   control = graph()->NewNode(common()->Merge(2), if_true, if_false);
   effect = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, control);
   value = graph()->NewNode(common()->Phi(MachineRepresentation::kFloat64, 2),
                            vtrue, vfalse, control);
 
   return ValueEffectControl(value, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
 EffectControlLinearizer::LowerTruncateTaggedToWord32(Node* node, Node* effect,
                                                      Node* control) {
   Node* value = node->InputAt(0);
 
-  Node* check = ObjectIsSmi(value);
+  Node* check = graph()->NewNode(simplified()->ObjectIsSmi(), value);
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kTrue), check, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* etrue = effect;
-  Node* vtrue = ChangeSmiToInt32(value);
+  Node* vtrue =
+      graph()->NewNode(simplified()->ChangeTaggedSignedToInt32(), value);
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* efalse = effect;
   Node* vfalse;
   {
     STATIC_ASSERT(HeapNumber::kValueOffset == Oddball::kToNumberRawOffset);
     vfalse = efalse = graph()->NewNode(
         simplified()->LoadField(AccessBuilder::ForHeapNumberValue()), value,
         efalse, if_false);
     vfalse = graph()->NewNode(machine()->TruncateFloat64ToWord32(), vfalse);
   }
 
   control = graph()->NewNode(common()->Merge(2), if_true, if_false);
   effect = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, control);
   value = graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 2),
                            vtrue, vfalse, control);
 
   return ValueEffectControl(value, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
 EffectControlLinearizer::LowerObjectIsCallable(Node* node, Node* effect,
                                                Node* control) {
   Node* value = node->InputAt(0);
 
-  Node* check = ObjectIsSmi(value);
+  Node* check = graph()->NewNode(simplified()->ObjectIsSmi(), value);
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kFalse), check, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* etrue = effect;
   Node* vtrue = jsgraph()->Int32Constant(0);
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* efalse = effect;
   Node* vfalse;
@@ skipping 19 matching lines @@
                            vfalse, control);
 
   return ValueEffectControl(value, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
 EffectControlLinearizer::LowerObjectIsNumber(Node* node, Node* effect,
                                              Node* control) {
   Node* value = node->InputAt(0);
 
-  Node* check = ObjectIsSmi(value);
+  Node* check = graph()->NewNode(simplified()->ObjectIsSmi(), value);
   Node* branch = graph()->NewNode(common()->Branch(), check, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* etrue = effect;
   Node* vtrue = jsgraph()->Int32Constant(1);
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* efalse = effect;
   Node* vfalse;
   {
@@ skipping 10 matching lines @@
                            vfalse, control);
 
   return ValueEffectControl(value, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
 EffectControlLinearizer::LowerObjectIsReceiver(Node* node, Node* effect,
                                                Node* control) {
   Node* value = node->InputAt(0);
 
-  Node* check = ObjectIsSmi(value);
+  Node* check = graph()->NewNode(simplified()->ObjectIsSmi(), value);
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kFalse), check, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* etrue = effect;
   Node* vtrue = jsgraph()->Int32Constant(0);
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* efalse = effect;
   Node* vfalse;
@@ skipping 12 matching lines @@
 
   control = graph()->NewNode(common()->Merge(2), if_true, if_false);
   effect = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, control);
   value = graph()->NewNode(common()->Phi(MachineRepresentation::kBit, 2), vtrue,
                            vfalse, control);
 
   return ValueEffectControl(value, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
-EffectControlLinearizer::LowerObjectIsSmi(Node* node, Node* effect,
-                                          Node* control) {
-  Node* value = node->InputAt(0);
-  value = ObjectIsSmi(value);
-  return ValueEffectControl(value, effect, control);
-}
-
-EffectControlLinearizer::ValueEffectControl
 EffectControlLinearizer::LowerObjectIsString(Node* node, Node* effect,
                                              Node* control) {
   Node* value = node->InputAt(0);
 
-  Node* check = ObjectIsSmi(value);
+  Node* check = graph()->NewNode(simplified()->ObjectIsSmi(), value);
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kFalse), check, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* etrue = effect;
   Node* vtrue = jsgraph()->Int32Constant(0);
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* efalse = effect;
   Node* vfalse;
@@ skipping 14 matching lines @@
                            vfalse, control);
 
   return ValueEffectControl(value, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
 EffectControlLinearizer::LowerObjectIsUndetectable(Node* node, Node* effect,
                                                    Node* control) {
   Node* value = node->InputAt(0);
 
-  Node* check = ObjectIsSmi(value);
+  Node* check = graph()->NewNode(simplified()->ObjectIsSmi(), value);
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kFalse), check, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* etrue = effect;
   Node* vtrue = jsgraph()->Int32Constant(0);
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* efalse = effect;
   Node* vfalse;
@@ skipping 18 matching lines @@
   effect = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, control);
   value = graph()->NewNode(common()->Phi(MachineRepresentation::kBit, 2), vtrue,
                            vfalse, control);
 
   return ValueEffectControl(value, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
 EffectControlLinearizer::AllocateHeapNumberWithValue(Node* value, Node* effect,
                                                      Node* control) {
+  effect = graph()->NewNode(common()->BeginRegion(), effect);
   Node* result = effect = graph()->NewNode(
       simplified()->Allocate(NOT_TENURED),
       jsgraph()->Int32Constant(HeapNumber::kSize), effect, control);
   effect = graph()->NewNode(simplified()->StoreField(AccessBuilder::ForMap()),
                             result, jsgraph()->HeapNumberMapConstant(), effect,
                             control);
   effect = graph()->NewNode(
       simplified()->StoreField(AccessBuilder::ForHeapNumberValue()), result,
       value, effect, control);
+  result = effect = graph()->NewNode(common()->FinishRegion(), result, effect);
   return ValueEffectControl(result, effect, control);
 }
 
 Node* EffectControlLinearizer::ChangeInt32ToSmi(Node* value) {
   if (machine()->Is64()) {
     value = graph()->NewNode(machine()->ChangeInt32ToInt64(), value);
   }
   return graph()->NewNode(machine()->WordShl(), value, SmiShiftBitsConstant());
 }
 
 Node* EffectControlLinearizer::ChangeUint32ToSmi(Node* value) {
   if (machine()->Is64()) {
     value = graph()->NewNode(machine()->ChangeUint32ToUint64(), value);
   }
   return graph()->NewNode(machine()->WordShl(), value, SmiShiftBitsConstant());
 }
 
 Node* EffectControlLinearizer::ChangeInt32ToFloat64(Node* value) {
   return graph()->NewNode(machine()->ChangeInt32ToFloat64(), value);
 }
 
 Node* EffectControlLinearizer::ChangeUint32ToFloat64(Node* value) {
   return graph()->NewNode(machine()->ChangeUint32ToFloat64(), value);
 }
 
-Node* EffectControlLinearizer::ChangeSmiToInt32(Node* value) {
-  value = graph()->NewNode(machine()->WordSar(), value, SmiShiftBitsConstant());
-  if (machine()->Is64()) {
-    value = graph()->NewNode(machine()->TruncateInt64ToInt32(), value);
-  }
-  return value;
-}
-
-Node* EffectControlLinearizer::ObjectIsSmi(Node* value) {
-  return graph()->NewNode(
-      machine()->WordEqual(),
-      graph()->NewNode(machine()->WordAnd(), value,
-                       jsgraph()->IntPtrConstant(kSmiTagMask)),
-      jsgraph()->IntPtrConstant(kSmiTag));
-}
-
 Node* EffectControlLinearizer::SmiMaxValueConstant() {
   return jsgraph()->Int32Constant(Smi::kMaxValue);
 }
 
 Node* EffectControlLinearizer::SmiShiftBitsConstant() {
   return jsgraph()->IntPtrConstant(kSmiShiftSize + kSmiTagSize);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8