[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 328 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 = graph()->NewNode(simplified()->ObjectIsSmi(), value);
+  Node* check = 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 =
-      graph()->NewNode(simplified()->ChangeTaggedSignedToInt32(), value);
+  Node* vtrue = ChangeSmiToInt32(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 = graph()->NewNode(simplified()->ObjectIsSmi(), value);
+  Node* check = 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 =
-      graph()->NewNode(simplified()->ChangeTaggedSignedToInt32(), value);
+  Node* vtrue = ChangeSmiToInt32(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 = graph()->NewNode(simplified()->ObjectIsSmi(), value);
+  Node* check = 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 = graph()->NewNode(simplified()->ChangeTaggedSignedToInt32(), value);
+    vtrue = ChangeSmiToInt32(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 = graph()->NewNode(simplified()->ObjectIsSmi(), value);
+  Node* check = 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 =
-      graph()->NewNode(simplified()->ChangeTaggedSignedToInt32(), value);
+  Node* vtrue = ChangeSmiToInt32(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 = graph()->NewNode(simplified()->ObjectIsSmi(), value);
+  Node* check = 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 = graph()->NewNode(simplified()->ObjectIsSmi(), value);
+  Node* check = 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 = graph()->NewNode(simplified()->ObjectIsSmi(), value);
+  Node* check = 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 = graph()->NewNode(simplified()->ObjectIsSmi(), value);
+  Node* check = 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 = graph()->NewNode(simplified()->ObjectIsSmi(), value);
+  Node* check = 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 54 matching lines @@
 }
 
 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