Lines Matching refs:Node
8 #include "src/compiler/node-matchers.h"
9 #include "src/compiler/node-properties.h"
27 InstructionOperand UseOperand(Node* node, InstructionCode opcode) {
28 if (CanBeImmediate(node, opcode)) {
29 return UseImmediate(node);
31 return UseRegister(node);
34 bool CanBeImmediate(Node* node, InstructionCode opcode) {
36 if (node->opcode() == IrOpcode::kInt32Constant)
37 value = OpParameter<int32_t>(node);
38 else if (node->opcode() == IrOpcode::kInt64Constant)
39 value = OpParameter<int64_t>(node);
70 Node* node) {
72 selector->Emit(opcode, g.DefineAsRegister(node),
73 g.UseRegister(node->InputAt(0)));
78 Node* node) {
80 selector->Emit(opcode, g.DefineAsRegister(node),
81 g.UseRegister(node->InputAt(0)),
82 g.UseRegister(node->InputAt(1)));
87 Node* node) {
89 selector->Emit(opcode, g.DefineAsRegister(node),
90 g.UseRegister(node->InputAt(0)),
91 g.UseOperand(node->InputAt(1), opcode));
95 static void VisitBinop(InstructionSelector* selector, Node* node,
98 Int32BinopMatcher m(node);
104 inputs[input_count++] = g.UseRegister(m.left().node());
105 inputs[input_count++] = g.UseOperand(m.right().node(), opcode);
112 outputs[output_count++] = g.DefineAsRegister(node);
127 static void VisitBinop(InstructionSelector* selector, Node* node,
130 VisitBinop(selector, node, opcode, &cont);
134 void InstructionSelector::VisitLoad(Node* node) {
135 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
137 Node* base = node->InputAt(0);
138 Node* index = node->InputAt(1);
169 g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(index));
176 g.DefineAsRegister(node), addr_reg, g.TempImmediate(0));
181 void InstructionSelector::VisitStore(Node* node) {
183 Node* base = node->InputAt(0);
184 Node* index = node->InputAt(1);
185 Node* value = node->InputAt(2);
187 StoreRepresentation store_rep = StoreRepresentationOf(node->op());
264 void InstructionSelector::VisitWord32And(Node* node) {
266 Int32BinopMatcher m(node);
267 if (m.left().IsWord32Shr() && CanCover(node, m.left().node()) &&
278 Int32BinopMatcher mleft(m.left().node());
289 Emit(kMips64Ext, g.DefineAsRegister(node),
290 g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
304 Emit(kMips64Ins, g.DefineSameAsFirst(node),
305 g.UseRegister(m.left().node()), g.TempImmediate(0),
310 VisitBinop(this, node, kMips64And);
314 void InstructionSelector::VisitWord64And(Node* node) {
316 Int64BinopMatcher m(node);
317 if (m.left().IsWord64Shr() && CanCover(node, m.left().node()) &&
328 Int64BinopMatcher mleft(m.left().node());
339 Emit(kMips64Dext, g.DefineAsRegister(node),
340 g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
355 Emit(kMips64Dins, g.DefineSameAsFirst(node),
356 g.UseRegister(m.left().node()), g.TempImmediate(0),
361 VisitBinop(this, node, kMips64And);
365 void InstructionSelector::VisitWord32Or(Node* node) {
366 VisitBinop(this, node, kMips64Or);
370 void InstructionSelector::VisitWord64Or(Node* node) {
371 VisitBinop(this, node, kMips64Or);
375 void InstructionSelector::VisitWord32Xor(Node* node) {
376 Int32BinopMatcher m(node);
377 if (m.left().IsWord32Or() && CanCover(node, m.left().node()) &&
379 Int32BinopMatcher mleft(m.left().node());
382 Emit(kMips64Nor, g.DefineAsRegister(node),
383 g.UseRegister(mleft.left().node()),
384 g.UseRegister(mleft.right().node()));
391 Emit(kMips64Nor, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
395 VisitBinop(this, node, kMips64Xor);
399 void InstructionSelector::VisitWord64Xor(Node* node) {
400 Int64BinopMatcher m(node);
401 if (m.left().IsWord64Or() && CanCover(node, m.left().node()) &&
403 Int64BinopMatcher mleft(m.left().node());
406 Emit(kMips64Nor, g.DefineAsRegister(node),
407 g.UseRegister(mleft.left().node()),
408 g.UseRegister(mleft.right().node()));
415 Emit(kMips64Nor, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
419 VisitBinop(this, node, kMips64Xor);
423 void InstructionSelector::VisitWord32Shl(Node* node) {
424 Int32BinopMatcher m(node);
425 if (m.left().IsWord32And() && CanCover(node, m.left().node()) &&
428 Int32BinopMatcher mleft(m.left().node());
442 Emit(kMips64Shl, g.DefineAsRegister(node),
443 g.UseRegister(mleft.left().node()),
444 g.UseImmediate(m.right().node()));
450 VisitRRO(this, kMips64Shl, node);
454 void InstructionSelector::VisitWord32Shr(Node* node) {
455 Int32BinopMatcher m(node);
458 Int32BinopMatcher mleft(m.left().node());
468 Emit(kMips64Ext, g.DefineAsRegister(node),
469 g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
475 VisitRRO(this, kMips64Shr, node);
479 void InstructionSelector::VisitWord32Sar(Node* node) {
480 VisitRRO(this, kMips64Sar, node);
484 void InstructionSelector::VisitWord64Shl(Node* node) {
486 Int64BinopMatcher m(node);
491 Emit(kMips64Dshl, g.DefineSameAsFirst(node),
492 g.UseRegister(m.left().node()->InputAt(0)),
493 g.UseImmediate(m.right().node()));
496 if (m.left().IsWord64And() && CanCover(node, m.left().node()) &&
500 Int64BinopMatcher mleft(m.left().node());
513 Emit(kMips64Dshl, g.DefineAsRegister(node),
514 g.UseRegister(mleft.left().node()),
515 g.UseImmediate(m.right().node()));
521 VisitRRO(this, kMips64Dshl, node);
525 void InstructionSelector::VisitWord64Shr(Node* node) {
526 Int64BinopMatcher m(node);
529 Int64BinopMatcher mleft(m.left().node());
539 Emit(kMips64Dext, g.DefineAsRegister(node),
540 g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
546 VisitRRO(this, kMips64Dshr, node);
550 void InstructionSelector::VisitWord64Sar(Node* node) {
551 VisitRRO(this, kMips64Dsar, node);
555 void InstructionSelector::VisitWord32Ror(Node* node) {
556 VisitRRO(this, kMips64Ror, node);
560 void InstructionSelector::VisitWord32Clz(Node* node) {
561 VisitRR(this, kMips64Clz, node);
565 void InstructionSelector::VisitWord32Ctz(Node* node) { UNREACHABLE(); }
568 void InstructionSelector::VisitWord64Ctz(Node* node) { UNREACHABLE(); }
571 void InstructionSelector::VisitWord32Popcnt(Node* node) { UNREACHABLE(); }
574 void InstructionSelector::VisitWord64Popcnt(Node* node) { UNREACHABLE(); }
577 void InstructionSelector::VisitWord64Ror(Node* node) {
578 VisitRRO(this, kMips64Dror, node);
582 void InstructionSelector::VisitWord64Clz(Node* node) {
583 VisitRR(this, kMips64Dclz, node);
587 void InstructionSelector::VisitInt32Add(Node* node) {
590 VisitBinop(this, node, kMips64Add);
594 void InstructionSelector::VisitInt64Add(Node* node) {
597 VisitBinop(this, node, kMips64Dadd);
601 void InstructionSelector::VisitInt32Sub(Node* node) {
602 VisitBinop(this, node, kMips64Sub);
606 void InstructionSelector::VisitInt64Sub(Node* node) {
607 VisitBinop(this, node, kMips64Dsub);
611 void InstructionSelector::VisitInt32Mul(Node* node) {
613 Int32BinopMatcher m(node);
618 g.DefineAsRegister(node), g.UseRegister(m.left().node()),
625 g.UseRegister(m.left().node()),
628 g.DefineAsRegister(node), g.UseRegister(m.left().node()), temp);
634 g.UseRegister(m.left().node()),
637 g.DefineAsRegister(node), temp, g.UseRegister(m.left().node()));
641 Node* left = node->InputAt(0);
642 Node* right = node->InputAt(1);
643 if (CanCover(node, left) && CanCover(node, right)) {
649 Emit(kMips64DMulHigh, g.DefineSameAsFirst(node),
650 g.UseRegister(leftInput.left().node()),
651 g.UseRegister(rightInput.left().node()));
656 VisitRRR(this, kMips64Mul, node);
660 void InstructionSelector::VisitInt32MulHigh(Node* node) {
661 VisitRRR(this, kMips64MulHigh, node);
665 void InstructionSelector::VisitUint32MulHigh(Node* node) {
666 VisitRRR(this, kMips64MulHighU, node);
670 void InstructionSelector::VisitInt64Mul(Node* node) {
672 Int64BinopMatcher m(node);
678 g.DefineAsRegister(node), g.UseRegister(m.left().node()),
685 g.UseRegister(m.left().node()),
688 g.DefineAsRegister(node), g.UseRegister(m.left().node()), temp);
694 g.UseRegister(m.left().node()),
697 g.DefineAsRegister(node), temp, g.UseRegister(m.left().node()));
701 Emit(kMips64Dmul, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
702 g.UseRegister(m.right().node()));
706 void InstructionSelector::VisitInt32Div(Node* node) {
708 Int32BinopMatcher m(node);
709 Node* left = node->InputAt(0);
710 Node* right = node->InputAt(1);
711 if (CanCover(node, left) && CanCover(node, right)) {
717 Emit(kMips64Ddiv, g.DefineSameAsFirst(node),
718 g.UseRegister(leftInput.left().node()),
719 g.UseRegister(rightInput.left().node()));
724 Emit(kMips64Div, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
725 g.UseRegister(m.right().node()));
729 void InstructionSelector::VisitUint32Div(Node* node) {
731 Int32BinopMatcher m(node);
732 Emit(kMips64DivU, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
733 g.UseRegister(m.right().node()));
737 void InstructionSelector::VisitInt32Mod(Node* node) {
739 Int32BinopMatcher m(node);
740 Node* left = node->InputAt(0);
741 Node* right = node->InputAt(1);
742 if (CanCover(node, left) && CanCover(node, right)) {
748 Emit(kMips64Dmod, g.DefineSameAsFirst(node),
749 g.UseRegister(leftInput.left().node()),
750 g.UseRegister(rightInput.left().node()));
755 Emit(kMips64Mod, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
756 g.UseRegister(m.right().node()));
760 void InstructionSelector::VisitUint32Mod(Node* node) {
762 Int32BinopMatcher m(node);
763 Emit(kMips64ModU, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
764 g.UseRegister(m.right().node()));
768 void InstructionSelector::VisitInt64Div(Node* node) {
770 Int64BinopMatcher m(node);
771 Emit(kMips64Ddiv, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
772 g.UseRegister(m.right().node()));
776 void InstructionSelector::VisitUint64Div(Node* node) {
778 Int64BinopMatcher m(node);
779 Emit(kMips64DdivU, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
780 g.UseRegister(m.right().node()));
784 void InstructionSelector::VisitInt64Mod(Node* node) {
786 Int64BinopMatcher m(node);
787 Emit(kMips64Dmod, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
788 g.UseRegister(m.right().node()));
792 void InstructionSelector::VisitUint64Mod(Node* node) {
794 Int64BinopMatcher m(node);
795 Emit(kMips64DmodU, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
796 g.UseRegister(m.right().node()));
800 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
801 VisitRR(this, kMips64CvtDS, node);
805 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) {
806 VisitRR(this, kMips64CvtDW, node);
810 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
811 VisitRR(this, kMips64CvtDUw, node);
815 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) {
817 Node* value = node->InputAt(0);
820 if (CanCover(node, value)) {
823 Emit(kMips64FloorWD, g.DefineAsRegister(node),
827 Emit(kMips64CeilWD, g.DefineAsRegister(node),
831 Emit(kMips64RoundWD, g.DefineAsRegister(node),
835 Emit(kMips64TruncWD, g.DefineAsRegister(node),
842 Node* next = value->InputAt(0);
847 Emit(kMips64FloorWS, g.DefineAsRegister(node),
851 Emit(kMips64CeilWS, g.DefineAsRegister(node),
855 Emit(kMips64RoundWS, g.DefineAsRegister(node),
859 Emit(kMips64TruncWS, g.DefineAsRegister(node),
863 Emit(kMips64TruncWS, g.DefineAsRegister(node),
869 Emit(kMips64TruncWS, g.DefineAsRegister(node),
875 VisitRR(this, kMips64TruncWD, node);
879 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) {
880 VisitRR(this, kMips64TruncUwD, node);
884 void InstructionSelector::VisitTryTruncateFloat32ToInt64(Node* node) {
886 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
889 outputs[output_count++] = g.DefineAsRegister(node);
891 Node* success_output = NodeProperties::FindProjection(node, 1);
900 void InstructionSelector::VisitTryTruncateFloat64ToInt64(Node* node) {
902 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
905 outputs[output_count++] = g.DefineAsRegister(node);
907 Node* success_output = NodeProperties::FindProjection(node, 1);
916 void InstructionSelector::VisitTryTruncateFloat32ToUint64(Node* node) {
918 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
921 outputs[output_count++] = g.DefineAsRegister(node);
923 Node* success_output = NodeProperties::FindProjection(node, 1);
932 void InstructionSelector::VisitTryTruncateFloat64ToUint64(Node* node) {
935 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
938 outputs[output_count++] = g.DefineAsRegister(node);
940 Node* success_output = NodeProperties::FindProjection(node, 1);
949 void InstructionSelector::VisitChangeInt32ToInt64(Node* node) {
951 Emit(kMips64Shl, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)),
956 void InstructionSelector::VisitChangeUint32ToUint64(Node* node) {
958 Emit(kMips64Dext, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)),
963 void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) {
965 Node* value = node->InputAt(0);
966 if (CanCover(node, value)) {
972 Emit(kMips64Dsar, g.DefineSameAsFirst(node),
973 g.UseRegister(m.left().node()),
974 g.UseImmediate(m.right().node()));
983 Emit(kMips64Ext, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)),
988 void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
990 Node* value = node->InputAt(0);
993 if (CanCover(node, value) &&
995 Emit(kMips64CvtSW, g.DefineAsRegister(node),
999 VisitRR(this, kMips64CvtSD, node);
1003 void InstructionSelector::VisitTruncateFloat64ToInt32(Node* node) {
1004 switch (TruncationModeOf(node->op())) {
1006 return VisitRR(this, kArchTruncateDoubleToI, node);
1008 return VisitRR(this, kMips64TruncWD, node);
1014 void InstructionSelector::VisitRoundInt64ToFloat32(Node* node) {
1015 VisitRR(this, kMips64CvtSL, node);
1019 void InstructionSelector::VisitRoundInt64ToFloat64(Node* node) {
1020 VisitRR(this, kMips64CvtDL, node);
1024 void InstructionSelector::VisitRoundUint64ToFloat32(Node* node) {
1025 VisitRR(this, kMips64CvtSUl, node);
1029 void InstructionSelector::VisitRoundUint64ToFloat64(Node* node) {
1030 VisitRR(this, kMips64CvtDUl, node);
1034 void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) {
1035 VisitRR(this, kMips64Float64ExtractLowWord32, node);
1039 void InstructionSelector::VisitBitcastFloat64ToInt64(Node* node) {
1040 VisitRR(this, kMips64BitcastDL, node);
1044 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) {
1046 Emit(kMips64Float64InsertLowWord32, g.DefineAsRegister(node),
1048 g.UseRegister(node->InputAt(0)));
1052 void InstructionSelector::VisitBitcastInt64ToFloat64(Node* node) {
1053 VisitRR(this, kMips64BitcastLD, node);
1057 void InstructionSelector::VisitFloat32Add(Node* node) {
1058 VisitRRR(this, kMips64AddS, node);
1062 void InstructionSelector::VisitFloat64Add(Node* node) {
1063 VisitRRR(this, kMips64AddD, node);
1067 void InstructionSelector::VisitFloat32Sub(Node* node) {
1068 VisitRRR(this, kMips64SubS, node);
1072 void InstructionSelector::VisitFloat64Sub(Node* node) {
1074 Float64BinopMatcher m(node);
1076 CanCover(m.node(), m.right().node())) {
1078 CanCover(m.right().node(), m.right().InputAt(0))) {
1081 Emit(kMips64Float64RoundUp, g.DefineAsRegister(node),
1082 g.UseRegister(mright0.right().node()));
1087 VisitRRR(this, kMips64SubD, node);
1091 void InstructionSelector::VisitFloat32Mul(Node* node) {
1092 VisitRRR(this, kMips64MulS, node);
1096 void InstructionSelector::VisitFloat64Mul(Node* node) {
1097 VisitRRR(this, kMips64MulD, node);
1101 void InstructionSelector::VisitFloat32Div(Node* node) {
1102 VisitRRR(this, kMips64DivS, node);
1106 void InstructionSelector::VisitFloat64Div(Node* node) {
1107 VisitRRR(this, kMips64DivD, node);
1111 void InstructionSelector::VisitFloat64Mod(Node* node) {
1113 Emit(kMips64ModD, g.DefineAsFixed(node, f0),
1114 g.UseFixed(node->InputAt(0), f12),
1115 g.UseFixed(node->InputAt(1), f14))->MarkAsCall();
1119 void InstructionSelector::VisitFloat32Max(Node* node) {
1122 Emit(kMips64Float32Max, g.DefineAsRegister(node),
1123 g.UseUniqueRegister(node->InputAt(0)),
1124 g.UseUniqueRegister(node->InputAt(1)));
1128 Emit(kMips64Float32Max, g.DefineSameAsFirst(node),
1129 g.UseRegister(node->InputAt(1)), g.UseRegister(node->InputAt(0)));
1134 void InstructionSelector::VisitFloat64Max(Node* node) {
1137 Emit(kMips64Float64Max, g.DefineAsRegister(node),
1138 g.UseUniqueRegister(node->InputAt(0)),
1139 g.UseUniqueRegister(node->InputAt(1)));
1143 Emit(kMips64Float64Max, g.DefineSameAsFirst(node),
1144 g.UseRegister(node->InputAt(1)), g.UseRegister(node->InputAt(0)));
1149 void InstructionSelector::VisitFloat32Min(Node* node) {
1152 Emit(kMips64Float32Min, g.DefineAsRegister(node),
1153 g.UseUniqueRegister(node->InputAt(0)),
1154 g.UseUniqueRegister(node->InputAt(1)));
1158 Emit(kMips64Float32Min, g.DefineSameAsFirst(node),
1159 g.UseRegister(node->InputAt(1)), g.UseRegister(node->InputAt(0)));
1164 void InstructionSelector::VisitFloat64Min(Node* node) {
1167 Emit(kMips64Float64Min, g.DefineAsRegister(node),
1168 g.UseUniqueRegister(node->InputAt(0)),
1169 g.UseUniqueRegister(node->InputAt(1)));
1173 Emit(kMips64Float64Min, g.DefineSameAsFirst(node),
1174 g.UseRegister(node->InputAt(1)), g.UseRegister(node->InputAt(0)));
1179 void InstructionSelector::VisitFloat32Abs(Node* node) {
1180 VisitRR(this, kMips64AbsS, node);
1184 void InstructionSelector::VisitFloat64Abs(Node* node) {
1185 VisitRR(this, kMips64AbsD, node);
1189 void InstructionSelector::VisitFloat32Sqrt(Node* node) {
1190 VisitRR(this, kMips64SqrtS, node);
1194 void InstructionSelector::VisitFloat64Sqrt(Node* node) {
1195 VisitRR(this, kMips64SqrtD, node);
1199 void InstructionSelector::VisitFloat32RoundDown(Node* node) {
1200 VisitRR(this, kMips64Float32RoundDown, node);
1204 void InstructionSelector::VisitFloat64RoundDown(Node* node) {
1205 VisitRR(this, kMips64Float64RoundDown, node);
1209 void InstructionSelector::VisitFloat32RoundUp(Node* node) {
1210 VisitRR(this, kMips64Float32RoundUp, node);
1214 void InstructionSelector::VisitFloat64RoundUp(Node* node) {
1215 VisitRR(this, kMips64Float64RoundUp, node);
1219 void InstructionSelector::VisitFloat32RoundTruncate(Node* node) {
1220 VisitRR(this, kMips64Float32RoundTruncate, node);
1224 void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
1225 VisitRR(this, kMips64Float64RoundTruncate, node);
1229 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
1234 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) {
1235 VisitRR(this, kMips64Float32RoundTiesEven, node);
1239 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) {
1240 VisitRR(this, kMips64Float64RoundTiesEven, node);
1246 Node* node) {
1258 Emit(kMips64StoreToStackSlot, g.NoOutput(), g.UseRegister(input.node()),
1270 if (input.node()) {
1271 Emit(kMips64StoreToStackSlot, g.NoOutput(), g.UseRegister(input.node()),
1282 void InstructionSelector::VisitCheckedLoad(Node* node) {
1283 CheckedLoadRepresentation load_rep = CheckedLoadRepresentationOf(node->op());
1285 Node* const buffer = node->InputAt(0);
1286 Node* const offset = node->InputAt(1);
1287 Node* const length = node->InputAt(2);
1325 g.DefineAsRegister(node), offset_operand, length_operand,
1330 void InstructionSelector::VisitCheckedStore(Node* node) {
1331 MachineRepresentation rep = CheckedStoreRepresentationOf(node->op());
1333 Node* const buffer = node->InputAt(0);
1334 Node* const offset = node->InputAt(1);
1335 Node* const length = node->InputAt(2);
1336 Node* const value = node->InputAt(3);
1398 void VisitFloat32Compare(InstructionSelector* selector, Node* node,
1401 Float32BinopMatcher m(node);
1404 lhs = m.left().IsZero() ? g.UseImmediate(m.left().node())
1405 : g.UseRegister(m.left().node());
1406 rhs = m.right().IsZero() ? g.UseImmediate(m.right().node())
1407 : g.UseRegister(m.right().node());
1413 void VisitFloat64Compare(InstructionSelector* selector, Node* node,
1416 Float64BinopMatcher m(node);
1419 lhs = m.left().IsZero() ? g.UseImmediate(m.left().node())
1420 : g.UseRegister(m.left().node());
1421 rhs = m.right().IsZero() ? g.UseImmediate(m.right().node())
1422 : g.UseRegister(m.right().node());
1428 void VisitWordCompare(InstructionSelector* selector, Node* node,
1432 Node* left = node->InputAt(0);
1433 Node* right = node->InputAt(1);
1490 void VisitWord32Compare(InstructionSelector* selector, Node* node,
1492 VisitWordCompare(selector, node, kMips64Cmp, cont, false);
1496 void VisitWord64Compare(InstructionSelector* selector, Node* node,
1498 VisitWordCompare(selector, node, kMips64Cmp, cont, false);
1504 void EmitWordCompareZero(InstructionSelector* selector, Node* value,
1520 void VisitWordCompareZero(InstructionSelector* selector, Node* user,
1521 Node* value, FlagsContinuation* cont) {
1530 value = m.left().node();
1555 value = m.left().node();
1594 // <Operation>WithOverflow node.
1601 Node* const node = value->InputAt(0);
1602 Node* const result = NodeProperties::FindProjection(node, 0);
1604 switch (node->opcode()) {
1607 return VisitBinop(selector, node, kMips64Dadd, cont);
1610 return VisitBinop(selector, node, kMips64Dsub, cont);
1613 return VisitBinop(selector, node, kMips64DaddOvf, cont);
1616 return VisitBinop(selector, node, kMips64DsubOvf, cont);
1637 void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
1644 void InstructionSelector::VisitSwitch(Node* node, const SwitchInfo& sw) {
1646 InstructionOperand value_operand = g.UseRegister(node->InputAt(0));
1672 void InstructionSelector::VisitWord32Equal(Node* const node) {
1673 FlagsContinuation cont(kEqual, node);
1674 Int32BinopMatcher m(node);
1676 return VisitWordCompareZero(this, m.node(), m.left().node(), &cont);
1679 VisitWord32Compare(this, node, &cont);
1683 void InstructionSelector::VisitInt32LessThan(Node* node) {
1684 FlagsContinuation cont(kSignedLessThan, node);
1685 VisitWord32Compare(this, node, &cont);
1689 void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
1690 FlagsContinuation cont(kSignedLessThanOrEqual, node);
1691 VisitWord32Compare(this, node, &cont);
1695 void InstructionSelector::VisitUint32LessThan(Node* node) {
1696 FlagsContinuation cont(kUnsignedLessThan, node);
1697 VisitWord32Compare(this, node, &cont);
1701 void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
1702 FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
1703 VisitWord32Compare(this, node, &cont);
1707 void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
1708 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1710 return VisitBinop(this, node, kMips64Dadd, &cont);
1713 VisitBinop(this, node, kMips64Dadd, &cont);
1717 void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
1718 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1720 return VisitBinop(this, node, kMips64Dsub, &cont);
1723 VisitBinop(this, node, kMips64Dsub, &cont);
1727 void InstructionSelector::VisitInt64AddWithOverflow(Node* node) {
1728 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1730 return VisitBinop(this, node, kMips64DaddOvf, &cont);
1733 VisitBinop(this, node, kMips64DaddOvf, &cont);
1737 void InstructionSelector::VisitInt64SubWithOverflow(Node* node) {
1738 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1740 return VisitBinop(this, node, kMips64DsubOvf, &cont);
1743 VisitBinop(this, node, kMips64DsubOvf, &cont);
1747 void InstructionSelector::VisitWord64Equal(Node* const node) {
1748 FlagsContinuation cont(kEqual, node);
1749 Int64BinopMatcher m(node);
1751 return VisitWordCompareZero(this, m.node(), m.left().node(), &cont);
1754 VisitWord64Compare(this, node, &cont);
1758 void InstructionSelector::VisitInt64LessThan(Node* node) {
1759 FlagsContinuation cont(kSignedLessThan, node);
1760 VisitWord64Compare(this, node, &cont);
1764 void InstructionSelector::VisitInt64LessThanOrEqual(Node* node) {
1765 FlagsContinuation cont(kSignedLessThanOrEqual, node);
1766 VisitWord64Compare(this, node, &cont);
1770 void InstructionSelector::VisitUint64LessThan(Node* node) {
1771 FlagsContinuation cont(kUnsignedLessThan, node);
1772 VisitWord64Compare(this, node, &cont);
1776 void InstructionSelector::VisitUint64LessThanOrEqual(Node* node) {
1777 FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
1778 VisitWord64Compare(this, node, &cont);
1782 void InstructionSelector::VisitFloat32Equal(Node* node) {
1783 FlagsContinuation cont(kEqual, node);
1784 VisitFloat32Compare(this, node, &cont);
1788 void InstructionSelector::VisitFloat32LessThan(Node* node) {
1789 FlagsContinuation cont(kUnsignedLessThan, node);
1790 VisitFloat32Compare(this, node, &cont);
1794 void InstructionSelector::VisitFloat32LessThanOrEqual(Node* node) {
1795 FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
1796 VisitFloat32Compare(this, node, &cont);
1800 void InstructionSelector::VisitFloat64Equal(Node* node) {
1801 FlagsContinuation cont(kEqual, node);
1802 VisitFloat64Compare(this, node, &cont);
1806 void InstructionSelector::VisitFloat64LessThan(Node* node) {
1807 FlagsContinuation cont(kUnsignedLessThan, node);
1808 VisitFloat64Compare(this, node, &cont);
1812 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
1813 FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
1814 VisitFloat64Compare(this, node, &cont);
1818 void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) {
1819 VisitRR(this, kMips64Float64ExtractLowWord32, node);
1823 void InstructionSelector::VisitFloat64ExtractHighWord32(Node* node) {
1824 VisitRR(this, kMips64Float64ExtractHighWord32, node);
1828 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) {
1830 Node* left = node->InputAt(0);
1831 Node* right = node->InputAt(1);
1832 Emit(kMips64Float64InsertLowWord32, g.DefineSameAsFirst(node),
1837 void InstructionSelector::VisitFloat64InsertHighWord32(Node* node) {
1839 Node* left = node->InputAt(0);
1840 Node* right = node->InputAt(1);
1841 Emit(kMips64Float64InsertHighWord32, g.DefineSameAsFirst(node),
