LCOV - code coverage report
Current view: top level - src/compiler - representation-change.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 464 620 74.8 %
Date: 2019-03-21 Functions: 30 36 83.3 %

          Line data    Source code
       1             : // Copyright 2015 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/compiler/representation-change.h"
       6             : 
       7             : #include <sstream>
       8             : 
       9             : #include "src/base/bits.h"
      10             : #include "src/code-factory.h"
      11             : #include "src/compiler/machine-operator.h"
      12             : #include "src/compiler/node-matchers.h"
      13             : #include "src/compiler/type-cache.h"
      14             : #include "src/heap/factory-inl.h"
      15             : 
      16             : namespace v8 {
      17             : namespace internal {
      18             : namespace compiler {
      19             : 
      20           0 : const char* Truncation::description() const {
      21           0 :   switch (kind()) {
      22             :     case TruncationKind::kNone:
      23             :       return "no-value-use";
      24             :     case TruncationKind::kBool:
      25           0 :       return "truncate-to-bool";
      26             :     case TruncationKind::kWord32:
      27           0 :       return "truncate-to-word32";
      28             :     case TruncationKind::kFloat64:
      29           0 :       switch (identify_zeros()) {
      30             :         case kIdentifyZeros:
      31             :           return "truncate-to-float64 (identify zeros)";
      32             :         case kDistinguishZeros:
      33           0 :           return "truncate-to-float64 (distinguish zeros)";
      34             :       }
      35             :     case TruncationKind::kAny:
      36           0 :       switch (identify_zeros()) {
      37             :         case kIdentifyZeros:
      38             :           return "no-truncation (but identify zeros)";
      39             :         case kDistinguishZeros:
      40           0 :           return "no-truncation (but distinguish zeros)";
      41             :       }
      42             :   }
      43           0 :   UNREACHABLE();
      44             : }
      45             : 
      46             : // Partial order for truncations:
      47             : //
      48             : //          kAny <-------+
      49             : //            ^          |
      50             : //            |          |
      51             : //          kFloat64     |
      52             : //          ^            |
      53             : //          /            |
      54             : //   kWord32           kBool
      55             : //         ^            ^
      56             : //         \            /
      57             : //          \          /
      58             : //           \        /
      59             : //            \      /
      60             : //             \    /
      61             : //             kNone
      62             : //
      63             : // TODO(jarin) We might consider making kBool < kFloat64.
      64             : 
      65             : // static
      66   105387536 : Truncation::TruncationKind Truncation::Generalize(TruncationKind rep1,
      67             :                                                   TruncationKind rep2) {
      68   105387536 :   if (LessGeneral(rep1, rep2)) return rep2;
      69    11610585 :   if (LessGeneral(rep2, rep1)) return rep1;
      70             :   // Handle the generalization of float64-representable values.
      71          14 :   if (LessGeneral(rep1, TruncationKind::kFloat64) &&
      72           7 :       LessGeneral(rep2, TruncationKind::kFloat64)) {
      73             :     return TruncationKind::kFloat64;
      74             :   }
      75             :   // Handle the generalization of any-representable values.
      76          14 :   if (LessGeneral(rep1, TruncationKind::kAny) &&
      77           7 :       LessGeneral(rep2, TruncationKind::kAny)) {
      78             :     return TruncationKind::kAny;
      79             :   }
      80             :   // All other combinations are illegal.
      81           0 :   FATAL("Tried to combine incompatible truncations");
      82             :   return TruncationKind::kNone;
      83             : }
      84             : 
      85             : // static
      86   105388108 : IdentifyZeros Truncation::GeneralizeIdentifyZeros(IdentifyZeros i1,
      87             :                                                   IdentifyZeros i2) {
      88   105388108 :   if (i1 == i2) {
      89    74947237 :     return i1;
      90             :   } else {
      91             :     return kDistinguishZeros;
      92             :   }
      93             : }
      94             : 
      95             : // static
      96   119320126 : bool Truncation::LessGeneral(TruncationKind rep1, TruncationKind rep2) {
      97   119320126 :   switch (rep1) {
      98             :     case TruncationKind::kNone:
      99             :       return true;
     100             :     case TruncationKind::kBool:
     101      700587 :       return rep2 == TruncationKind::kBool || rep2 == TruncationKind::kAny;
     102             :     case TruncationKind::kWord32:
     103             :       return rep2 == TruncationKind::kWord32 ||
     104      840763 :              rep2 == TruncationKind::kFloat64 || rep2 == TruncationKind::kAny;
     105             :     case TruncationKind::kFloat64:
     106      588402 :       return rep2 == TruncationKind::kFloat64 || rep2 == TruncationKind::kAny;
     107             :     case TruncationKind::kAny:
     108    63260061 :       return rep2 == TruncationKind::kAny;
     109             :   }
     110           0 :   UNREACHABLE();
     111             : }
     112             : 
     113             : // static
     114           0 : bool Truncation::LessGeneralIdentifyZeros(IdentifyZeros i1, IdentifyZeros i2) {
     115           0 :   return i1 == i2 || i1 == kIdentifyZeros;
     116             : }
     117             : 
     118             : namespace {
     119             : 
     120             : bool IsWord(MachineRepresentation rep) {
     121             :   return rep == MachineRepresentation::kWord8 ||
     122    18532844 :          rep == MachineRepresentation::kWord16 ||
     123             :          rep == MachineRepresentation::kWord32;
     124             : }
     125             : 
     126             : }  // namespace
     127             : 
     128      464309 : RepresentationChanger::RepresentationChanger(JSGraph* jsgraph, Isolate* isolate)
     129      464309 :     : cache_(TypeCache::Get()),
     130             :       jsgraph_(jsgraph),
     131             :       isolate_(isolate),
     132             :       testing_type_errors_(false),
     133      464329 :       type_error_(false) {}
     134             : 
     135             : // Changes representation from {output_rep} to {use_rep}. The {truncation}
     136             : // parameter is only used for sanity checking - if the changer cannot figure
     137             : // out signedness for the word32->float64 conversion, then we check that the
     138             : // uses truncate to word32 (so they do not care about signedness).
     139    17006187 : Node* RepresentationChanger::GetRepresentationFor(
     140             :     Node* node, MachineRepresentation output_rep, Type output_type,
     141             :     Node* use_node, UseInfo use_info) {
     142    17006726 :   if (output_rep == MachineRepresentation::kNone && !output_type.IsNone()) {
     143             :     // The output representation should be set if the type is inhabited (i.e.,
     144             :     // if the value is possible).
     145           0 :     return TypeError(node, output_rep, output_type, use_info.representation());
     146             :   }
     147             : 
     148             :   // Handle the no-op shortcuts when no checking is necessary.
     149    17006187 :   if (use_info.type_check() == TypeCheckKind::kNone ||
     150             :       output_rep != MachineRepresentation::kWord32) {
     151    16911302 :     if (use_info.representation() == output_rep) {
     152             :       // Representations are the same. That's a no-op.
     153             :       return node;
     154             :     }
     155    18165946 :     if (IsWord(use_info.representation()) && IsWord(output_rep)) {
     156             :       // Both are words less than or equal to 32-bits.
     157             :       // Since loads of integers from memory implicitly sign or zero extend the
     158             :       // value to the full machine word size and stores implicitly truncate,
     159             :       // no representation change is necessary.
     160             :       return node;
     161             :     }
     162             :   }
     163             : 
     164    16971290 :   switch (use_info.representation()) {
     165             :     case MachineRepresentation::kTaggedSigned:
     166             :       DCHECK(use_info.type_check() == TypeCheckKind::kNone ||
     167             :              use_info.type_check() == TypeCheckKind::kSignedSmall);
     168             :       return GetTaggedSignedRepresentationFor(node, output_rep, output_type,
     169       69392 :                                               use_node, use_info);
     170             :     case MachineRepresentation::kTaggedPointer:
     171             :       DCHECK(use_info.type_check() == TypeCheckKind::kNone ||
     172             :              use_info.type_check() == TypeCheckKind::kHeapObject);
     173             :       return GetTaggedPointerRepresentationFor(node, output_rep, output_type,
     174       35541 :                                                use_node, use_info);
     175             :     case MachineRepresentation::kTagged:
     176             :       DCHECK_EQ(TypeCheckKind::kNone, use_info.type_check());
     177             :       return GetTaggedRepresentationFor(node, output_rep, output_type,
     178    14743595 :                                         use_info.truncation());
     179             :     case MachineRepresentation::kFloat32:
     180             :       DCHECK_EQ(TypeCheckKind::kNone, use_info.type_check());
     181             :       return GetFloat32RepresentationFor(node, output_rep, output_type,
     182        1402 :                                          use_info.truncation());
     183             :     case MachineRepresentation::kFloat64:
     184             :       return GetFloat64RepresentationFor(node, output_rep, output_type,
     185      261791 :                                          use_node, use_info);
     186             :     case MachineRepresentation::kBit:
     187             :       DCHECK_EQ(TypeCheckKind::kNone, use_info.type_check());
     188      314984 :       return GetBitRepresentationFor(node, output_rep, output_type);
     189             :     case MachineRepresentation::kWord8:
     190             :     case MachineRepresentation::kWord16:
     191             :     case MachineRepresentation::kWord32:
     192             :       return GetWord32RepresentationFor(node, output_rep, output_type, use_node,
     193     1360765 :                                         use_info);
     194             :     case MachineRepresentation::kWord64:
     195             :       DCHECK(use_info.type_check() == TypeCheckKind::kNone ||
     196             :              use_info.type_check() == TypeCheckKind::kSigned64);
     197             :       return GetWord64RepresentationFor(node, output_rep, output_type, use_node,
     198      183820 :                                         use_info);
     199             :     // TODO(solanes): Create the code for the compressed values
     200             :     case MachineRepresentation::kCompressedSigned:
     201             :     case MachineRepresentation::kCompressedPointer:
     202             :     case MachineRepresentation::kCompressed:
     203           0 :       UNREACHABLE();
     204             :     case MachineRepresentation::kSimd128:
     205             :     case MachineRepresentation::kNone:
     206             :       return node;
     207             :   }
     208           0 :   UNREACHABLE();
     209             : }
     210             : 
     211       69392 : Node* RepresentationChanger::GetTaggedSignedRepresentationFor(
     212             :     Node* node, MachineRepresentation output_rep, Type output_type,
     213             :     Node* use_node, UseInfo use_info) {
     214             :   // Eagerly fold representation changes for constants.
     215       69392 :   switch (node->opcode()) {
     216             :     case IrOpcode::kNumberConstant:
     217          32 :       if (output_type.Is(Type::SignedSmall())) {
     218             :         return node;
     219             :       }
     220             :       break;
     221             :     default:
     222             :       break;
     223             :   }
     224             :   // Select the correct X -> Tagged operator.
     225             :   const Operator* op;
     226       69392 :   if (output_type.Is(Type::None())) {
     227             :     // This is an impossible value; it should not be used at runtime.
     228           0 :     return jsgraph()->graph()->NewNode(
     229             :         jsgraph()->common()->DeadValue(MachineRepresentation::kTaggedSigned),
     230           0 :         node);
     231       69392 :   } else if (IsWord(output_rep)) {
     232       45052 :     if (output_type.Is(Type::Signed31())) {
     233       30399 :       op = simplified()->ChangeInt31ToTaggedSigned();
     234       14653 :     } else if (output_type.Is(Type::Signed32())) {
     235             :       if (SmiValuesAre32Bits()) {
     236             :         op = simplified()->ChangeInt32ToTagged();
     237       14646 :       } else if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
     238       14646 :         op = simplified()->CheckedInt32ToTaggedSigned(use_info.feedback());
     239             :       } else {
     240             :         return TypeError(node, output_rep, output_type,
     241           0 :                          MachineRepresentation::kTaggedSigned);
     242             :       }
     243           7 :     } else if (output_type.Is(Type::Unsigned32()) &&
     244             :                use_info.type_check() == TypeCheckKind::kSignedSmall) {
     245           7 :       op = simplified()->CheckedUint32ToTaggedSigned(use_info.feedback());
     246             :     } else {
     247             :       return TypeError(node, output_rep, output_type,
     248           0 :                        MachineRepresentation::kTaggedSigned);
     249             :     }
     250       24340 :   } else if (output_rep == MachineRepresentation::kWord64) {
     251          15 :     if (output_type.Is(Type::Signed31())) {
     252             :       // int64 -> int32 -> tagged signed
     253           5 :       node = InsertTruncateInt64ToInt32(node);
     254           5 :       op = simplified()->ChangeInt31ToTaggedSigned();
     255             :     } else if (output_type.Is(Type::Signed32()) && SmiValuesAre32Bits()) {
     256             :       // int64 -> int32 -> tagged signed
     257             :       node = InsertTruncateInt64ToInt32(node);
     258             :       op = simplified()->ChangeInt32ToTagged();
     259          10 :     } else if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
     260          20 :       if (output_type.Is(cache_->kPositiveSafeInteger)) {
     261           5 :         op = simplified()->CheckedUint64ToTaggedSigned(use_info.feedback());
     262          10 :       } else if (output_type.Is(cache_->kSafeInteger)) {
     263           5 :         op = simplified()->CheckedInt64ToTaggedSigned(use_info.feedback());
     264             :       } else {
     265             :         return TypeError(node, output_rep, output_type,
     266           0 :                          MachineRepresentation::kTaggedSigned);
     267             :       }
     268             :     } else {
     269             :       return TypeError(node, output_rep, output_type,
     270           0 :                        MachineRepresentation::kTaggedSigned);
     271             :     }
     272       24325 :   } else if (output_rep == MachineRepresentation::kFloat64) {
     273          23 :     if (output_type.Is(Type::Signed31())) {
     274             :       // float64 -> int32 -> tagged signed
     275           0 :       node = InsertChangeFloat64ToInt32(node);
     276           0 :       op = simplified()->ChangeInt31ToTaggedSigned();
     277          23 :     } else if (output_type.Is(Type::Signed32())) {
     278             :       // float64 -> int32 -> tagged signed
     279           0 :       node = InsertChangeFloat64ToInt32(node);
     280             :       if (SmiValuesAre32Bits()) {
     281             :         op = simplified()->ChangeInt32ToTagged();
     282           0 :       } else if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
     283           0 :         op = simplified()->CheckedInt32ToTaggedSigned(use_info.feedback());
     284             :       } else {
     285             :         return TypeError(node, output_rep, output_type,
     286           0 :                          MachineRepresentation::kTaggedSigned);
     287             :       }
     288          23 :     } else if (output_type.Is(Type::Unsigned32()) &&
     289             :                use_info.type_check() == TypeCheckKind::kSignedSmall) {
     290             :       // float64 -> uint32 -> tagged signed
     291           0 :       node = InsertChangeFloat64ToUint32(node);
     292           0 :       op = simplified()->CheckedUint32ToTaggedSigned(use_info.feedback());
     293          23 :     } else if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
     294          23 :       op = simplified()->CheckedFloat64ToInt32(
     295          23 :           output_type.Maybe(Type::MinusZero())
     296             :               ? CheckForMinusZeroMode::kCheckForMinusZero
     297             :               : CheckForMinusZeroMode::kDontCheckForMinusZero,
     298          23 :           use_info.feedback());
     299          23 :       node = InsertConversion(node, op, use_node);
     300             :       if (SmiValuesAre32Bits()) {
     301             :         op = simplified()->ChangeInt32ToTagged();
     302             :       } else {
     303          23 :         op = simplified()->CheckedInt32ToTaggedSigned(use_info.feedback());
     304             :       }
     305             :     } else {
     306             :       return TypeError(node, output_rep, output_type,
     307           0 :                        MachineRepresentation::kTaggedSigned);
     308             :     }
     309       24302 :   } else if (output_rep == MachineRepresentation::kFloat32) {
     310           0 :     if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
     311           0 :       op = machine()->ChangeFloat32ToFloat64();
     312           0 :       node = InsertConversion(node, op, use_node);
     313           0 :       op = simplified()->CheckedFloat64ToInt32(
     314           0 :           output_type.Maybe(Type::MinusZero())
     315             :               ? CheckForMinusZeroMode::kCheckForMinusZero
     316             :               : CheckForMinusZeroMode::kDontCheckForMinusZero,
     317           0 :           use_info.feedback());
     318           0 :       node = InsertConversion(node, op, use_node);
     319             :       if (SmiValuesAre32Bits()) {
     320             :         op = simplified()->ChangeInt32ToTagged();
     321             :       } else {
     322           0 :         op = simplified()->CheckedInt32ToTaggedSigned(use_info.feedback());
     323             :       }
     324             :     } else {
     325             :       return TypeError(node, output_rep, output_type,
     326           0 :                        MachineRepresentation::kTaggedSigned);
     327             :     }
     328       24302 :   } else if (CanBeTaggedPointer(output_rep)) {
     329       24302 :     if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
     330       24288 :       op = simplified()->CheckedTaggedToTaggedSigned(use_info.feedback());
     331          14 :     } else if (output_type.Is(Type::SignedSmall())) {
     332          14 :       op = simplified()->ChangeTaggedToTaggedSigned();
     333             :     } else {
     334             :       return TypeError(node, output_rep, output_type,
     335           0 :                        MachineRepresentation::kTaggedSigned);
     336             :     }
     337           0 :   } else if (output_rep == MachineRepresentation::kBit) {
     338           0 :     if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
     339             :       // TODO(turbofan): Consider adding a Bailout operator that just deopts.
     340             :       // Also use that for MachineRepresentation::kPointer case above.
     341           0 :       node = InsertChangeBitToTagged(node);
     342           0 :       op = simplified()->CheckedTaggedToTaggedSigned(use_info.feedback());
     343             :     } else {
     344             :       return TypeError(node, output_rep, output_type,
     345           0 :                        MachineRepresentation::kTaggedSigned);
     346             :     }
     347             :   } else {
     348             :     return TypeError(node, output_rep, output_type,
     349           0 :                      MachineRepresentation::kTaggedSigned);
     350             :   }
     351       69391 :   return InsertConversion(node, op, use_node);
     352             : }
     353             : 
     354       35541 : Node* RepresentationChanger::GetTaggedPointerRepresentationFor(
     355             :     Node* node, MachineRepresentation output_rep, Type output_type,
     356             :     Node* use_node, UseInfo use_info) {
     357             :   // Eagerly fold representation changes for constants.
     358       35541 :   switch (node->opcode()) {
     359             :     case IrOpcode::kHeapConstant:
     360             :     case IrOpcode::kDelayedStringConstant:
     361             :       return node;  // No change necessary.
     362             :     case IrOpcode::kInt32Constant:
     363             :     case IrOpcode::kFloat64Constant:
     364             :     case IrOpcode::kFloat32Constant:
     365           0 :       UNREACHABLE();
     366             :     default:
     367             :       break;
     368             :   }
     369             :   // Select the correct X -> TaggedPointer operator.
     370             :   Operator const* op;
     371       35541 :   if (output_type.Is(Type::None())) {
     372             :     // This is an impossible value; it should not be used at runtime.
     373           0 :     return jsgraph()->graph()->NewNode(
     374             :         jsgraph()->common()->DeadValue(MachineRepresentation::kTaggedPointer),
     375           0 :         node);
     376       35541 :   } else if (output_rep == MachineRepresentation::kBit) {
     377           0 :     if (output_type.Is(Type::Boolean())) {
     378           0 :       op = simplified()->ChangeBitToTagged();
     379             :     } else {
     380             :       return TypeError(node, output_rep, output_type,
     381           0 :                        MachineRepresentation::kTagged);
     382             :     }
     383       35541 :   } else if (IsWord(output_rep)) {
     384          14 :     if (output_type.Is(Type::Unsigned32())) {
     385             :       // uint32 -> float64 -> tagged
     386           0 :       node = InsertChangeUint32ToFloat64(node);
     387          14 :     } else if (output_type.Is(Type::Signed32())) {
     388             :       // int32 -> float64 -> tagged
     389          14 :       node = InsertChangeInt32ToFloat64(node);
     390             :     } else {
     391             :       return TypeError(node, output_rep, output_type,
     392           0 :                        MachineRepresentation::kTaggedPointer);
     393             :     }
     394          14 :     op = simplified()->ChangeFloat64ToTaggedPointer();
     395       35527 :   } else if (output_rep == MachineRepresentation::kWord64) {
     396          10 :     if (output_type.Is(cache_->kSafeInteger)) {
     397             :       // int64 -> float64 -> tagged pointer
     398           5 :       op = machine()->ChangeInt64ToFloat64();
     399             :       node = jsgraph()->graph()->NewNode(op, node);
     400           5 :       op = simplified()->ChangeFloat64ToTaggedPointer();
     401             :     } else {
     402             :       return TypeError(node, output_rep, output_type,
     403           0 :                        MachineRepresentation::kTaggedPointer);
     404             :     }
     405       35522 :   } else if (output_rep == MachineRepresentation::kFloat32) {
     406           0 :     if (output_type.Is(Type::Number())) {
     407             :       // float32 -> float64 -> tagged
     408           0 :       node = InsertChangeFloat32ToFloat64(node);
     409           0 :       op = simplified()->ChangeFloat64ToTaggedPointer();
     410             :     } else {
     411             :       return TypeError(node, output_rep, output_type,
     412           0 :                        MachineRepresentation::kTaggedPointer);
     413             :     }
     414       35522 :   } else if (output_rep == MachineRepresentation::kFloat64) {
     415         168 :     if (output_type.Is(Type::Number())) {
     416             :       // float64 -> tagged
     417         168 :       op = simplified()->ChangeFloat64ToTaggedPointer();
     418             :     } else {
     419             :       return TypeError(node, output_rep, output_type,
     420           0 :                        MachineRepresentation::kTaggedPointer);
     421             :     }
     422       35354 :   } else if (CanBeTaggedSigned(output_rep) &&
     423             :              use_info.type_check() == TypeCheckKind::kHeapObject) {
     424       35354 :     if (!output_type.Maybe(Type::SignedSmall())) {
     425             :       return node;
     426             :     }
     427             :     // TODO(turbofan): Consider adding a Bailout operator that just deopts
     428             :     // for TaggedSigned output representation.
     429       34805 :     op = simplified()->CheckedTaggedToTaggedPointer(use_info.feedback());
     430             :   } else {
     431             :     return TypeError(node, output_rep, output_type,
     432           0 :                      MachineRepresentation::kTaggedPointer);
     433             :   }
     434       34992 :   return InsertConversion(node, op, use_node);
     435             : }
     436             : 
     437    14743568 : Node* RepresentationChanger::GetTaggedRepresentationFor(
     438             :     Node* node, MachineRepresentation output_rep, Type output_type,
     439             :     Truncation truncation) {
     440             :   // Eagerly fold representation changes for constants.
     441    14743568 :   switch (node->opcode()) {
     442             :     case IrOpcode::kNumberConstant:
     443             :     case IrOpcode::kHeapConstant:
     444             :     case IrOpcode::kDelayedStringConstant:
     445             :       return node;  // No change necessary.
     446             :     case IrOpcode::kInt32Constant:
     447             :     case IrOpcode::kFloat64Constant:
     448             :     case IrOpcode::kFloat32Constant:
     449           0 :       UNREACHABLE();
     450             :       break;
     451             :     default:
     452             :       break;
     453             :   }
     454     3194367 :   if (output_rep == MachineRepresentation::kTaggedSigned ||
     455             :       output_rep == MachineRepresentation::kTaggedPointer) {
     456             :     // this is a no-op.
     457             :     return node;
     458             :   }
     459             :   // Select the correct X -> Tagged operator.
     460             :   const Operator* op;
     461      124881 :   if (output_type.Is(Type::None())) {
     462             :     // This is an impossible value; it should not be used at runtime.
     463         308 :     return jsgraph()->graph()->NewNode(
     464         308 :         jsgraph()->common()->DeadValue(MachineRepresentation::kTagged), node);
     465      124573 :   } else if (output_rep == MachineRepresentation::kBit) {
     466       10513 :     if (output_type.Is(Type::Boolean())) {
     467       10513 :       op = simplified()->ChangeBitToTagged();
     468             :     } else {
     469             :       return TypeError(node, output_rep, output_type,
     470           0 :                        MachineRepresentation::kTagged);
     471             :     }
     472      114060 :   } else if (IsWord(output_rep)) {
     473       39053 :     if (output_type.Is(Type::Signed31())) {
     474       16528 :       op = simplified()->ChangeInt31ToTaggedSigned();
     475       46050 :     } else if (output_type.Is(Type::Signed32()) ||
     476           7 :                (output_type.Is(Type::Signed32OrMinusZero()) &&
     477             :                 truncation.IdentifiesZeroAndMinusZero())) {
     478       21532 :       op = simplified()->ChangeInt32ToTagged();
     479        1000 :     } else if (output_type.Is(Type::Unsigned32()) ||
     480           0 :                (output_type.Is(Type::Unsigned32OrMinusZero()) &&
     481        1000 :                 truncation.IdentifiesZeroAndMinusZero()) ||
     482             :                truncation.IsUsedAsWord32()) {
     483             :       // Either the output is uint32 or the uses only care about the
     484             :       // low 32 bits (so we can pick uint32 safely).
     485         993 :       op = simplified()->ChangeUint32ToTagged();
     486             :     } else {
     487             :       return TypeError(node, output_rep, output_type,
     488           0 :                        MachineRepresentation::kTagged);
     489             :     }
     490       75007 :   } else if (output_rep == MachineRepresentation::kWord64) {
     491         451 :     if (output_type.Is(Type::Signed31())) {
     492             :       // int64 -> int32 -> tagged signed
     493           5 :       node = InsertTruncateInt64ToInt32(node);
     494           5 :       op = simplified()->ChangeInt31ToTaggedSigned();
     495         446 :     } else if (output_type.Is(Type::Signed32())) {
     496             :       // int64 -> int32 -> tagged
     497           5 :       node = InsertTruncateInt64ToInt32(node);
     498           5 :       op = simplified()->ChangeInt32ToTagged();
     499         441 :     } else if (output_type.Is(Type::Unsigned32())) {
     500             :       // int64 -> uint32 -> tagged
     501          12 :       node = InsertTruncateInt64ToInt32(node);
     502          12 :       op = simplified()->ChangeUint32ToTagged();
     503         858 :     } else if (output_type.Is(cache_->kPositiveSafeInteger)) {
     504             :       // uint64 -> tagged
     505          88 :       op = simplified()->ChangeUint64ToTagged();
     506         682 :     } else if (output_type.Is(cache_->kSafeInteger)) {
     507             :       // int64 -> tagged
     508         336 :       op = simplified()->ChangeInt64ToTagged();
     509             :     } else {
     510             :       return TypeError(node, output_rep, output_type,
     511           5 :                        MachineRepresentation::kTagged);
     512             :     }
     513       74556 :   } else if (output_rep ==
     514             :              MachineRepresentation::kFloat32) {  // float32 -> float64 -> tagged
     515         378 :     node = InsertChangeFloat32ToFloat64(node);
     516         378 :     op = simplified()->ChangeFloat64ToTagged(
     517         378 :         output_type.Maybe(Type::MinusZero())
     518             :             ? CheckForMinusZeroMode::kCheckForMinusZero
     519         378 :             : CheckForMinusZeroMode::kDontCheckForMinusZero);
     520       74178 :   } else if (output_rep == MachineRepresentation::kFloat64) {
     521       74178 :     if (output_type.Is(Type::Signed31())) {  // float64 -> int32 -> tagged
     522          31 :       node = InsertChangeFloat64ToInt32(node);
     523          31 :       op = simplified()->ChangeInt31ToTaggedSigned();
     524       74147 :     } else if (output_type.Is(
     525             :                    Type::Signed32())) {  // float64 -> int32 -> tagged
     526         499 :       node = InsertChangeFloat64ToInt32(node);
     527         499 :       op = simplified()->ChangeInt32ToTagged();
     528       73648 :     } else if (output_type.Is(
     529             :                    Type::Unsigned32())) {  // float64 -> uint32 -> tagged
     530          23 :       node = InsertChangeFloat64ToUint32(node);
     531          23 :       op = simplified()->ChangeUint32ToTagged();
     532      147264 :     } else if (output_type.Is(Type::Number()) ||
     533          14 :                (output_type.Is(Type::NumberOrOddball()) &&
     534             :                 truncation.IsUsedAsFloat64())) {
     535       73625 :       op = simplified()->ChangeFloat64ToTagged(
     536       73625 :           output_type.Maybe(Type::MinusZero())
     537             :               ? CheckForMinusZeroMode::kCheckForMinusZero
     538       73625 :               : CheckForMinusZeroMode::kDontCheckForMinusZero);
     539             :     } else {
     540             :       return TypeError(node, output_rep, output_type,
     541           0 :                        MachineRepresentation::kTagged);
     542             :     }
     543             :   } else {
     544             :     return TypeError(node, output_rep, output_type,
     545           0 :                      MachineRepresentation::kTagged);
     546             :   }
     547      124567 :   return jsgraph()->graph()->NewNode(op, node);
     548             : }
     549             : 
     550        1402 : Node* RepresentationChanger::GetFloat32RepresentationFor(
     551             :     Node* node, MachineRepresentation output_rep, Type output_type,
     552             :     Truncation truncation) {
     553             :   // Eagerly fold representation changes for constants.
     554        1402 :   switch (node->opcode()) {
     555             :     case IrOpcode::kNumberConstant:
     556        2308 :       return jsgraph()->Float32Constant(
     557        1154 :           DoubleToFloat32(OpParameter<double>(node->op())));
     558             :     case IrOpcode::kInt32Constant:
     559             :     case IrOpcode::kFloat64Constant:
     560             :     case IrOpcode::kFloat32Constant:
     561           0 :       UNREACHABLE();
     562             :       break;
     563             :     default:
     564             :       break;
     565             :   }
     566             :   // Select the correct X -> Float32 operator.
     567             :   const Operator* op = nullptr;
     568         248 :   if (output_type.Is(Type::None())) {
     569             :     // This is an impossible value; it should not be used at runtime.
     570           0 :     return jsgraph()->graph()->NewNode(
     571           0 :         jsgraph()->common()->DeadValue(MachineRepresentation::kFloat32), node);
     572         248 :   } else if (IsWord(output_rep)) {
     573          31 :     if (output_type.Is(Type::Signed32())) {
     574             :       // int32 -> float64 -> float32
     575          26 :       op = machine()->ChangeInt32ToFloat64();
     576             :       node = jsgraph()->graph()->NewNode(op, node);
     577          26 :       op = machine()->TruncateFloat64ToFloat32();
     578           5 :     } else if (output_type.Is(Type::Unsigned32()) ||
     579             :                truncation.IsUsedAsWord32()) {
     580             :       // Either the output is uint32 or the uses only care about the
     581             :       // low 32 bits (so we can pick uint32 safely).
     582             : 
     583             :       // uint32 -> float64 -> float32
     584           5 :       op = machine()->ChangeUint32ToFloat64();
     585             :       node = jsgraph()->graph()->NewNode(op, node);
     586           5 :       op = machine()->TruncateFloat64ToFloat32();
     587             :     }
     588         217 :   } else if (IsAnyTagged(output_rep)) {
     589           5 :     if (output_type.Is(Type::NumberOrOddball())) {
     590             :       // tagged -> float64 -> float32
     591           5 :       if (output_type.Is(Type::Number())) {
     592           5 :         op = simplified()->ChangeTaggedToFloat64();
     593             :       } else {
     594           0 :         op = simplified()->TruncateTaggedToFloat64();
     595             :       }
     596             :       node = jsgraph()->graph()->NewNode(op, node);
     597           5 :       op = machine()->TruncateFloat64ToFloat32();
     598             :     }
     599         212 :   } else if (output_rep == MachineRepresentation::kFloat64) {
     600         197 :     op = machine()->TruncateFloat64ToFloat32();
     601          15 :   } else if (output_rep == MachineRepresentation::kWord64) {
     602          10 :     if (output_type.Is(cache_->kSafeInteger)) {
     603             :       // int64 -> float64 -> float32
     604           5 :       op = machine()->ChangeInt64ToFloat64();
     605             :       node = jsgraph()->graph()->NewNode(op, node);
     606           5 :       op = machine()->TruncateFloat64ToFloat32();
     607             :     }
     608             :   }
     609         248 :   if (op == nullptr) {
     610             :     return TypeError(node, output_rep, output_type,
     611          10 :                      MachineRepresentation::kFloat32);
     612             :   }
     613         238 :   return jsgraph()->graph()->NewNode(op, node);
     614             : }
     615             : 
     616      261789 : Node* RepresentationChanger::GetFloat64RepresentationFor(
     617             :     Node* node, MachineRepresentation output_rep, Type output_type,
     618             :     Node* use_node, UseInfo use_info) {
     619             :   NumberMatcher m(node);
     620      261789 :   if (m.HasValue()) {
     621             :     switch (use_info.type_check()) {
     622             :       case TypeCheckKind::kNone:
     623             :       case TypeCheckKind::kNumber:
     624             :       case TypeCheckKind::kNumberOrOddball:
     625      150258 :         return jsgraph()->Float64Constant(m.Value());
     626             :       case TypeCheckKind::kHeapObject:
     627             :       case TypeCheckKind::kSigned32:
     628             :       case TypeCheckKind::kSigned64:
     629             :       case TypeCheckKind::kSignedSmall:
     630             :         break;
     631             :     }
     632             :   }
     633             :   // Select the correct X -> Float64 operator.
     634             :   const Operator* op = nullptr;
     635      111531 :   if (output_type.Is(Type::None())) {
     636             :     // This is an impossible value; it should not be used at runtime.
     637           0 :     return jsgraph()->graph()->NewNode(
     638           0 :         jsgraph()->common()->DeadValue(MachineRepresentation::kFloat64), node);
     639      111531 :   } else if (IsWord(output_rep)) {
     640       77845 :     if (output_type.Is(Type::Signed32()) ||
     641          15 :         (output_type.Is(Type::Signed32OrMinusZero()) &&
     642             :          use_info.truncation().IdentifiesZeroAndMinusZero())) {
     643       38042 :       op = machine()->ChangeInt32ToFloat64();
     644         582 :     } else if (output_type.Is(Type::Unsigned32()) ||
     645             :                use_info.truncation().IsUsedAsWord32()) {
     646             :       // Either the output is uint32 or the uses only care about the
     647             :       // low 32 bits (so we can pick uint32 safely).
     648         582 :       op = machine()->ChangeUint32ToFloat64();
     649             :     }
     650       72907 :   } else if (output_rep == MachineRepresentation::kBit) {
     651           0 :     CHECK(output_type.Is(Type::Boolean()));
     652           0 :     if (use_info.truncation().IsUsedAsFloat64()) {
     653           0 :       op = machine()->ChangeUint32ToFloat64();
     654             :     } else {
     655           0 :       CHECK_NE(use_info.type_check(), TypeCheckKind::kNone);
     656             :       Node* unreachable =
     657           0 :           InsertUnconditionalDeopt(use_node, DeoptimizeReason::kNotAHeapNumber);
     658           0 :       return jsgraph()->graph()->NewNode(
     659             :           jsgraph()->common()->DeadValue(MachineRepresentation::kFloat64),
     660           0 :           unreachable);
     661             :     }
     662      145814 :   } else if (output_rep == MachineRepresentation::kTagged ||
     663       77921 :              output_rep == MachineRepresentation::kTaggedSigned ||
     664             :              output_rep == MachineRepresentation::kTaggedPointer) {
     665       70308 :     if (output_type.Is(Type::Undefined())) {
     666         244 :       return jsgraph()->Float64Constant(
     667         244 :           std::numeric_limits<double>::quiet_NaN());
     668             : 
     669       70064 :     } else if (output_rep == MachineRepresentation::kTaggedSigned) {
     670        1228 :       node = InsertChangeTaggedSignedToInt32(node);
     671        1228 :       op = machine()->ChangeInt32ToFloat64();
     672       68836 :     } else if (output_type.Is(Type::Number())) {
     673       11726 :       op = simplified()->ChangeTaggedToFloat64();
     674       57110 :     } else if (output_type.Is(Type::NumberOrOddball())) {
     675             :       // TODO(jarin) Here we should check that truncation is Number.
     676        1468 :       op = simplified()->TruncateTaggedToFloat64();
     677      111284 :     } else if (use_info.type_check() == TypeCheckKind::kNumber ||
     678       46941 :                (use_info.type_check() == TypeCheckKind::kNumberOrOddball &&
     679       46941 :                 !output_type.Maybe(Type::BooleanOrNullOrNumber()))) {
     680             :       op = simplified()->CheckedTaggedToFloat64(CheckTaggedInputMode::kNumber,
     681        9166 :                                                 use_info.feedback());
     682       46476 :     } else if (use_info.type_check() == TypeCheckKind::kNumberOrOddball) {
     683             :       op = simplified()->CheckedTaggedToFloat64(
     684       46476 :           CheckTaggedInputMode::kNumberOrOddball, use_info.feedback());
     685             :     }
     686        2599 :   } else if (output_rep == MachineRepresentation::kFloat32) {
     687        2174 :     op = machine()->ChangeFloat32ToFloat64();
     688         425 :   } else if (output_rep == MachineRepresentation::kWord64) {
     689         850 :     if (output_type.Is(cache_->kSafeInteger)) {
     690         425 :       op = machine()->ChangeInt64ToFloat64();
     691             :     }
     692             :   }
     693      111287 :   if (op == nullptr) {
     694             :     return TypeError(node, output_rep, output_type,
     695           0 :                      MachineRepresentation::kFloat64);
     696             :   }
     697      111287 :   return InsertConversion(node, op, use_node);
     698             : }
     699             : 
     700           0 : Node* RepresentationChanger::MakeTruncatedInt32Constant(double value) {
     701     1040905 :   return jsgraph()->Int32Constant(DoubleToInt32(value));
     702             : }
     703             : 
     704           7 : Node* RepresentationChanger::InsertUnconditionalDeopt(Node* node,
     705             :                                                       DeoptimizeReason reason) {
     706           7 :   Node* effect = NodeProperties::GetEffectInput(node);
     707           7 :   Node* control = NodeProperties::GetControlInput(node);
     708             :   effect =
     709          14 :       jsgraph()->graph()->NewNode(simplified()->CheckIf(reason),
     710             :                                   jsgraph()->Int32Constant(0), effect, control);
     711           7 :   Node* unreachable = effect = jsgraph()->graph()->NewNode(
     712             :       jsgraph()->common()->Unreachable(), effect, control);
     713           7 :   NodeProperties::ReplaceEffectInput(node, effect);
     714           7 :   return unreachable;
     715             : }
     716             : 
     717     1360750 : Node* RepresentationChanger::GetWord32RepresentationFor(
     718             :     Node* node, MachineRepresentation output_rep, Type output_type,
     719             :     Node* use_node, UseInfo use_info) {
     720             :   // Eagerly fold representation changes for constants.
     721     1360750 :   switch (node->opcode()) {
     722             :     case IrOpcode::kInt32Constant:
     723             :     case IrOpcode::kInt64Constant:
     724             :     case IrOpcode::kFloat32Constant:
     725             :     case IrOpcode::kFloat64Constant:
     726           0 :       UNREACHABLE();
     727             :       break;
     728             :     case IrOpcode::kNumberConstant: {
     729     1041036 :       double const fv = OpParameter<double>(node->op());
     730     2082072 :       if (use_info.type_check() == TypeCheckKind::kNone ||
     731        1512 :           ((use_info.type_check() == TypeCheckKind::kSignedSmall ||
     732        1464 :             use_info.type_check() == TypeCheckKind::kSigned32 ||
     733         444 :             use_info.type_check() == TypeCheckKind::kNumber ||
     734       84643 :             use_info.type_check() == TypeCheckKind::kNumberOrOddball) &&
     735             :            IsInt32Double(fv))) {
     736     1040897 :         return MakeTruncatedInt32Constant(fv);
     737             :       }
     738             :       break;
     739             :     }
     740             :     default:
     741             :       break;
     742             :   }
     743             : 
     744             :   // Select the correct X -> Word32 operator.
     745             :   const Operator* op = nullptr;
     746      319828 :   if (output_type.Is(Type::None())) {
     747             :     // This is an impossible value; it should not be used at runtime.
     748          21 :     return jsgraph()->graph()->NewNode(
     749          21 :         jsgraph()->common()->DeadValue(MachineRepresentation::kWord32), node);
     750      319807 :   } else if (output_rep == MachineRepresentation::kBit) {
     751          58 :     CHECK(output_type.Is(Type::Boolean()));
     752          58 :     if (use_info.truncation().IsUsedAsWord32()) {
     753             :       return node;
     754             :     } else {
     755           0 :       CHECK(Truncation::Any(kIdentifyZeros)
     756             :                 .IsLessGeneralThan(use_info.truncation()));
     757           0 :       CHECK_NE(use_info.type_check(), TypeCheckKind::kNone);
     758             :       Node* unreachable =
     759           0 :           InsertUnconditionalDeopt(use_node, DeoptimizeReason::kNotASmi);
     760           0 :       return jsgraph()->graph()->NewNode(
     761             :           jsgraph()->common()->DeadValue(MachineRepresentation::kWord32),
     762           0 :           unreachable);
     763             :     }
     764      319749 :   } else if (output_rep == MachineRepresentation::kFloat64) {
     765       12617 :     if (output_type.Is(Type::Signed32())) {
     766         536 :       op = machine()->ChangeFloat64ToInt32();
     767       12081 :     } else if (use_info.type_check() == TypeCheckKind::kSignedSmall ||
     768             :                use_info.type_check() == TypeCheckKind::kSigned32) {
     769        2165 :       op = simplified()->CheckedFloat64ToInt32(
     770        2165 :           output_type.Maybe(Type::MinusZero())
     771             :               ? use_info.minus_zero_check()
     772             :               : CheckForMinusZeroMode::kDontCheckForMinusZero,
     773        2165 :           use_info.feedback());
     774        9916 :     } else if (output_type.Is(Type::Unsigned32())) {
     775          12 :       op = machine()->ChangeFloat64ToUint32();
     776        9904 :     } else if (use_info.truncation().IsUsedAsWord32()) {
     777        9904 :       op = machine()->TruncateFloat64ToWord32();
     778             :     } else {
     779             :       return TypeError(node, output_rep, output_type,
     780           0 :                        MachineRepresentation::kWord32);
     781             :     }
     782      307132 :   } else if (output_rep == MachineRepresentation::kFloat32) {
     783          15 :     node = InsertChangeFloat32ToFloat64(node);  // float32 -> float64 -> int32
     784          15 :     if (output_type.Is(Type::Signed32())) {
     785           5 :       op = machine()->ChangeFloat64ToInt32();
     786          10 :     } else if (use_info.type_check() == TypeCheckKind::kSignedSmall ||
     787             :                use_info.type_check() == TypeCheckKind::kSigned32) {
     788           0 :       op = simplified()->CheckedFloat64ToInt32(
     789           0 :           output_type.Maybe(Type::MinusZero())
     790             :               ? use_info.minus_zero_check()
     791             :               : CheckForMinusZeroMode::kDontCheckForMinusZero,
     792           0 :           use_info.feedback());
     793          10 :     } else if (output_type.Is(Type::Unsigned32())) {
     794           5 :       op = machine()->ChangeFloat64ToUint32();
     795           5 :     } else if (use_info.truncation().IsUsedAsWord32()) {
     796           5 :       op = machine()->TruncateFloat64ToWord32();
     797             :     } else {
     798             :       return TypeError(node, output_rep, output_type,
     799           0 :                        MachineRepresentation::kWord32);
     800             :     }
     801      307117 :   } else if (IsAnyTagged(output_rep)) {
     802      312308 :     if (output_rep == MachineRepresentation::kTaggedSigned &&
     803             :         output_type.Is(Type::SignedSmall())) {
     804       81687 :       op = simplified()->ChangeTaggedSignedToInt32();
     805      148930 :     } else if (output_type.Is(Type::Signed32())) {
     806        2346 :       op = simplified()->ChangeTaggedToInt32();
     807      146584 :     } else if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
     808      141167 :       op = simplified()->CheckedTaggedSignedToInt32(use_info.feedback());
     809        5417 :     } else if (use_info.type_check() == TypeCheckKind::kSigned32) {
     810        2458 :       op = simplified()->CheckedTaggedToInt32(
     811        2458 :           output_type.Maybe(Type::MinusZero())
     812             :               ? use_info.minus_zero_check()
     813             :               : CheckForMinusZeroMode::kDontCheckForMinusZero,
     814        2458 :           use_info.feedback());
     815        2959 :     } else if (output_type.Is(Type::Unsigned32())) {
     816         578 :       op = simplified()->ChangeTaggedToUint32();
     817        2381 :     } else if (use_info.truncation().IsUsedAsWord32()) {
     818        2381 :       if (output_type.Is(Type::NumberOrOddball())) {
     819         405 :         op = simplified()->TruncateTaggedToWord32();
     820        1976 :       } else if (use_info.type_check() == TypeCheckKind::kNumber) {
     821             :         op = simplified()->CheckedTruncateTaggedToWord32(
     822        1335 :             CheckTaggedInputMode::kNumber, use_info.feedback());
     823         641 :       } else if (use_info.type_check() == TypeCheckKind::kNumberOrOddball) {
     824             :         op = simplified()->CheckedTruncateTaggedToWord32(
     825         641 :             CheckTaggedInputMode::kNumberOrOddball, use_info.feedback());
     826             :       } else {
     827             :         return TypeError(node, output_rep, output_type,
     828           0 :                          MachineRepresentation::kWord32);
     829             :       }
     830             :     } else {
     831             :       return TypeError(node, output_rep, output_type,
     832           0 :                        MachineRepresentation::kWord32);
     833             :     }
     834       76496 :   } else if (output_rep == MachineRepresentation::kWord32) {
     835             :     // Only the checked case should get here, the non-checked case is
     836             :     // handled in GetRepresentationFor.
     837       76206 :     if (use_info.type_check() == TypeCheckKind::kSignedSmall ||
     838             :         use_info.type_check() == TypeCheckKind::kSigned32) {
     839             :       bool indentify_zeros = use_info.truncation().IdentifiesZeroAndMinusZero();
     840      152170 :       if (output_type.Is(Type::Signed32()) ||
     841         135 :           (indentify_zeros && output_type.Is(Type::Signed32OrMinusZero()))) {
     842             :         return node;
     843         352 :       } else if (output_type.Is(Type::Unsigned32()) ||
     844           0 :                  (indentify_zeros &&
     845             :                   output_type.Is(Type::Unsigned32OrMinusZero()))) {
     846         176 :         op = simplified()->CheckedUint32ToInt32(use_info.feedback());
     847             :       } else {
     848             :         return TypeError(node, output_rep, output_type,
     849           0 :                          MachineRepresentation::kWord32);
     850             :       }
     851         121 :     } else if (use_info.type_check() == TypeCheckKind::kNumber ||
     852             :                use_info.type_check() == TypeCheckKind::kNumberOrOddball) {
     853             :       return node;
     854             :     }
     855         290 :   } else if (output_rep == MachineRepresentation::kWord8 ||
     856             :              output_rep == MachineRepresentation::kWord16) {
     857             :     DCHECK_EQ(MachineRepresentation::kWord32, use_info.representation());
     858             :     DCHECK(use_info.type_check() == TypeCheckKind::kSignedSmall ||
     859             :            use_info.type_check() == TypeCheckKind::kSigned32);
     860             :     return node;
     861         290 :   } else if (output_rep == MachineRepresentation::kWord64) {
     862         551 :     if (output_type.Is(Type::Signed32()) ||
     863             :         output_type.Is(Type::Unsigned32())) {
     864          35 :       op = machine()->TruncateInt64ToInt32();
     865         760 :     } else if (output_type.Is(cache_->kSafeInteger) &&
     866             :                use_info.truncation().IsUsedAsWord32()) {
     867         231 :       op = machine()->TruncateInt64ToInt32();
     868          24 :     } else if (use_info.type_check() == TypeCheckKind::kSignedSmall ||
     869             :                use_info.type_check() == TypeCheckKind::kSigned32) {
     870          38 :       if (output_type.Is(cache_->kPositiveSafeInteger)) {
     871           5 :         op = simplified()->CheckedUint64ToInt32(use_info.feedback());
     872          28 :       } else if (output_type.Is(cache_->kSafeInteger)) {
     873          14 :         op = simplified()->CheckedInt64ToInt32(use_info.feedback());
     874             :       } else {
     875             :         return TypeError(node, output_rep, output_type,
     876           0 :                          MachineRepresentation::kWord32);
     877             :       }
     878             :     } else {
     879             :       return TypeError(node, output_rep, output_type,
     880           5 :                        MachineRepresentation::kWord32);
     881             :     }
     882             :   }
     883             : 
     884      243711 :   if (op == nullptr) {
     885             :     return TypeError(node, output_rep, output_type,
     886           0 :                      MachineRepresentation::kWord32);
     887             :   }
     888      243711 :   return InsertConversion(node, op, use_node);
     889             : }
     890             : 
     891      495500 : Node* RepresentationChanger::InsertConversion(Node* node, const Operator* op,
     892             :                                               Node* use_node) {
     893      495500 :   if (op->ControlInputCount() > 0) {
     894             :     // If the operator can deoptimize (which means it has control
     895             :     // input), we need to connect it to the effect and control chains.
     896      277591 :     Node* effect = NodeProperties::GetEffectInput(use_node);
     897      277590 :     Node* control = NodeProperties::GetControlInput(use_node);
     898             :     Node* conversion = jsgraph()->graph()->NewNode(op, node, effect, control);
     899      277603 :     NodeProperties::ReplaceEffectInput(use_node, conversion);
     900      277584 :     return conversion;
     901             :   }
     902      217909 :   return jsgraph()->graph()->NewNode(op, node);
     903             : }
     904             : 
     905      314984 : Node* RepresentationChanger::GetBitRepresentationFor(
     906             :     Node* node, MachineRepresentation output_rep, Type output_type) {
     907             :   // Eagerly fold representation changes for constants.
     908      314984 :   switch (node->opcode()) {
     909             :     case IrOpcode::kHeapConstant: {
     910             :       HeapObjectMatcher m(node);
     911      127439 :       if (m.Is(factory()->false_value())) {
     912       87098 :         return jsgraph()->Int32Constant(0);
     913       40341 :       } else if (m.Is(factory()->true_value())) {
     914       40341 :         return jsgraph()->Int32Constant(1);
     915             :       }
     916             :       break;
     917             :     }
     918             :     default:
     919             :       break;
     920             :   }
     921             :   // Select the correct X -> Bit operator.
     922             :   const Operator* op;
     923      187545 :   if (output_type.Is(Type::None())) {
     924             :     // This is an impossible value; it should not be used at runtime.
     925         217 :     return jsgraph()->graph()->NewNode(
     926         217 :         jsgraph()->common()->DeadValue(MachineRepresentation::kBit), node);
     927      187328 :   } else if (output_rep == MachineRepresentation::kTagged ||
     928             :              output_rep == MachineRepresentation::kTaggedPointer) {
     929      187314 :     if (output_type.Is(Type::BooleanOrNullOrUndefined())) {
     930             :       // true is the only trueish Oddball.
     931      139577 :       op = simplified()->ChangeTaggedToBit();
     932             :     } else {
     933       95084 :       if (output_rep == MachineRepresentation::kTagged &&
     934       47347 :           output_type.Maybe(Type::SignedSmall())) {
     935       47325 :         op = simplified()->TruncateTaggedToBit();
     936             :       } else {
     937             :         // The {output_type} either doesn't include the Smi range,
     938             :         // or the {output_rep} is known to be TaggedPointer.
     939         412 :         op = simplified()->TruncateTaggedPointerToBit();
     940             :       }
     941             :     }
     942          14 :   } else if (output_rep == MachineRepresentation::kTaggedSigned) {
     943           0 :     node = jsgraph()->graph()->NewNode(machine()->WordEqual(), node,
     944             :                                        jsgraph()->IntPtrConstant(0));
     945           0 :     return jsgraph()->graph()->NewNode(machine()->Word32Equal(), node,
     946           0 :                                        jsgraph()->Int32Constant(0));
     947          14 :   } else if (IsWord(output_rep)) {
     948           0 :     node = jsgraph()->graph()->NewNode(machine()->Word32Equal(), node,
     949             :                                        jsgraph()->Int32Constant(0));
     950           0 :     return jsgraph()->graph()->NewNode(machine()->Word32Equal(), node,
     951           0 :                                        jsgraph()->Int32Constant(0));
     952          14 :   } else if (output_rep == MachineRepresentation::kWord64) {
     953           0 :     node = jsgraph()->graph()->NewNode(machine()->Word64Equal(), node,
     954             :                                        jsgraph()->Int64Constant(0));
     955           0 :     return jsgraph()->graph()->NewNode(machine()->Word32Equal(), node,
     956           0 :                                        jsgraph()->Int32Constant(0));
     957          14 :   } else if (output_rep == MachineRepresentation::kFloat32) {
     958           0 :     node = jsgraph()->graph()->NewNode(machine()->Float32Abs(), node);
     959           0 :     return jsgraph()->graph()->NewNode(machine()->Float32LessThan(),
     960           0 :                                        jsgraph()->Float32Constant(0.0), node);
     961          14 :   } else if (output_rep == MachineRepresentation::kFloat64) {
     962          14 :     node = jsgraph()->graph()->NewNode(machine()->Float64Abs(), node);
     963          14 :     return jsgraph()->graph()->NewNode(machine()->Float64LessThan(),
     964          14 :                                        jsgraph()->Float64Constant(0.0), node);
     965             :   } else {
     966             :     return TypeError(node, output_rep, output_type,
     967           0 :                      MachineRepresentation::kBit);
     968             :   }
     969      187314 :   return jsgraph()->graph()->NewNode(op, node);
     970             : }
     971             : 
     972      183820 : Node* RepresentationChanger::GetWord64RepresentationFor(
     973             :     Node* node, MachineRepresentation output_rep, Type output_type,
     974             :     Node* use_node, UseInfo use_info) {
     975             :   // Eagerly fold representation changes for constants.
     976      183820 :   switch (node->opcode()) {
     977             :     case IrOpcode::kInt32Constant:
     978             :     case IrOpcode::kInt64Constant:
     979             :     case IrOpcode::kFloat32Constant:
     980             :     case IrOpcode::kFloat64Constant:
     981           0 :       UNREACHABLE();
     982             :       break;
     983             :     case IrOpcode::kNumberConstant: {
     984      147645 :       double const fv = OpParameter<double>(node->op());
     985             :       using limits = std::numeric_limits<int64_t>;
     986      147645 :       if (fv <= limits::max() && fv >= limits::min()) {
     987      147638 :         int64_t const iv = static_cast<int64_t>(fv);
     988      147638 :         if (static_cast<double>(iv) == fv) {
     989      147638 :           return jsgraph()->Int64Constant(iv);
     990             :         }
     991             :       }
     992             :       break;
     993             :     }
     994             :     default:
     995             :       break;
     996             :   }
     997             : 
     998             :   // Select the correct X -> Word64 operator.
     999             :   const Operator* op;
    1000       36182 :   if (output_type.Is(Type::None())) {
    1001             :     // This is an impossible value; it should not be used at runtime.
    1002          63 :     return jsgraph()->graph()->NewNode(
    1003          63 :         jsgraph()->common()->DeadValue(MachineRepresentation::kWord64), node);
    1004       36119 :   } else if (output_rep == MachineRepresentation::kBit) {
    1005           7 :     CHECK(output_type.Is(Type::Boolean()));
    1006           7 :     CHECK_NE(use_info.type_check(), TypeCheckKind::kNone);
    1007             :     Node* unreachable =
    1008           7 :         InsertUnconditionalDeopt(use_node, DeoptimizeReason::kNotASmi);
    1009           7 :     return jsgraph()->graph()->NewNode(
    1010             :         jsgraph()->common()->DeadValue(MachineRepresentation::kWord64),
    1011           7 :         unreachable);
    1012       36112 :   } else if (IsWord(output_rep)) {
    1013       35713 :     if (output_type.Is(Type::Unsigned32())) {
    1014       34370 :       op = machine()->ChangeUint32ToUint64();
    1015        1343 :     } else if (output_type.Is(Type::Signed32())) {
    1016        1338 :       op = machine()->ChangeInt32ToInt64();
    1017             :     } else {
    1018             :       return TypeError(node, output_rep, output_type,
    1019           5 :                        MachineRepresentation::kWord64);
    1020             :     }
    1021         399 :   } else if (output_rep == MachineRepresentation::kFloat32) {
    1022          66 :     if (output_type.Is(cache_->kInt64)) {
    1023             :       // float32 -> float64 -> int64
    1024          15 :       node = InsertChangeFloat32ToFloat64(node);
    1025          15 :       op = machine()->ChangeFloat64ToInt64();
    1026          36 :     } else if (output_type.Is(cache_->kUint64)) {
    1027             :       // float32 -> float64 -> uint64
    1028           5 :       node = InsertChangeFloat32ToFloat64(node);
    1029           5 :       op = machine()->ChangeFloat64ToUint64();
    1030          13 :     } else if (use_info.type_check() == TypeCheckKind::kSigned64) {
    1031             :       // float32 -> float64 -> int64
    1032          13 :       node = InsertChangeFloat32ToFloat64(node);
    1033          13 :       op = simplified()->CheckedFloat64ToInt64(
    1034          13 :           output_type.Maybe(Type::MinusZero())
    1035             :               ? use_info.minus_zero_check()
    1036             :               : CheckForMinusZeroMode::kDontCheckForMinusZero,
    1037          13 :           use_info.feedback());
    1038             :     } else {
    1039             :       return TypeError(node, output_rep, output_type,
    1040           0 :                        MachineRepresentation::kWord64);
    1041             :     }
    1042         366 :   } else if (output_rep == MachineRepresentation::kFloat64) {
    1043         120 :     if (output_type.Is(cache_->kInt64)) {
    1044          42 :       op = machine()->ChangeFloat64ToInt64();
    1045          36 :     } else if (output_type.Is(cache_->kUint64)) {
    1046           5 :       op = machine()->ChangeFloat64ToUint64();
    1047          13 :     } else if (use_info.type_check() == TypeCheckKind::kSigned64) {
    1048          13 :       op = simplified()->CheckedFloat64ToInt64(
    1049          13 :           output_type.Maybe(Type::MinusZero())
    1050             :               ? use_info.minus_zero_check()
    1051             :               : CheckForMinusZeroMode::kDontCheckForMinusZero,
    1052          13 :           use_info.feedback());
    1053             :     } else {
    1054             :       return TypeError(node, output_rep, output_type,
    1055           0 :                        MachineRepresentation::kWord64);
    1056             :     }
    1057         306 :   } else if (output_rep == MachineRepresentation::kTaggedSigned) {
    1058         112 :     if (output_type.Is(Type::SignedSmall())) {
    1059         112 :       op = simplified()->ChangeTaggedSignedToInt64();
    1060             :     } else {
    1061             :       return TypeError(node, output_rep, output_type,
    1062           0 :                        MachineRepresentation::kWord64);
    1063             :     }
    1064         194 :   } else if (CanBeTaggedPointer(output_rep)) {
    1065         388 :     if (output_type.Is(cache_->kInt64)) {
    1066          23 :       op = simplified()->ChangeTaggedToInt64();
    1067         171 :     } else if (use_info.type_check() == TypeCheckKind::kSigned64) {
    1068         161 :       op = simplified()->CheckedTaggedToInt64(
    1069         161 :           output_type.Maybe(Type::MinusZero())
    1070             :               ? use_info.minus_zero_check()
    1071             :               : CheckForMinusZeroMode::kDontCheckForMinusZero,
    1072         161 :           use_info.feedback());
    1073             :     } else {
    1074             :       return TypeError(node, output_rep, output_type,
    1075          10 :                        MachineRepresentation::kWord64);
    1076             :     }
    1077             :   } else {
    1078             :     return TypeError(node, output_rep, output_type,
    1079           0 :                      MachineRepresentation::kWord64);
    1080             :   }
    1081       36097 :   return InsertConversion(node, op, use_node);
    1082             : }
    1083             : 
    1084      233466 : const Operator* RepresentationChanger::Int32OperatorFor(
    1085             :     IrOpcode::Value opcode) {
    1086      233466 :   switch (opcode) {
    1087             :     case IrOpcode::kSpeculativeNumberAdd:  // Fall through.
    1088             :     case IrOpcode::kSpeculativeSafeIntegerAdd:
    1089             :     case IrOpcode::kNumberAdd:
    1090      114298 :       return machine()->Int32Add();
    1091             :     case IrOpcode::kSpeculativeNumberSubtract:  // Fall through.
    1092             :     case IrOpcode::kSpeculativeSafeIntegerSubtract:
    1093             :     case IrOpcode::kNumberSubtract:
    1094        9442 :       return machine()->Int32Sub();
    1095             :     case IrOpcode::kSpeculativeNumberMultiply:
    1096             :     case IrOpcode::kNumberMultiply:
    1097        1081 :       return machine()->Int32Mul();
    1098             :     case IrOpcode::kSpeculativeNumberDivide:
    1099             :     case IrOpcode::kNumberDivide:
    1100           0 :       return machine()->Int32Div();
    1101             :     case IrOpcode::kSpeculativeNumberModulus:
    1102             :     case IrOpcode::kNumberModulus:
    1103           0 :       return machine()->Int32Mod();
    1104             :     case IrOpcode::kSpeculativeNumberBitwiseOr:  // Fall through.
    1105             :     case IrOpcode::kNumberBitwiseOr:
    1106       20439 :       return machine()->Word32Or();
    1107             :     case IrOpcode::kSpeculativeNumberBitwiseXor:  // Fall through.
    1108             :     case IrOpcode::kNumberBitwiseXor:
    1109        2551 :       return machine()->Word32Xor();
    1110             :     case IrOpcode::kSpeculativeNumberBitwiseAnd:  // Fall through.
    1111             :     case IrOpcode::kNumberBitwiseAnd:
    1112       10108 :       return machine()->Word32And();
    1113             :     case IrOpcode::kNumberEqual:
    1114             :     case IrOpcode::kSpeculativeNumberEqual:
    1115        9770 :       return machine()->Word32Equal();
    1116             :     case IrOpcode::kNumberLessThan:
    1117             :     case IrOpcode::kSpeculativeNumberLessThan:
    1118       64208 :       return machine()->Int32LessThan();
    1119             :     case IrOpcode::kNumberLessThanOrEqual:
    1120             :     case IrOpcode::kSpeculativeNumberLessThanOrEqual:
    1121        1569 :       return machine()->Int32LessThanOrEqual();
    1122             :     default:
    1123           0 :       UNREACHABLE();
    1124             :   }
    1125             : }
    1126             : 
    1127      136890 : const Operator* RepresentationChanger::Int32OverflowOperatorFor(
    1128             :     IrOpcode::Value opcode) {
    1129      136890 :   switch (opcode) {
    1130             :     case IrOpcode::kSpeculativeSafeIntegerAdd:
    1131      131942 :       return simplified()->CheckedInt32Add();
    1132             :     case IrOpcode::kSpeculativeSafeIntegerSubtract:
    1133        3462 :       return simplified()->CheckedInt32Sub();
    1134             :     case IrOpcode::kSpeculativeNumberDivide:
    1135         242 :       return simplified()->CheckedInt32Div();
    1136             :     case IrOpcode::kSpeculativeNumberModulus:
    1137        1244 :       return simplified()->CheckedInt32Mod();
    1138             :     default:
    1139           0 :       UNREACHABLE();
    1140             :   }
    1141             : }
    1142             : 
    1143         837 : const Operator* RepresentationChanger::Int64OperatorFor(
    1144             :     IrOpcode::Value opcode) {
    1145             :   switch (opcode) {
    1146             :     case IrOpcode::kSpeculativeNumberAdd:  // Fall through.
    1147             :     case IrOpcode::kSpeculativeSafeIntegerAdd:
    1148             :     case IrOpcode::kNumberAdd:
    1149         386 :       return machine()->Int64Add();
    1150             :     case IrOpcode::kSpeculativeNumberSubtract:  // Fall through.
    1151             :     case IrOpcode::kSpeculativeSafeIntegerSubtract:
    1152             :     case IrOpcode::kNumberSubtract:
    1153         451 :       return machine()->Int64Sub();
    1154             :     default:
    1155           0 :       UNREACHABLE();
    1156             :   }
    1157             : }
    1158             : 
    1159       14130 : const Operator* RepresentationChanger::TaggedSignedOperatorFor(
    1160             :     IrOpcode::Value opcode) {
    1161       14130 :   switch (opcode) {
    1162             :     case IrOpcode::kSpeculativeNumberLessThan:
    1163             :       return machine()->Is32() ? machine()->Int32LessThan()
    1164        5281 :                                : machine()->Int64LessThan();
    1165             :     case IrOpcode::kSpeculativeNumberLessThanOrEqual:
    1166             :       return machine()->Is32() ? machine()->Int32LessThanOrEqual()
    1167         328 :                                : machine()->Int64LessThanOrEqual();
    1168             :     case IrOpcode::kSpeculativeNumberEqual:
    1169             :       return machine()->Is32() ? machine()->Word32Equal()
    1170        8521 :                                : machine()->Word64Equal();
    1171             :     default:
    1172           0 :       UNREACHABLE();
    1173             :   }
    1174             : }
    1175             : 
    1176       36370 : const Operator* RepresentationChanger::Uint32OperatorFor(
    1177             :     IrOpcode::Value opcode) {
    1178       36370 :   switch (opcode) {
    1179             :     case IrOpcode::kNumberAdd:
    1180           0 :       return machine()->Int32Add();
    1181             :     case IrOpcode::kNumberSubtract:
    1182           0 :       return machine()->Int32Sub();
    1183             :     case IrOpcode::kSpeculativeNumberMultiply:
    1184             :     case IrOpcode::kNumberMultiply:
    1185           0 :       return machine()->Int32Mul();
    1186             :     case IrOpcode::kSpeculativeNumberDivide:
    1187             :     case IrOpcode::kNumberDivide:
    1188           0 :       return machine()->Uint32Div();
    1189             :     case IrOpcode::kSpeculativeNumberModulus:
    1190             :     case IrOpcode::kNumberModulus:
    1191           0 :       return machine()->Uint32Mod();
    1192             :     case IrOpcode::kNumberEqual:
    1193             :     case IrOpcode::kSpeculativeNumberEqual:
    1194       12835 :       return machine()->Word32Equal();
    1195             :     case IrOpcode::kNumberLessThan:
    1196             :     case IrOpcode::kSpeculativeNumberLessThan:
    1197       21083 :       return machine()->Uint32LessThan();
    1198             :     case IrOpcode::kNumberLessThanOrEqual:
    1199             :     case IrOpcode::kSpeculativeNumberLessThanOrEqual:
    1200        1546 :       return machine()->Uint32LessThanOrEqual();
    1201             :     case IrOpcode::kNumberClz32:
    1202          34 :       return machine()->Word32Clz();
    1203             :     case IrOpcode::kNumberImul:
    1204         872 :       return machine()->Int32Mul();
    1205             :     default:
    1206           0 :       UNREACHABLE();
    1207             :   }
    1208             : }
    1209             : 
    1210         138 : const Operator* RepresentationChanger::Uint32OverflowOperatorFor(
    1211             :     IrOpcode::Value opcode) {
    1212         138 :   switch (opcode) {
    1213             :     case IrOpcode::kSpeculativeNumberDivide:
    1214          94 :       return simplified()->CheckedUint32Div();
    1215             :     case IrOpcode::kSpeculativeNumberModulus:
    1216          44 :       return simplified()->CheckedUint32Mod();
    1217             :     default:
    1218           0 :       UNREACHABLE();
    1219             :   }
    1220             : }
    1221             : 
    1222      175619 : const Operator* RepresentationChanger::Float64OperatorFor(
    1223             :     IrOpcode::Value opcode) {
    1224      175619 :   switch (opcode) {
    1225             :     case IrOpcode::kSpeculativeNumberAdd:
    1226             :     case IrOpcode::kSpeculativeSafeIntegerAdd:
    1227             :     case IrOpcode::kNumberAdd:
    1228       74487 :       return machine()->Float64Add();
    1229             :     case IrOpcode::kSpeculativeNumberSubtract:
    1230             :     case IrOpcode::kSpeculativeSafeIntegerSubtract:
    1231             :     case IrOpcode::kNumberSubtract:
    1232        2058 :       return machine()->Float64Sub();
    1233             :     case IrOpcode::kSpeculativeNumberMultiply:
    1234             :     case IrOpcode::kNumberMultiply:
    1235       13730 :       return machine()->Float64Mul();
    1236             :     case IrOpcode::kSpeculativeNumberDivide:
    1237             :     case IrOpcode::kNumberDivide:
    1238       16354 :       return machine()->Float64Div();
    1239             :     case IrOpcode::kSpeculativeNumberModulus:
    1240             :     case IrOpcode::kNumberModulus:
    1241        1852 :       return machine()->Float64Mod();
    1242             :     case IrOpcode::kNumberEqual:
    1243             :     case IrOpcode::kSpeculativeNumberEqual:
    1244       17238 :       return machine()->Float64Equal();
    1245             :     case IrOpcode::kNumberLessThan:
    1246             :     case IrOpcode::kSpeculativeNumberLessThan:
    1247        3899 :       return machine()->Float64LessThan();
    1248             :     case IrOpcode::kNumberLessThanOrEqual:
    1249             :     case IrOpcode::kSpeculativeNumberLessThanOrEqual:
    1250         269 :       return machine()->Float64LessThanOrEqual();
    1251             :     case IrOpcode::kNumberAbs:
    1252         189 :       return machine()->Float64Abs();
    1253             :     case IrOpcode::kNumberAcos:
    1254           0 :       return machine()->Float64Acos();
    1255             :     case IrOpcode::kNumberAcosh:
    1256           0 :       return machine()->Float64Acosh();
    1257             :     case IrOpcode::kNumberAsin:
    1258           7 :       return machine()->Float64Asin();
    1259             :     case IrOpcode::kNumberAsinh:
    1260           0 :       return machine()->Float64Asinh();
    1261             :     case IrOpcode::kNumberAtan:
    1262           0 :       return machine()->Float64Atan();
    1263             :     case IrOpcode::kNumberAtanh:
    1264           0 :       return machine()->Float64Atanh();
    1265             :     case IrOpcode::kNumberAtan2:
    1266           0 :       return machine()->Float64Atan2();
    1267             :     case IrOpcode::kNumberCbrt:
    1268           0 :       return machine()->Float64Cbrt();
    1269             :     case IrOpcode::kNumberCeil:
    1270        6955 :       return machine()->Float64RoundUp().placeholder();
    1271             :     case IrOpcode::kNumberCos:
    1272          14 :       return machine()->Float64Cos();
    1273             :     case IrOpcode::kNumberCosh:
    1274           7 :       return machine()->Float64Cosh();
    1275             :     case IrOpcode::kNumberExp:
    1276          33 :       return machine()->Float64Exp();
    1277             :     case IrOpcode::kNumberExpm1:
    1278          14 :       return machine()->Float64Expm1();
    1279             :     case IrOpcode::kNumberFloor:
    1280       28153 :       return machine()->Float64RoundDown().placeholder();
    1281             :     case IrOpcode::kNumberFround:
    1282        1285 :       return machine()->TruncateFloat64ToFloat32();
    1283             :     case IrOpcode::kNumberLog:
    1284         163 :       return machine()->Float64Log();
    1285             :     case IrOpcode::kNumberLog1p:
    1286           0 :       return machine()->Float64Log1p();
    1287             :     case IrOpcode::kNumberLog2:
    1288           0 :       return machine()->Float64Log2();
    1289             :     case IrOpcode::kNumberLog10:
    1290           0 :       return machine()->Float64Log10();
    1291             :     case IrOpcode::kNumberMax:
    1292          72 :       return machine()->Float64Max();
    1293             :     case IrOpcode::kNumberMin:
    1294         149 :       return machine()->Float64Min();
    1295             :     case IrOpcode::kNumberPow:
    1296         910 :       return machine()->Float64Pow();
    1297             :     case IrOpcode::kNumberSin:
    1298          33 :       return machine()->Float64Sin();
    1299             :     case IrOpcode::kNumberSinh:
    1300           7 :       return machine()->Float64Sinh();
    1301             :     case IrOpcode::kNumberSqrt:
    1302          51 :       return machine()->Float64Sqrt();
    1303             :     case IrOpcode::kNumberTan:
    1304          28 :       return machine()->Float64Tan();
    1305             :     case IrOpcode::kNumberTanh:
    1306           7 :       return machine()->Float64Tanh();
    1307             :     case IrOpcode::kNumberTrunc:
    1308        6914 :       return machine()->Float64RoundTruncate().placeholder();
    1309             :     case IrOpcode::kNumberSilenceNaN:
    1310         741 :       return machine()->Float64SilenceNaN();
    1311             :     default:
    1312           0 :       UNREACHABLE();
    1313             :   }
    1314             : }
    1315             : 
    1316          35 : Node* RepresentationChanger::TypeError(Node* node,
    1317             :                                        MachineRepresentation output_rep,
    1318             :                                        Type output_type,
    1319             :                                        MachineRepresentation use) {
    1320          35 :   type_error_ = true;
    1321          35 :   if (!testing_type_errors_) {
    1322           0 :     std::ostringstream out_str;
    1323           0 :     out_str << output_rep << " (";
    1324           0 :     output_type.PrintTo(out_str);
    1325           0 :     out_str << ")";
    1326             : 
    1327           0 :     std::ostringstream use_str;
    1328           0 :     use_str << use;
    1329             : 
    1330             :     FATAL(
    1331             :         "RepresentationChangerError: node #%d:%s of "
    1332             :         "%s cannot be changed to %s",
    1333             :         node->id(), node->op()->mnemonic(), out_str.str().c_str(),
    1334           0 :         use_str.str().c_str());
    1335             :   }
    1336          35 :   return node;
    1337             : }
    1338             : 
    1339           0 : Node* RepresentationChanger::InsertChangeBitToTagged(Node* node) {
    1340           0 :   return jsgraph()->graph()->NewNode(simplified()->ChangeBitToTagged(), node);
    1341             : }
    1342             : 
    1343         426 : Node* RepresentationChanger::InsertChangeFloat32ToFloat64(Node* node) {
    1344         852 :   return jsgraph()->graph()->NewNode(machine()->ChangeFloat32ToFloat64(), node);
    1345             : }
    1346             : 
    1347          23 : Node* RepresentationChanger::InsertChangeFloat64ToUint32(Node* node) {
    1348          46 :   return jsgraph()->graph()->NewNode(machine()->ChangeFloat64ToUint32(), node);
    1349             : }
    1350             : 
    1351         530 : Node* RepresentationChanger::InsertChangeFloat64ToInt32(Node* node) {
    1352        1060 :   return jsgraph()->graph()->NewNode(machine()->ChangeFloat64ToInt32(), node);
    1353             : }
    1354             : 
    1355          14 : Node* RepresentationChanger::InsertChangeInt32ToFloat64(Node* node) {
    1356          28 :   return jsgraph()->graph()->NewNode(machine()->ChangeInt32ToFloat64(), node);
    1357             : }
    1358             : 
    1359        1228 : Node* RepresentationChanger::InsertChangeTaggedSignedToInt32(Node* node) {
    1360        1228 :   return jsgraph()->graph()->NewNode(simplified()->ChangeTaggedSignedToInt32(),
    1361        1228 :                                      node);
    1362             : }
    1363             : 
    1364           0 : Node* RepresentationChanger::InsertChangeTaggedToFloat64(Node* node) {
    1365           0 :   return jsgraph()->graph()->NewNode(simplified()->ChangeTaggedToFloat64(),
    1366           0 :                                      node);
    1367             : }
    1368             : 
    1369           0 : Node* RepresentationChanger::InsertChangeUint32ToFloat64(Node* node) {
    1370           0 :   return jsgraph()->graph()->NewNode(machine()->ChangeUint32ToFloat64(), node);
    1371             : }
    1372             : 
    1373          27 : Node* RepresentationChanger::InsertTruncateInt64ToInt32(Node* node) {
    1374          54 :   return jsgraph()->graph()->NewNode(machine()->TruncateInt64ToInt32(), node);
    1375             : }
    1376             : 
    1377             : }  // namespace compiler
    1378             : }  // namespace internal
    1379      120216 : }  // namespace v8

Generated by: LCOV version 1.10