[turbofan] Disallow typing for change/checked operators.

src/compiler/simplified-operator-reducer.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/simplified-operator-reducer.h"
 
 #include "src/compiler/js-graph.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/operator-properties.h"
@@ skipping 16 matching lines @@
   if (m.IsChangeBitToTagged()) return Decision::kFalse;
   if (m.IsChangeInt31ToTaggedSigned()) return Decision::kTrue;
   if (m.IsHeapConstant()) return Decision::kFalse;
   return Decision::kUnknown;
 }
 
 }  // namespace
 
 SimplifiedOperatorReducer::SimplifiedOperatorReducer(Editor* editor,
                                                      JSGraph* jsgraph)
-    : AdvancedReducer(editor),
-      jsgraph_(jsgraph),
-      type_cache_(TypeCache::Get()) {}
+    : AdvancedReducer(editor), jsgraph_(jsgraph) {}
 
 SimplifiedOperatorReducer::~SimplifiedOperatorReducer() {}
 
 
 Reduction SimplifiedOperatorReducer::Reduce(Node* node) {
   switch (node->opcode()) {
     case IrOpcode::kBooleanNot: {
       HeapObjectMatcher m(node->InputAt(0));
       if (m.HasValue()) {
         return Replace(jsgraph()->BooleanConstant(!m.Value()->BooleanValue()));
@@ skipping 105 matching lines @@
         case Decision::kUnknown:
           break;
       }
       break;
     }
     case IrOpcode::kNumberAbs: {
       NumberMatcher m(node->InputAt(0));
       if (m.HasValue()) return ReplaceNumber(std::fabs(m.Value()));
       break;
     }
-    case IrOpcode::kNumberCeil:
-    case IrOpcode::kNumberFloor:
-    case IrOpcode::kNumberRound:
-    case IrOpcode::kNumberTrunc: {
-      Node* const input = NodeProperties::GetValueInput(node, 0);
-      Type* const input_type = NodeProperties::GetType(input);
-      if (input_type->Is(type_cache_.kIntegerOrMinusZeroOrNaN)) {
-        return Replace(input);
-      }
+    case IrOpcode::kReferenceEqual: {
+      HeapObjectBinopMatcher m(node);
+      if (m.left().node() == m.right().node()) return ReplaceBoolean(true);
       break;
     }
-    case IrOpcode::kReferenceEqual:
-      return ReduceReferenceEqual(node);
     default:
       break;
   }
   return NoChange();
 }
 
-Reduction SimplifiedOperatorReducer::ReduceReferenceEqual(Node* node) {
-  DCHECK_EQ(IrOpcode::kReferenceEqual, node->opcode());
-  Node* const left = NodeProperties::GetValueInput(node, 0);
-  Node* const right = NodeProperties::GetValueInput(node, 1);
-  HeapObjectMatcher match_left(left);
-  HeapObjectMatcher match_right(right);
-  if (match_left.HasValue() && match_right.HasValue()) {
-    if (match_left.Value().is_identical_to(match_right.Value())) {
-      return Replace(jsgraph()->TrueConstant());
-    } else {
-      return Replace(jsgraph()->FalseConstant());
-    }
-  }
-  return NoChange();
-}
-
 Reduction SimplifiedOperatorReducer::Change(Node* node, const Operator* op,
                                             Node* a) {
   DCHECK_EQ(node->InputCount(), OperatorProperties::GetTotalInputCount(op));
   DCHECK_LE(1, node->InputCount());
   node->ReplaceInput(0, a);
   NodeProperties::ChangeOp(node, op);
   return Changed(node);
 }
 
 Reduction SimplifiedOperatorReducer::ReplaceBoolean(bool value) {
@@ skipping 23 matching lines @@
 Graph* SimplifiedOperatorReducer::graph() const { return jsgraph()->graph(); }
 
 
 MachineOperatorBuilder* SimplifiedOperatorReducer::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8