[turbofan] Remove dead code from representation changer.

src/compiler/representation-change.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/representation-change.h"
 
 #include <sstream>
 
 #include "src/base/bits.h"
 #include "src/code-factory.h"
@@ skipping 524 matching lines @@
     CHECK(!output_type->IsInhabited());
     return jsgraph()->graph()->NewNode(machine()->ImpossibleToFloat64(), node);
   } else if (output_rep == MachineRepresentation::kBit) {
     return node;  // Sloppy comparison -> word64
   }
   // Can't really convert Word64 to anything else. Purported to be internal.
   return TypeError(node, output_rep, output_type,
                    MachineRepresentation::kWord64);
 }
 
-Node* RepresentationChanger::GetCheckedWord32RepresentationFor(
-    Node* node, MachineRepresentation output_rep, Type* output_type,
-    Node* use_node, Truncation truncation, TypeCheckKind check) {
-  // TODO(jarin) Eagerly fold constants (or insert hard deopt if the constant
-  // does not pass the check).
-
-  // If the input is already Signed32 in Word32 representation, we do not
-  // have to do anything. (We could fold this into the big if below, but
-  // it feels nicer to have the shortcut return first).
-  if (output_rep == MachineRepresentation::kWord32 ||
-      output_type->Is(Type::Signed32())) {
-    return node;
-  }
-
-  // Select the correct X -> Word32 operator.
-  const Operator* op = nullptr;
-  if (output_rep == MachineRepresentation::kNone) {
-    // We should only use kNone representation if the type is empty.
-    CHECK(!output_type->IsInhabited());
-    op = machine()->ImpossibleToWord32();
-  } else if (output_rep == MachineRepresentation::kWord32) {
-    if (output_type->Is(Type::Unsigned32())) {
-      op = simplified()->CheckedUint32ToInt32();
-    }
-  } else if (output_rep == MachineRepresentation::kBit) {
-    return node;  // Sloppy comparison -> word32
-  } else if (output_rep == MachineRepresentation::kFloat64) {
-    if (output_type->Is(Type::Unsigned32())) {
-      op = machine()->ChangeFloat64ToUint32();
-    } else if (output_type->Is(Type::Signed32())) {
-      op = machine()->ChangeFloat64ToInt32();
-    } else if (truncation.IsUsedAsWord32()) {
-      op = machine()->TruncateFloat64ToWord32();
-    } else if (check == TypeCheckKind::kSigned32) {
-      op = simplified()->CheckedFloat64ToInt32();
-    }
-  } else if (output_rep == MachineRepresentation::kFloat32) {
-    node = InsertChangeFloat32ToFloat64(node);  // float32 -> float64 -> int32
-    if (output_type->Is(Type::Unsigned32())) {
-      op = machine()->ChangeFloat64ToUint32();
-    } else if (output_type->Is(Type::Signed32())) {
-      op = machine()->ChangeFloat64ToInt32();
-    } else if (truncation.IsUsedAsWord32()) {
-      op = machine()->TruncateFloat64ToWord32();
-    } else if (check == TypeCheckKind::kSigned32) {
-      op = simplified()->CheckedFloat64ToInt32();
-    }
-  } else if (output_rep == MachineRepresentation::kTagged) {
-    if (output_type->Is(Type::TaggedSigned())) {
-      op = simplified()->ChangeTaggedSignedToInt32();
-    } else if (output_type->Is(Type::Unsigned32())) {
-      op = simplified()->ChangeTaggedToUint32();
-    } else if (output_type->Is(Type::Signed32())) {
-      op = simplified()->ChangeTaggedToInt32();
-    } else if (truncation.IsUsedAsWord32()) {
-      op = simplified()->TruncateTaggedToWord32();
-    } else if (check == TypeCheckKind::kSigned32) {
-      op = simplified()->CheckedTaggedToInt32();
-    }
-  }
-  if (op == nullptr) {
-    return TypeError(node, output_rep, output_type,
-                     MachineRepresentation::kWord32);
-  }
-  if (op->ControlInputCount() > 0) {
-    // If the operator can deoptimize (which means it has control
-    // input), we need to connect it to the effect and control chains.
-    UNIMPLEMENTED();
-  }
-  return jsgraph()->graph()->NewNode(op, node);
-}
-
 const Operator* RepresentationChanger::Int32OperatorFor(
     IrOpcode::Value opcode) {
   switch (opcode) {
     case IrOpcode::kSpeculativeNumberAdd:  // Fall through.
     case IrOpcode::kNumberAdd:
       return machine()->Int32Add();
     case IrOpcode::kSpeculativeNumberSubtract:  // Fall through.
     case IrOpcode::kNumberSubtract:
       return machine()->Int32Sub();
     case IrOpcode::kSpeculativeNumberMultiply:
@@ skipping 221 matching lines @@
 }
 
 Node* RepresentationChanger::InsertChangeTaggedToFloat64(Node* node) {
   return jsgraph()->graph()->NewNode(simplified()->ChangeTaggedToFloat64(),
                                      node);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8