Lines Matching refs:node
11 #include "src/compiler/node-matchers.h"
52 for (Node* const phi : *block) {
56 for (Node* const input : phi->inputs()) {
222 bool InstructionSelector::CanCover(Node* user, Node* node) const {
223 // 1. Both {user} and {node} must be in the same basic block.
224 if (schedule()->block(node) != schedule()->block(user)) {
227 // 2. Pure {node}s must be owned by the {user}.
228 if (node->op()->HasProperty(Operator::kPure)) {
229 return node->OwnedBy(user);
231 // 3. Impure {node}s must match the effect level of {user}.
232 if (GetEffectLevel(node) != GetEffectLevel(user)) {
235 // 4. Only {node} must have value edges pointing to {user}.
236 for (Edge const edge : node->use_edges()) {
244 int InstructionSelector::GetVirtualRegister(const Node* node) {
245 DCHECK_NOT_NULL(node);
246 size_t const id = node->id();
270 bool InstructionSelector::IsDefined(Node* node) const {
271 DCHECK_NOT_NULL(node);
272 size_t const id = node->id();
278 void InstructionSelector::MarkAsDefined(Node* node) {
279 DCHECK_NOT_NULL(node);
280 size_t const id = node->id();
286 bool InstructionSelector::IsUsed(Node* node) const {
287 DCHECK_NOT_NULL(node);
288 if (!node->op()->HasProperty(Operator::kEliminatable)) return true;
289 size_t const id = node->id();
295 void InstructionSelector::MarkAsUsed(Node* node) {
296 DCHECK_NOT_NULL(node);
297 size_t const id = node->id();
302 int InstructionSelector::GetEffectLevel(Node* node) const {
303 DCHECK_NOT_NULL(node);
304 size_t const id = node->id();
309 void InstructionSelector::SetEffectLevel(Node* node, int effect_level) {
310 DCHECK_NOT_NULL(node);
311 size_t const id = node->id();
324 Node* node) {
325 sequence()->MarkAsRepresentation(rep, GetVirtualRegister(node));
334 InstructionOperand OperandForDeopt(OperandGenerator* g, Node* input,
364 size_t GetObjectId(Node* node) {
366 if (objects_[i] == node) {
373 size_t InsertObject(Node* node) {
375 objects_.push_back(node);
380 ZoneVector<Node*> objects_;
389 Node* input, MachineType type,
427 Node* state, OperandGenerator* g,
443 Node* parameters = state->InputAt(kFrameStateParametersInput);
444 Node* locals = state->InputAt(kFrameStateLocalsInput);
445 Node* stack = state->InputAt(kFrameStateStackInput);
446 Node* context = state->InputAt(kFrameStateContextInput);
447 Node* function = state->InputAt(kFrameStateFunctionInput);
462 deduplicator, input_node.node,
472 deduplicator, input_node.node,
477 deduplicator, input_node.node,
528 void InstructionSelector::InitializeCallBuffer(Node* call, CallBuffer* buffer,
568 Node* output = buffer->output_nodes[i];
581 Node* callee = call->InputAt(0);
613 Node* frame_state =
707 for (Node* const node : *block) {
708 if (node->opcode() == IrOpcode::kStore ||
709 node->opcode() == IrOpcode::kCheckedStore ||
710 node->opcode() == IrOpcode::kCall) {
713 SetEffectLevel(node, effect_level);
717 // control input should be on the same effect level as the last node.
728 // matching may cover more than one node at a time.
729 for (auto node : base::Reversed(*block)) {
731 if (!IsUsed(node) || IsDefined(node)) continue;
732 // Generate code for this node "top down", but schedule the code "bottom
735 VisitNode(node);
739 SourcePosition source_position = source_positions_->GetSourcePosition(node);
742 node->opcode() == IrOpcode::kCall)) {
764 for (Node* const node : *successor) {
765 CHECK(!IrOpcode::IsPhiOpcode(node->opcode()));
771 Node* input = block->control_input();
826 Node* value = input->InputAt(0);
844 void InstructionSelector::VisitNode(Node* node) {
845 DCHECK_NOT_NULL(schedule()->block(node)); // should only use scheduled nodes.
846 switch (node->opcode()) {
864 return MarkAsReference(node), VisitIfException(node);
866 return MarkAsReference(node), VisitFinishRegion(node);
869 linkage()->GetParameterType(ParameterIndexOf(node->op()));
870 MarkAsRepresentation(type.representation(), node);
871 return VisitParameter(node);
874 return MarkAsReference(node), VisitOsrValue(node);
876 MachineRepresentation rep = PhiRepresentationOf(node->op());
877 MarkAsRepresentation(rep, node);
878 return VisitPhi(node);
881 return VisitProjection(node);
887 return VisitConstant(node);
889 return MarkAsFloat32(node), VisitConstant(node);
891 return MarkAsFloat64(node), VisitConstant(node);
893 return MarkAsReference(node), VisitConstant(node);
895 double value = OpParameter<double>(node);
896 if (!IsSmiDouble(value)) MarkAsReference(node);
897 return VisitConstant(node);
900 return VisitCall(node);
902 return VisitDeoptimizeIf(node);
904 return VisitDeoptimizeUnless(node);
910 VisitDebugBreak(node);
913 VisitComment(node);
916 LoadRepresentation type = LoadRepresentationOf(node->op());
917 MarkAsRepresentation(type.representation(), node);
918 return VisitLoad(node);
921 return VisitStore(node);
923 return MarkAsWord32(node), VisitWord32And(node);
925 return MarkAsWord32(node), VisitWord32Or(node);
927 return MarkAsWord32(node), VisitWord32Xor(node);
929 return MarkAsWord32(node), VisitWord32Shl(node);
931 return MarkAsWord32(node), VisitWord32Shr(node);
933 return MarkAsWord32(node), VisitWord32Sar(node);
935 return MarkAsWord32(node), VisitWord32Ror(node);
937 return VisitWord32Equal(node);
939 return MarkAsWord32(node), VisitWord32Clz(node);
941 return MarkAsWord32(node), VisitWord32Ctz(node);
943 return MarkAsWord32(node), VisitWord32ReverseBits(node);
945 return MarkAsWord32(node), VisitWord32Popcnt(node);
947 return MarkAsWord32(node), VisitWord64Popcnt(node);
949 return MarkAsWord64(node), VisitWord64And(node);
951 return MarkAsWord64(node), VisitWord64Or(node);
953 return MarkAsWord64(node), VisitWord64Xor(node);
955 return MarkAsWord64(node), VisitWord64Shl(node);
957 return MarkAsWord64(node), VisitWord64Shr(node);
959 return MarkAsWord64(node), VisitWord64Sar(node);
961 return MarkAsWord64(node), VisitWord64Ror(node);
963 return MarkAsWord64(node), VisitWord64Clz(node);
965 return MarkAsWord64(node), VisitWord64Ctz(node);
967 return MarkAsWord64(node), VisitWord64ReverseBits(node);
969 return VisitWord64Equal(node);
971 return MarkAsWord32(node), VisitInt32Add(node);
973 return MarkAsWord32(node), VisitInt32AddWithOverflow(node);
975 return MarkAsWord32(node), VisitInt32Sub(node);
977 return VisitInt32SubWithOverflow(node);
979 return MarkAsWord32(node), VisitInt32Mul(node);
981 return VisitInt32MulHigh(node);
983 return MarkAsWord32(node), VisitInt32Div(node);
985 return MarkAsWord32(node), VisitInt32Mod(node);
987 return VisitInt32LessThan(node);
989 return VisitInt32LessThanOrEqual(node);
991 return MarkAsWord32(node), VisitUint32Div(node);
993 return VisitUint32LessThan(node);
995 return VisitUint32LessThanOrEqual(node);
997 return MarkAsWord32(node), VisitUint32Mod(node);
999 return VisitUint32MulHigh(node);
1001 return MarkAsWord64(node), VisitInt64Add(node);
1003 return MarkAsWord64(node), VisitInt64AddWithOverflow(node);
1005 return MarkAsWord64(node), VisitInt64Sub(node);
1007 return MarkAsWord64(node), VisitInt64SubWithOverflow(node);
1009 return MarkAsWord64(node), VisitInt64Mul(node);
1011 return MarkAsWord64(node), VisitInt64Div(node);
1013 return MarkAsWord64(node), VisitInt64Mod(node);
1015 return VisitInt64LessThan(node);
1017 return VisitInt64LessThanOrEqual(node);
1019 return MarkAsWord64(node), VisitUint64Div(node);
1021 return VisitUint64LessThan(node);
1023 return VisitUint64LessThanOrEqual(node);
1025 return MarkAsWord64(node), VisitUint64Mod(node);
1027 return MarkAsReference(node), VisitBitcastWordToTagged(node);
1029 return MarkAsFloat64(node), VisitChangeFloat32ToFloat64(node);
1031 return MarkAsFloat64(node), VisitChangeInt32ToFloat64(node);
1033 return MarkAsFloat64(node), VisitChangeUint32ToFloat64(node);
1035 return MarkAsWord32(node), VisitChangeFloat64ToInt32(node);
1037 return MarkAsWord32(node), VisitChangeFloat64ToUint32(node);
1039 MarkAsFloat64(node);
1040 if (CanProduceSignalingNaN(node->InputAt(0))) {
1041 return VisitFloat64SilenceNaN(node);
1043 return EmitIdentity(node);
1046 return MarkAsWord32(node), VisitTruncateFloat64ToUint32(node);
1048 return MarkAsWord32(node), VisitTruncateFloat32ToInt32(node);
1050 return MarkAsWord32(node), VisitTruncateFloat32ToUint32(node);
1052 return MarkAsWord64(node), VisitTryTruncateFloat32ToInt64(node);
1054 return MarkAsWord64(node), VisitTryTruncateFloat64ToInt64(node);
1056 return MarkAsWord64(node), VisitTryTruncateFloat32ToUint64(node);
1058 return MarkAsWord64(node), VisitTryTruncateFloat64ToUint64(node);
1060 return MarkAsWord64(node), VisitChangeInt32ToInt64(node);
1062 return MarkAsWord64(node), VisitChangeUint32ToUint64(node);
1064 return MarkAsFloat32(node), VisitTruncateFloat64ToFloat32(node);
1066 return MarkAsWord32(node), VisitTruncateFloat64ToWord32(node);
1068 return MarkAsWord32(node), VisitTruncateInt64ToInt32(node);
1070 return MarkAsWord32(node), VisitRoundFloat64ToInt32(node);
1072 return MarkAsFloat32(node), VisitRoundInt64ToFloat32(node);
1074 return MarkAsFloat32(node), VisitRoundInt32ToFloat32(node);
1076 return MarkAsFloat64(node), VisitRoundInt64ToFloat64(node);
1078 return MarkAsWord32(node), VisitBitcastFloat32ToInt32(node);
1080 return MarkAsFloat32(node), VisitRoundUint32ToFloat32(node);
1082 return MarkAsFloat64(node), VisitRoundUint64ToFloat32(node);
1084 return MarkAsFloat64(node), VisitRoundUint64ToFloat64(node);
1086 return MarkAsWord64(node), VisitBitcastFloat64ToInt64(node);
1088 return MarkAsFloat32(node), VisitBitcastInt32ToFloat32(node);
1090 return MarkAsFloat64(node), VisitBitcastInt64ToFloat64(node);
1092 return MarkAsFloat32(node), VisitFloat32Add(node);
1094 return MarkAsFloat32(node), VisitFloat32Sub(node);
1096 return MarkAsFloat32(node), VisitFloat32SubPreserveNan(node);
1098 return MarkAsFloat32(node), VisitFloat32Neg(node);
1100 return MarkAsFloat32(node), VisitFloat32Mul(node);
1102 return MarkAsFloat32(node), VisitFloat32Div(node);
1104 return MarkAsFloat32(node), VisitFloat32Min(node);
1106 return MarkAsFloat32(node), VisitFloat32Max(node);
1108 return MarkAsFloat32(node), VisitFloat32Abs(node);
1110 return MarkAsFloat32(node), VisitFloat32Sqrt(node);
1112 return VisitFloat32Equal(node);
1114 return VisitFloat32LessThan(node);
1116 return VisitFloat32LessThanOrEqual(node);
1118 return MarkAsFloat64(node), VisitFloat64Add(node);
1120 return MarkAsFloat64(node), VisitFloat64Sub(node);
1122 return MarkAsFloat64(node), VisitFloat64SubPreserveNan(node);
1124 return MarkAsFloat64(node), VisitFloat64Neg(node);
1126 return MarkAsFloat64(node), VisitFloat64Mul(node);
1128 return MarkAsFloat64(node), VisitFloat64Div(node);
1130 return MarkAsFloat64(node), VisitFloat64Mod(node);
1132 return MarkAsFloat64(node), VisitFloat64Min(node);
1134 return MarkAsFloat64(node), VisitFloat64Max(node);
1136 return MarkAsFloat64(node), VisitFloat64Abs(node);
1138 return MarkAsFloat64(node), VisitFloat64Atan(node);
1140 return MarkAsFloat64(node), VisitFloat64Atan2(node);
1142 return MarkAsFloat64(node), VisitFloat64Atanh(node);
1144 return MarkAsFloat64(node), VisitFloat64Cbrt(node);
1146 return MarkAsFloat64(node), VisitFloat64Cos(node);
1148 return MarkAsFloat64(node), VisitFloat64Exp(node);
1150 return MarkAsFloat64(node), VisitFloat64Expm1(node);
1152 return MarkAsFloat64(node), VisitFloat64Log(node);
1154 return MarkAsFloat64(node), VisitFloat64Log1p(node);
1156 return MarkAsFloat64(node), VisitFloat64Log10(node);
1158 return MarkAsFloat64(node), VisitFloat64Log2(node);
1160 return MarkAsFloat64(node), VisitFloat64Sin(node);
1162 return MarkAsFloat64(node), VisitFloat64Sqrt(node);
1164 return MarkAsFloat64(node), VisitFloat64Tan(node);
1166 return VisitFloat64Equal(node);
1168 return VisitFloat64LessThan(node);
1170 return VisitFloat64LessThanOrEqual(node);
1172 return MarkAsFloat32(node), VisitFloat32RoundDown(node);
1174 return MarkAsFloat64(node), VisitFloat64RoundDown(node);
1176 return MarkAsFloat32(node), VisitFloat32RoundUp(node);
1178 return MarkAsFloat64(node), VisitFloat64RoundUp(node);
1180 return MarkAsFloat32(node), VisitFloat32RoundTruncate(node);
1182 return MarkAsFloat64(node), VisitFloat64RoundTruncate(node);
1184 return MarkAsFloat64(node), VisitFloat64RoundTiesAway(node);
1186 return MarkAsFloat32(node), VisitFloat32RoundTiesEven(node);
1188 return MarkAsFloat64(node), VisitFloat64RoundTiesEven(node);
1190 return MarkAsWord32(node), VisitFloat64ExtractLowWord32(node);
1192 return MarkAsWord32(node), VisitFloat64ExtractHighWord32(node);
1194 return MarkAsFloat64(node), VisitFloat64InsertLowWord32(node);
1196 return MarkAsFloat64(node), VisitFloat64InsertHighWord32(node);
1198 return VisitStackSlot(node);
1200 return VisitLoadStackPointer(node);
1202 return VisitLoadFramePointer(node);
1204 return VisitLoadParentFramePointer(node);
1207 CheckedLoadRepresentationOf(node->op()).representation();
1208 MarkAsRepresentation(rep, node);
1209 return VisitCheckedLoad(node);
1212 return VisitCheckedStore(node);
1214 MarkAsWord32(NodeProperties::FindProjection(node, 0));
1215 MarkAsWord32(NodeProperties::FindProjection(node, 1));
1216 return VisitInt32PairAdd(node);
1218 MarkAsWord32(NodeProperties::FindProjection(node, 0));
1219 MarkAsWord32(NodeProperties::FindProjection(node, 1));
1220 return VisitInt32PairSub(node);
1222 MarkAsWord32(NodeProperties::FindProjection(node, 0));
1223 MarkAsWord32(NodeProperties::FindProjection(node, 1));
1224 return VisitInt32PairMul(node);
1226 MarkAsWord32(NodeProperties::FindProjection(node, 0));
1227 MarkAsWord32(NodeProperties::FindProjection(node, 1));
1228 return VisitWord32PairShl(node);
1230 MarkAsWord32(NodeProperties::FindProjection(node, 0));
1231 MarkAsWord32(NodeProperties::FindProjection(node, 1));
1232 return VisitWord32PairShr(node);
1234 MarkAsWord32(NodeProperties::FindProjection(node, 0));
1235 MarkAsWord32(NodeProperties::FindProjection(node, 1));
1236 return VisitWord32PairSar(node);
1238 LoadRepresentation type = LoadRepresentationOf(node->op());
1239 MarkAsRepresentation(type.representation(), node);
1240 return VisitAtomicLoad(node);
1243 return VisitAtomicStore(node);
1245 V8_Fatal(__FILE__, __LINE__, "Unexpected operator #%d:%s @ node #%d",
1246 nodenode->op()->mnemonic(), node->id());
1252 void InstructionSelector::VisitLoadStackPointer(Node* node) {
1254 Emit(kArchStackPointer, g.DefineAsRegister(node));
1258 void InstructionSelector::VisitLoadFramePointer(Node* node) {
1260 Emit(kArchFramePointer, g.DefineAsRegister(node));
1263 void InstructionSelector::VisitLoadParentFramePointer(Node* node) {
1265 Emit(kArchParentFramePointer, g.DefineAsRegister(node));
1268 void InstructionSelector::VisitFloat64Atan(Node* node) {
1269 VisitFloat64Ieee754Unop(node, kIeee754Float64Atan);
1272 void InstructionSelector::VisitFloat64Atan2(Node* node) {
1273 VisitFloat64Ieee754Binop(node, kIeee754Float64Atan2);
1276 void InstructionSelector::VisitFloat64Atanh(Node* node) {
1277 VisitFloat64Ieee754Unop(node, kIeee754Float64Atanh);
1280 void InstructionSelector::VisitFloat64Cbrt(Node* node) {
1281 VisitFloat64Ieee754Unop(node, kIeee754Float64Cbrt);
1284 void InstructionSelector::VisitFloat64Cos(Node* node) {
1285 VisitFloat64Ieee754Unop(node, kIeee754Float64Cos);
1288 void InstructionSelector::VisitFloat64Exp(Node* node) {
1289 VisitFloat64Ieee754Unop(node, kIeee754Float64Exp);
1292 void InstructionSelector::VisitFloat64Expm1(Node* node) {
1293 VisitFloat64Ieee754Unop(node, kIeee754Float64Expm1);
1296 void InstructionSelector::VisitFloat64Log(Node* node) {
1297 VisitFloat64Ieee754Unop(node, kIeee754Float64Log);
1300 void InstructionSelector::VisitFloat64Log1p(Node* node) {
1301 VisitFloat64Ieee754Unop(node, kIeee754Float64Log1p);
1304 void InstructionSelector::VisitFloat64Log2(Node* node) {
1305 VisitFloat64Ieee754Unop(node, kIeee754Float64Log2);
1308 void InstructionSelector::VisitFloat64Log10(Node* node) {
1309 VisitFloat64Ieee754Unop(node, kIeee754Float64Log10);
1312 void InstructionSelector::VisitFloat64Sin(Node* node) {
1313 VisitFloat64Ieee754Unop(node, kIeee754Float64Sin);
1316 void InstructionSelector::VisitFloat64Tan(Node* node) {
1317 VisitFloat64Ieee754Unop(node, kIeee754Float64Tan);
1355 void InstructionSelector::VisitStackSlot(Node* node) {
1356 int size = 1 << ElementSizeLog2Of(StackSlotRepresentationOf(node->op()));
1360 Emit(kArchStackSlot, g.DefineAsRegister(node),
1364 void InstructionSelector::VisitBitcastWordToTagged(Node* node) {
1365 EmitIdentity(node);
1371 void InstructionSelector::VisitWord64And(Node* node) { UNIMPLEMENTED(); }
1374 void InstructionSelector::VisitWord64Or(Node* node) { UNIMPLEMENTED(); }
1377 void InstructionSelector::VisitWord64Xor(Node* node) { UNIMPLEMENTED(); }
1380 void InstructionSelector::VisitWord64Shl(Node* node) { UNIMPLEMENTED(); }
1383 void InstructionSelector::VisitWord64Shr(Node* node) { UNIMPLEMENTED(); }
1386 void InstructionSelector::VisitWord64Sar(Node* node) { UNIMPLEMENTED(); }
1389 void InstructionSelector::VisitWord64Ror(Node* node) { UNIMPLEMENTED(); }
1392 void InstructionSelector::VisitWord64Clz(Node* node) { UNIMPLEMENTED(); }
1395 void InstructionSelector::VisitWord64Ctz(Node* node) { UNIMPLEMENTED(); }
1398 void InstructionSelector::VisitWord64ReverseBits(Node* node) {
1403 void InstructionSelector::VisitWord64Popcnt(Node* node) { UNIMPLEMENTED(); }
1406 void InstructionSelector::VisitWord64Equal(Node* node) { UNIMPLEMENTED(); }
1409 void InstructionSelector::VisitInt64Add(Node* node) { UNIMPLEMENTED(); }
1412 void InstructionSelector::VisitInt64AddWithOverflow(Node* node) {
1417 void InstructionSelector::VisitInt64Sub(Node* node) { UNIMPLEMENTED(); }
1420 void InstructionSelector::VisitInt64SubWithOverflow(Node* node) {
1425 void InstructionSelector::VisitInt64Mul(Node* node) { UNIMPLEMENTED(); }
1428 void InstructionSelector::VisitInt64Div(Node* node) { UNIMPLEMENTED(); }
1431 void InstructionSelector::VisitInt64LessThan(Node* node) { UNIMPLEMENTED(); }
1434 void InstructionSelector::VisitInt64LessThanOrEqual(Node* node) {
1439 void InstructionSelector::VisitUint64Div(Node* node) { UNIMPLEMENTED(); }
1442 void InstructionSelector::VisitInt64Mod(Node* node) { UNIMPLEMENTED(); }
1445 void InstructionSelector::VisitUint64LessThan(Node* node) { UNIMPLEMENTED(); }
1448 void InstructionSelector::VisitUint64LessThanOrEqual(Node* node) {
1453 void InstructionSelector::VisitUint64Mod(Node* node) { UNIMPLEMENTED(); }
1456 void InstructionSelector::VisitChangeInt32ToInt64(Node* node) {
1461 void InstructionSelector::VisitChangeUint32ToUint64(Node* node) {
1466 void InstructionSelector::VisitTryTruncateFloat32ToInt64(Node* node) {
1471 void InstructionSelector::VisitTryTruncateFloat64ToInt64(Node* node) {
1476 void InstructionSelector::VisitTryTruncateFloat32ToUint64(Node* node) {
1481 void InstructionSelector::VisitTryTruncateFloat64ToUint64(Node* node) {
1486 void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) {
1491 void InstructionSelector::VisitRoundInt64ToFloat32(Node* node) {
1496 void InstructionSelector::VisitRoundInt64ToFloat64(Node* node) {
1501 void InstructionSelector::VisitRoundUint64ToFloat32(Node* node) {
1506 void InstructionSelector::VisitRoundUint64ToFloat64(Node* node) {
1511 void InstructionSelector::VisitBitcastFloat64ToInt64(Node* node) {
1516 void InstructionSelector::VisitBitcastInt64ToFloat64(Node* node) {
1524 void InstructionSelector::VisitInt32PairAdd(Node* node) { UNIMPLEMENTED(); }
1526 void InstructionSelector::VisitInt32PairSub(Node* node) { UNIMPLEMENTED(); }
1528 void InstructionSelector::VisitInt32PairMul(Node* node) { UNIMPLEMENTED(); }
1530 void InstructionSelector::VisitWord32PairShl(Node* node) { UNIMPLEMENTED(); }
1532 void InstructionSelector::VisitWord32PairShr(Node* node) { UNIMPLEMENTED(); }
1534 void InstructionSelector::VisitWord32PairSar(Node* node) { UNIMPLEMENTED(); }
1537 void InstructionSelector::VisitFinishRegion(Node* node) { EmitIdentity(node); }
1539 void InstructionSelector::VisitParameter(Node* node) {
1541 int index = ParameterIndexOf(node->op());
1545 node, linkage()->GetParameterLocation(index),
1548 node, linkage()->GetParameterLocation(index),
1555 void InstructionSelector::VisitIfException(Node* node) {
1557 Node* call = node->InputAt(1);
1561 g.DefineAsLocation(node, descriptor->GetReturnLocation(0),
1566 void InstructionSelector::VisitOsrValue(Node* node) {
1568 int index = OpParameter<int>(node);
1569 Emit(kArchNop, g.DefineAsLocation(node, linkage()->GetOsrValueLocation(index),
1574 void InstructionSelector::VisitPhi(Node* node) {
1575 const int input_count = node->op()->ValueInputCount();
1577 PhiInstruction(instruction_zone(), GetVirtualRegister(node),
1583 Node* const input = node->InputAt(i);
1590 void InstructionSelector::VisitProjection(Node* node) {
1592 Node* value = node->InputAt(0);
1608 if (ProjectionIndexOf(node->op()) == 0u) {
1609 Emit(kArchNop, g.DefineSameAsFirst(node), g.Use(value));
1611 DCHECK(ProjectionIndexOf(node->op()) == 1u);
1621 void InstructionSelector::VisitConstant(Node* node) {
1625 Emit(kArchNop, g.DefineAsConstant(node));
1629 void InstructionSelector::VisitCall(Node* node, BasicBlock* handler) {
1631 const CallDescriptor* descriptor = CallDescriptorOf(node->op());
1636 node->InputAt(static_cast<int>(descriptor->InputCount())));
1647 InitializeCallBuffer(node, &buffer, call_buffer_flags);
1649 EmitPrepareArguments(&(buffer.pushed_nodes), descriptor, node);
1697 void InstructionSelector::VisitTailCall(Node* node) {
1699 CallDescriptor const* descriptor = CallDescriptorOf(node->op());
1705 if (linkage()->GetIncomingDescriptor()->CanTailCall(node,
1714 InitializeCallBuffer(node, &buffer, flags, stack_param_delta);
1766 node->InputAt(static_cast<int>(descriptor->InputCount())))
1776 InitializeCallBuffer(node, &buffer, flags);
1778 EmitPrepareArguments(&(buffer.pushed_nodes), descriptor, node);
1813 void InstructionSelector::VisitReturn(Node* ret) {
1833 Node* frame_state) {
1843 size_t input_count, InstructionOperand* inputs, Node* frame_state) {
1863 void InstructionSelector::EmitIdentity(Node* node) {
1865 Node* value = node->InputAt(0);
1866 Emit(kArchNop, g.DefineSameAsFirst(node), g.Use(value));
1869 void InstructionSelector::VisitDeoptimize(DeoptimizeKind kind, Node* value) {
1883 void InstructionSelector::VisitThrow(Node* value) {
1888 void InstructionSelector::VisitDebugBreak(Node* node) {
1893 void InstructionSelector::VisitComment(Node* node) {
1895 InstructionOperand operand(g.UseImmediate(node));
1899 bool InstructionSelector::CanProduceSignalingNaN(Node* node) {
1901 if (node->opcode() == IrOpcode::kFloat64Add ||
1902 node->opcode() == IrOpcode::kFloat64Sub ||
1903 node->opcode() == IrOpcode::kFloat64Mul) {
1910 Node* state) {
1926 Node* outer_node = state->InputAt(kFrameStateOuterStateInput);
