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);
132 static void VisitBinop(InstructionSelector* selector, Node* node,
135 VisitBinop(selector, node, opcode, &cont);
139 void InstructionSelector::VisitLoad(Node* node) {
140 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
142 Node* base = node->InputAt(0);
143 Node* index = node->InputAt(1);
175 g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(index));
182 g.DefineAsRegister(node), addr_reg, g.TempImmediate(0));
187 void InstructionSelector::VisitStore(Node* node) {
189 Node* base = node->InputAt(0);
190 Node* index = node->InputAt(1);
191 Node* value = node->InputAt(2);
193 StoreRepresentation store_rep = StoreRepresentationOf(node->op());
269 void InstructionSelector::VisitWord32And(Node* node) {
271 Int32BinopMatcher m(node);
272 if (m.left().IsWord32Shr() && CanCover(node, m.left().node()) &&
283 Int32BinopMatcher mleft(m.left().node());
294 Emit(kMips64Ext, g.DefineAsRegister(node),
295 g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
309 Emit(kMips64Ins, g.DefineSameAsFirst(node),
310 g.UseRegister(m.left().node()), g.TempImmediate(0),
315 VisitBinop(this, node, kMips64And);
319 void InstructionSelector::VisitWord64And(Node* node) {
321 Int64BinopMatcher m(node);
322 if (m.left().IsWord64Shr() && CanCover(node, m.left().node()) &&
333 Int64BinopMatcher mleft(m.left().node());
344 Emit(kMips64Dext, g.DefineAsRegister(node),
345 g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
360 Emit(kMips64Dins, g.DefineSameAsFirst(node),
361 g.UseRegister(m.left().node()), g.TempImmediate(0),
366 VisitBinop(this, node, kMips64And);
370 void InstructionSelector::VisitWord32Or(Node* node) {
371 VisitBinop(this, node, kMips64Or);
375 void InstructionSelector::VisitWord64Or(Node* node) {
376 VisitBinop(this, node, kMips64Or);
380 void InstructionSelector::VisitWord32Xor(Node* node) {
381 Int32BinopMatcher m(node);
382 if (m.left().IsWord32Or() && CanCover(node, m.left().node()) &&
384 Int32BinopMatcher mleft(m.left().node());
387 Emit(kMips64Nor, g.DefineAsRegister(node),
388 g.UseRegister(mleft.left().node()),
389 g.UseRegister(mleft.right().node()));
396 Emit(kMips64Nor, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
400 VisitBinop(this, node, kMips64Xor);
404 void InstructionSelector::VisitWord64Xor(Node* node) {
405 Int64BinopMatcher m(node);
406 if (m.left().IsWord64Or() && CanCover(node, m.left().node()) &&
408 Int64BinopMatcher mleft(m.left().node());
411 Emit(kMips64Nor, g.DefineAsRegister(node),
412 g.UseRegister(mleft.left().node()),
413 g.UseRegister(mleft.right().node()));
420 Emit(kMips64Nor, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
424 VisitBinop(this, node, kMips64Xor);
428 void InstructionSelector::VisitWord32Shl(Node* node) {
429 Int32BinopMatcher m(node);
430 if (m.left().IsWord32And() && CanCover(node, m.left().node()) &&
433 Int32BinopMatcher mleft(m.left().node());
447 Emit(kMips64Shl, g.DefineAsRegister(node),
448 g.UseRegister(mleft.left().node()),
449 g.UseImmediate(m.right().node()));
455 VisitRRO(this, kMips64Shl, node);
459 void InstructionSelector::VisitWord32Shr(Node* node) {
460 Int32BinopMatcher m(node);
463 Int32BinopMatcher mleft(m.left().node());
473 Emit(kMips64Ext, g.DefineAsRegister(node),
474 g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
480 VisitRRO(this, kMips64Shr, node);
484 void InstructionSelector::VisitWord32Sar(Node* node) {
485 VisitRRO(this, kMips64Sar, node);
489 void InstructionSelector::VisitWord64Shl(Node* node) {
491 Int64BinopMatcher m(node);
496 Emit(kMips64Dshl, g.DefineSameAsFirst(node),
497 g.UseRegister(m.left().node()->InputAt(0)),
498 g.UseImmediate(m.right().node()));
501 if (m.left().IsWord64And() && CanCover(node, m.left().node()) &&
505 Int64BinopMatcher mleft(m.left().node());
518 Emit(kMips64Dshl, g.DefineAsRegister(node),
519 g.UseRegister(mleft.left().node()),
520 g.UseImmediate(m.right().node()));
526 VisitRRO(this, kMips64Dshl, node);
530 void InstructionSelector::VisitWord64Shr(Node* node) {
531 Int64BinopMatcher m(node);
534 Int64BinopMatcher mleft(m.left().node());
544 Emit(kMips64Dext, g.DefineAsRegister(node),
545 g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
551 VisitRRO(this, kMips64Dshr, node);
555 void InstructionSelector::VisitWord64Sar(Node* node) {
556 VisitRRO(this, kMips64Dsar, node);
560 void InstructionSelector::VisitWord32Ror(Node* node) {
561 VisitRRO(this, kMips64Ror, node);
565 void InstructionSelector::VisitWord32Clz(Node* node) {
566 VisitRR(this, kMips64Clz, node);
570 void InstructionSelector::VisitWord32ReverseBits(Node* node) { UNREACHABLE(); }
573 void InstructionSelector::VisitWord64ReverseBits(Node* node) { UNREACHABLE(); }
576 void InstructionSelector::VisitWord32Ctz(Node* node) {
578 Emit(kMips64Ctz, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
582 void InstructionSelector::VisitWord64Ctz(Node* node) {
584 Emit(kMips64Dctz, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
588 void InstructionSelector::VisitWord32Popcnt(Node* node) {
590 Emit(kMips64Popcnt, g.DefineAsRegister(node),
591 g.UseRegister(node->InputAt(0)));
595 void InstructionSelector::VisitWord64Popcnt(Node* node) {
597 Emit(kMips64Dpopcnt, g.DefineAsRegister(node),
598 g.UseRegister(node->InputAt(0)));
602 void InstructionSelector::VisitWord64Ror(Node* node) {
603 VisitRRO(this, kMips64Dror, node);
607 void InstructionSelector::VisitWord64Clz(Node* node) {
608 VisitRR(this, kMips64Dclz, node);
612 void InstructionSelector::VisitInt32Add(Node* node) {
614 Int32BinopMatcher m(node);
618 CanCover(node, m.left().node()) && CanCover(node, m.right().node())) {
619 Int32BinopMatcher mright(m.right().node());
622 Emit(kMips64Lsa, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
623 g.UseRegister(mright.left().node()), g.TempImmediate(shift_value));
630 CanCover(node, m.right().node()) && CanCover(node, m.left().node())) {
631 Int32BinopMatcher mleft(m.left().node());
634 Emit(kMips64Lsa, g.DefineAsRegister(node),
635 g.UseRegister(m.right().node()), g.UseRegister(mleft.left().node()),
640 VisitBinop(this, node, kMips64Add);
644 void InstructionSelector::VisitInt64Add(Node* node) {
646 Int64BinopMatcher m(node);
650 CanCover(node, m.left().node()) && CanCover(node, m.right().node())) {
651 Int64BinopMatcher mright(m.right().node());
654 Emit(kMips64Dlsa, g.DefineAsRegister(node),
655 g.UseRegister(m.left().node()), g.UseRegister(mright.left().node()),
663 CanCover(node, m.right().node()) && CanCover(node, m.left().node())) {
664 Int64BinopMatcher mleft(m.left().node());
667 Emit(kMips64Dlsa, g.DefineAsRegister(node),
668 g.UseRegister(m.right().node()), g.UseRegister(mleft.left().node()),
674 VisitBinop(this, node, kMips64Dadd);
678 void InstructionSelector::VisitInt32Sub(Node* node) {
679 VisitBinop(this, node, kMips64Sub);
683 void InstructionSelector::VisitInt64Sub(Node* node) {
684 VisitBinop(this, node, kMips64Dsub);
688 void InstructionSelector::VisitInt32Mul(Node* node) {
690 Int32BinopMatcher m(node);
695 g.DefineAsRegister(node), g.UseRegister(m.left().node()),
700 Emit(kMips64Lsa, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
701 g.UseRegister(m.left().node()),
708 g.UseRegister(m.left().node()),
711 g.DefineAsRegister(node), temp, g.UseRegister(m.left().node()));
715 Node* left = node->InputAt(0);
716 Node* right = node->InputAt(1);
717 if (CanCover(node, left) && CanCover(node, right)) {
723 Emit(kMips64DMulHigh, g.DefineSameAsFirst(node),
724 g.UseRegister(leftInput.left().node()),
725 g.UseRegister(rightInput.left().node()));
730 VisitRRR(this, kMips64Mul, node);
734 void InstructionSelector::VisitInt32MulHigh(Node* node) {
735 VisitRRR(this, kMips64MulHigh, node);
739 void InstructionSelector::VisitUint32MulHigh(Node* node) {
740 VisitRRR(this, kMips64MulHighU, node);
744 void InstructionSelector::VisitInt64Mul(Node* node) {
746 Int64BinopMatcher m(node);
752 g.DefineAsRegister(node), g.UseRegister(m.left().node()),
758 Emit(kMips64Dlsa, g.DefineAsRegister(node),
759 g.UseRegister(m.left().node()), g.UseRegister(m.left().node()),
766 g.UseRegister(m.left().node()),
769 g.DefineAsRegister(node), temp, g.UseRegister(m.left().node()));
773 Emit(kMips64Dmul, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
774 g.UseRegister(m.right().node()));
778 void InstructionSelector::VisitInt32Div(Node* node) {
780 Int32BinopMatcher m(node);
781 Node* left = node->InputAt(0);
782 Node* right = node->InputAt(1);
783 if (CanCover(node, left) && CanCover(node, right)) {
789 Emit(kMips64Ddiv, g.DefineSameAsFirst(node),
790 g.UseRegister(leftInput.left().node()),
791 g.UseRegister(rightInput.left().node()));
796 Emit(kMips64Div, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
797 g.UseRegister(m.right().node()));
801 void InstructionSelector::VisitUint32Div(Node* node) {
803 Int32BinopMatcher m(node);
804 Emit(kMips64DivU, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
805 g.UseRegister(m.right().node()));
809 void InstructionSelector::VisitInt32Mod(Node* node) {
811 Int32BinopMatcher m(node);
812 Node* left = node->InputAt(0);
813 Node* right = node->InputAt(1);
814 if (CanCover(node, left) && CanCover(node, right)) {
820 Emit(kMips64Dmod, g.DefineSameAsFirst(node),
821 g.UseRegister(leftInput.left().node()),
822 g.UseRegister(rightInput.left().node()));
827 Emit(kMips64Mod, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
828 g.UseRegister(m.right().node()));
832 void InstructionSelector::VisitUint32Mod(Node* node) {
834 Int32BinopMatcher m(node);
835 Emit(kMips64ModU, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
836 g.UseRegister(m.right().node()));
840 void InstructionSelector::VisitInt64Div(Node* node) {
842 Int64BinopMatcher m(node);
843 Emit(kMips64Ddiv, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
844 g.UseRegister(m.right().node()));
848 void InstructionSelector::VisitUint64Div(Node* node) {
850 Int64BinopMatcher m(node);
851 Emit(kMips64DdivU, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
852 g.UseRegister(m.right().node()));
856 void InstructionSelector::VisitInt64Mod(Node* node) {
858 Int64BinopMatcher m(node);
859 Emit(kMips64Dmod, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
860 g.UseRegister(m.right().node()));
864 void InstructionSelector::VisitUint64Mod(Node* node) {
866 Int64BinopMatcher m(node);
867 Emit(kMips64DmodU, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
868 g.UseRegister(m.right().node()));
872 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
873 VisitRR(this, kMips64CvtDS, node);
877 void InstructionSelector::VisitRoundInt32ToFloat32(Node* node) {
878 VisitRR(this, kMips64CvtSW, node);
882 void InstructionSelector::VisitRoundUint32ToFloat32(Node* node) {
883 VisitRR(this, kMips64CvtSUw, node);
887 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) {
888 VisitRR(this, kMips64CvtDW, node);
892 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
893 VisitRR(this, kMips64CvtDUw, node);
897 void InstructionSelector::VisitTruncateFloat32ToInt32(Node* node) {
898 VisitRR(this, kMips64TruncWS, node);
902 void InstructionSelector::VisitTruncateFloat32ToUint32(Node* node) {
903 VisitRR(this, kMips64TruncUwS, node);
907 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) {
909 Node* value = node->InputAt(0);
912 if (CanCover(node, value)) {
915 Emit(kMips64FloorWD, g.DefineAsRegister(node),
919 Emit(kMips64CeilWD, g.DefineAsRegister(node),
923 Emit(kMips64RoundWD, g.DefineAsRegister(node),
927 Emit(kMips64TruncWD, g.DefineAsRegister(node),
934 Node* next = value->InputAt(0);
939 Emit(kMips64FloorWS, g.DefineAsRegister(node),
943 Emit(kMips64CeilWS, g.DefineAsRegister(node),
947 Emit(kMips64RoundWS, g.DefineAsRegister(node),
951 Emit(kMips64TruncWS, g.DefineAsRegister(node),
955 Emit(kMips64TruncWS, g.DefineAsRegister(node),
961 Emit(kMips64TruncWS, g.DefineAsRegister(node),
967 VisitRR(this, kMips64TruncWD, node);
971 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) {
972 VisitRR(this, kMips64TruncUwD, node);
975 void InstructionSelector::VisitTruncateFloat64ToUint32(Node* node) {
976 VisitRR(this, kMips64TruncUwD, node);
979 void InstructionSelector::VisitTryTruncateFloat32ToInt64(Node* node) {
981 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
984 outputs[output_count++] = g.DefineAsRegister(node);
986 Node* success_output = NodeProperties::FindProjection(node, 1);
995 void InstructionSelector::VisitTryTruncateFloat64ToInt64(Node* node) {
997 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
1000 outputs[output_count++] = g.DefineAsRegister(node);
1002 Node* success_output = NodeProperties::FindProjection(node, 1);
1011 void InstructionSelector::VisitTryTruncateFloat32ToUint64(Node* node) {
1013 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
1016 outputs[output_count++] = g.DefineAsRegister(node);
1018 Node* success_output = NodeProperties::FindProjection(node, 1);
1027 void InstructionSelector::VisitTryTruncateFloat64ToUint64(Node* node) {
1030 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
1033 outputs[output_count++] = g.DefineAsRegister(node);
1035 Node* success_output = NodeProperties::FindProjection(node, 1);
1044 void InstructionSelector::VisitChangeInt32ToInt64(Node* node) {
1046 Emit(kMips64Shl, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)),
1051 void InstructionSelector::VisitChangeUint32ToUint64(Node* node) {
1053 Emit(kMips64Dext, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)),
1058 void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) {
1060 Node* value = node->InputAt(0);
1061 if (CanCover(node, value)) {
1067 Emit(kMips64Dsar, g.DefineSameAsFirst(node),
1068 g.UseRegister(m.left().node()),
1069 g.UseImmediate(m.right().node()));
1078 Emit(kMips64Ext, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)),
1083 void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
1085 Node* value = node->InputAt(0);
1088 if (CanCover(node, value) &&
1090 Emit(kMips64CvtSW, g.DefineAsRegister(node),
1094 VisitRR(this, kMips64CvtSD, node);
1097 void InstructionSelector::VisitTruncateFloat64ToWord32(Node* node) {
1098 VisitRR(this, kArchTruncateDoubleToI, node);
1101 void InstructionSelector::VisitRoundFloat64ToInt32(Node* node) {
1102 VisitRR(this, kMips64TruncWD, node);
1105 void InstructionSelector::VisitRoundInt64ToFloat32(Node* node) {
1106 VisitRR(this, kMips64CvtSL, node);
1110 void InstructionSelector::VisitRoundInt64ToFloat64(Node* node) {
1111 VisitRR(this, kMips64CvtDL, node);
1115 void InstructionSelector::VisitRoundUint64ToFloat32(Node* node) {
1116 VisitRR(this, kMips64CvtSUl, node);
1120 void InstructionSelector::VisitRoundUint64ToFloat64(Node* node) {
1121 VisitRR(this, kMips64CvtDUl, node);
1125 void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) {
1126 VisitRR(this, kMips64Float64ExtractLowWord32, node);
1130 void InstructionSelector::VisitBitcastFloat64ToInt64(Node* node) {
1131 VisitRR(this, kMips64BitcastDL, node);
1135 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) {
1137 Emit(kMips64Float64InsertLowWord32, g.DefineAsRegister(node),
1139 g.UseRegister(node->InputAt(0)));
1143 void InstructionSelector::VisitBitcastInt64ToFloat64(Node* node) {
1144 VisitRR(this, kMips64BitcastLD, node);
1148 void InstructionSelector::VisitFloat32Add(Node* node) {
1149 VisitRRR(this, kMips64AddS, node);
1153 void InstructionSelector::VisitFloat64Add(Node* node) {
1154 VisitRRR(this, kMips64AddD, node);
1158 void InstructionSelector::VisitFloat32Sub(Node* node) {
1159 VisitRRR(this, kMips64SubS, node);
1162 void InstructionSelector::VisitFloat32SubPreserveNan(Node* node) {
1163 VisitRRR(this, kMips64SubPreserveNanS, node);
1166 void InstructionSelector::VisitFloat64Sub(Node* node) {
1168 Float64BinopMatcher m(node);
1170 CanCover(m.node(), m.right().node())) {
1172 CanCover(m.right().node(), m.right().InputAt(0))) {
1175 Emit(kMips64Float64RoundUp, g.DefineAsRegister(node),
1176 g.UseRegister(mright0.right().node()));
1181 VisitRRR(this, kMips64SubD, node);
1184 void InstructionSelector::VisitFloat64SubPreserveNan(Node* node) {
1185 VisitRRR(this, kMips64SubPreserveNanD, node);
1188 void InstructionSelector::VisitFloat32Mul(Node* node) {
1189 VisitRRR(this, kMips64MulS, node);
1193 void InstructionSelector::VisitFloat64Mul(Node* node) {
1194 VisitRRR(this, kMips64MulD, node);
1198 void InstructionSelector::VisitFloat32Div(Node* node) {
1199 VisitRRR(this, kMips64DivS, node);
1203 void InstructionSelector::VisitFloat64Div(Node* node) {
1204 VisitRRR(this, kMips64DivD, node);
1208 void InstructionSelector::VisitFloat64Mod(Node* node) {
1210 Emit(kMips64ModD, g.DefineAsFixed(node, f0),
1211 g.UseFixed(node->InputAt(0), f12),
1212 g.UseFixed(node->InputAt(1), f14))->MarkAsCall();
1216 void InstructionSelector::VisitFloat32Max(Node* node) {
1219 Emit(kMips64Float32Max, g.DefineAsRegister(node),
1220 g.UseUniqueRegister(node->InputAt(0)),
1221 g.UseUniqueRegister(node->InputAt(1)));
1225 Emit(kMips64Float32Max, g.DefineSameAsFirst(node),
1226 g.UseRegister(node->InputAt(1)), g.UseRegister(node->InputAt(0)));
1231 void InstructionSelector::VisitFloat64Max(Node* node) {
1234 Emit(kMips64Float64Max, g.DefineAsRegister(node),
1235 g.UseUniqueRegister(node->InputAt(0)),
1236 g.UseUniqueRegister(node->InputAt(1)));
1240 Emit(kMips64Float64Max, g.DefineSameAsFirst(node),
1241 g.UseRegister(node->InputAt(1)), g.UseRegister(node->InputAt(0)));
1246 void InstructionSelector::VisitFloat32Min(Node* node) {
1249 Emit(kMips64Float32Min, g.DefineAsRegister(node),
1250 g.UseUniqueRegister(node->InputAt(0)),
1251 g.UseUniqueRegister(node->InputAt(1)));
1255 Emit(kMips64Float32Min, g.DefineSameAsFirst(node),
1256 g.UseRegister(node->InputAt(1)), g.UseRegister(node->InputAt(0)));
1261 void InstructionSelector::VisitFloat64Min(Node* node) {
1264 Emit(kMips64Float64Min, g.DefineAsRegister(node),
1265 g.UseUniqueRegister(node->InputAt(0)),
1266 g.UseUniqueRegister(node->InputAt(1)));
1270 Emit(kMips64Float64Min, g.DefineSameAsFirst(node),
1271 g.UseRegister(node->InputAt(1)), g.UseRegister(node->InputAt(0)));
1276 void InstructionSelector::VisitFloat32Abs(Node* node) {
1277 VisitRR(this, kMips64AbsS, node);
1281 void InstructionSelector::VisitFloat64Abs(Node* node) {
1282 VisitRR(this, kMips64AbsD, node);
1285 void InstructionSelector::VisitFloat32Sqrt(Node* node) {
1286 VisitRR(this, kMips64SqrtS, node);
1290 void InstructionSelector::VisitFloat64Sqrt(Node* node) {
1291 VisitRR(this, kMips64SqrtD, node);
1295 void InstructionSelector::VisitFloat32RoundDown(Node* node) {
1296 VisitRR(this, kMips64Float32RoundDown, node);
1300 void InstructionSelector::VisitFloat64RoundDown(Node* node) {
1301 VisitRR(this, kMips64Float64RoundDown, node);
1305 void InstructionSelector::VisitFloat32RoundUp(Node* node) {
1306 VisitRR(this, kMips64Float32RoundUp, node);
1310 void InstructionSelector::VisitFloat64RoundUp(Node* node) {
1311 VisitRR(this, kMips64Float64RoundUp, node);
1315 void InstructionSelector::VisitFloat32RoundTruncate(Node* node) {
1316 VisitRR(this, kMips64Float32RoundTruncate, node);
1320 void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
1321 VisitRR(this, kMips64Float64RoundTruncate, node);
1325 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
1330 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) {
1331 VisitRR(this, kMips64Float32RoundTiesEven, node);
1335 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) {
1336 VisitRR(this, kMips64Float64RoundTiesEven, node);
1339 void InstructionSelector::VisitFloat32Neg(Node* node) { UNREACHABLE(); }
1341 void InstructionSelector::VisitFloat64Neg(Node* node) { UNREACHABLE(); }
1343 void InstructionSelector::VisitFloat64Ieee754Binop(Node* node,
1346 Emit(opcode, g.DefineAsFixed(node, f0), g.UseFixed(node->InputAt(0), f12),
1347 g.UseFixed(node->InputAt(1), f14))
1351 void InstructionSelector::VisitFloat64Ieee754Unop(Node* node,
1354 Emit(opcode, g.DefineAsFixed(node, f0), g.UseFixed(node->InputAt(0), f12))
1360 Node* node) {
1372 Emit(kMips64StoreToStackSlot, g.NoOutput(), g.UseRegister(input.node()),
1384 if (input.node()) {
1385 Emit(kMips64StoreToStackSlot, g.NoOutput(), g.UseRegister(input.node()),
1397 void InstructionSelector::VisitCheckedLoad(Node* node) {
1398 CheckedLoadRepresentation load_rep = CheckedLoadRepresentationOf(node->op());
1400 Node* const buffer = node->InputAt(0);
1401 Node* const offset = node->InputAt(1);
1402 Node* const length = node->InputAt(2);
1441 g.DefineAsRegister(node), offset_operand, length_operand,
1446 void InstructionSelector::VisitCheckedStore(Node* node) {
1447 MachineRepresentation rep = CheckedStoreRepresentationOf(node->op());
1449 Node* const buffer = node->InputAt(0);
1450 Node* const offset = node->InputAt(1);
1451 Node* const length = node->InputAt(2);
1452 Node* const value = node->InputAt(3);
1518 void VisitFloat32Compare(InstructionSelector* selector, Node* node,
1521 Float32BinopMatcher m(node);
1524 lhs = m.left().IsZero() ? g.UseImmediate(m.left().node())
1525 : g.UseRegister(m.left().node());
1526 rhs = m.right().IsZero() ? g.UseImmediate(m.right().node())
1527 : g.UseRegister(m.right().node());
1533 void VisitFloat64Compare(InstructionSelector* selector, Node* node,
1536 Float64BinopMatcher m(node);
1539 lhs = m.left().IsZero() ? g.UseImmediate(m.left().node())
1540 : g.UseRegister(m.left().node());
1541 rhs = m.right().IsZero() ? g.UseImmediate(m.right().node())
1542 : g.UseRegister(m.right().node());
1548 void VisitWordCompare(InstructionSelector* selector, Node* node,
1552 Node* left = node->InputAt(0);
1553 Node* right = node->InputAt(1);
1610 void VisitWord32Compare(InstructionSelector* selector, Node* node,
1612 VisitWordCompare(selector, node, kMips64Cmp, cont, false);
1616 void VisitWord64Compare(InstructionSelector* selector, Node* node,
1618 VisitWordCompare(selector, node, kMips64Cmp, cont, false);
1623 void EmitWordCompareZero(InstructionSelector* selector, Node* value,
1642 void VisitWordCompareZero(InstructionSelector* selector, Node* user,
1643 Node* value, FlagsContinuation* cont) {
1652 value = m.left().node();
1677 value = m.left().node();
1716 // <Operation>WithOverflow node.
1723 Node* const node = value->InputAt(0);
1724 Node* const result = NodeProperties::FindProjection(node, 0);
1726 switch (node->opcode()) {
1729 return VisitBinop(selector, node, kMips64Dadd, cont);
1732 return VisitBinop(selector, node, kMips64Dsub, cont);
1735 return VisitBinop(selector, node, kMips64DaddOvf, cont);
1738 return VisitBinop(selector, node, kMips64DsubOvf, cont);
1760 void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
1766 void InstructionSelector::VisitDeoptimizeIf(Node* node) {
1768 FlagsContinuation::ForDeoptimize(kNotEqual, node->InputAt(1));
1769 VisitWordCompareZero(this, node, node->InputAt(0), &cont);
1772 void InstructionSelector::VisitDeoptimizeUnless(Node* node) {
1774 FlagsContinuation::ForDeoptimize(kEqual, node->InputAt(1));
1775 VisitWordCompareZero(this, node, node->InputAt(0), &cont);
1778 void InstructionSelector::VisitSwitch(Node* node, const SwitchInfo& sw) {
1780 InstructionOperand value_operand = g.UseRegister(node->InputAt(0));
1806 void InstructionSelector::VisitWord32Equal(Node* const node) {
1807 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1808 Int32BinopMatcher m(node);
1810 return VisitWordCompareZero(this, m.node(), m.left().node(), &cont);
1813 VisitWord32Compare(this, node, &cont);
1817 void InstructionSelector::VisitInt32LessThan(Node* node) {
1818 FlagsContinuation cont = FlagsContinuation::ForSet(kSignedLessThan, node);
1819 VisitWord32Compare(this, node, &cont);
1823 void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
1825 FlagsContinuation::ForSet(kSignedLessThanOrEqual, node);
1826 VisitWord32Compare(this, node, &cont);
1830 void InstructionSelector::VisitUint32LessThan(Node* node) {
1831 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1832 VisitWord32Compare(this, node, &cont);
1836 void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
1838 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1839 VisitWord32Compare(this, node, &cont);
1843 void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
1844 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1846 return VisitBinop(this, node, kMips64Dadd, &cont);
1849 VisitBinop(this, node, kMips64Dadd, &cont);
1853 void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
1854 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1856 return VisitBinop(this, node, kMips64Dsub, &cont);
1859 VisitBinop(this, node, kMips64Dsub, &cont);
1863 void InstructionSelector::VisitInt64AddWithOverflow(Node* node) {
1864 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1866 return VisitBinop(this, node, kMips64DaddOvf, &cont);
1869 VisitBinop(this, node, kMips64DaddOvf, &cont);
1873 void InstructionSelector::VisitInt64SubWithOverflow(Node* node) {
1874 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1876 return VisitBinop(this, node, kMips64DsubOvf, &cont);
1879 VisitBinop(this, node, kMips64DsubOvf, &cont);
1883 void InstructionSelector::VisitWord64Equal(Node* const node) {
1884 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1885 Int64BinopMatcher m(node);
1887 return VisitWordCompareZero(this, m.node(), m.left().node(), &cont);
1890 VisitWord64Compare(this, node, &cont);
1894 void InstructionSelector::VisitInt64LessThan(Node* node) {
1895 FlagsContinuation cont = FlagsContinuation::ForSet(kSignedLessThan, node);
1896 VisitWord64Compare(this, node, &cont);
1900 void InstructionSelector::VisitInt64LessThanOrEqual(Node* node) {
1902 FlagsContinuation::ForSet(kSignedLessThanOrEqual, node);
1903 VisitWord64Compare(this, node, &cont);
1907 void InstructionSelector::VisitUint64LessThan(Node* node) {
1908 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1909 VisitWord64Compare(this, node, &cont);
1913 void InstructionSelector::VisitUint64LessThanOrEqual(Node* node) {
1915 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1916 VisitWord64Compare(this, node, &cont);
1920 void InstructionSelector::VisitFloat32Equal(Node* node) {
1921 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1922 node, &cont);
1926 void InstructionSelector::VisitFloat32LessThan(Node* node) {
1927 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1928 VisitFloat32Compare(this, node, &cont);
1932 void InstructionSelector::VisitFloat32LessThanOrEqual(Node* node) {
1934 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1935 VisitFloat32Compare(this, node, &cont);
1939 void InstructionSelector::VisitFloat64Equal(Node* node) {
1940 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1941 VisitFloat64Compare(this, node, &cont);
1945 void InstructionSelector::VisitFloat64LessThan(Node* node) {
1946 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1947 VisitFloat64Compare(this, node, &cont);
1951 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
1953 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1954 VisitFloat64Compare(this, node, &cont);
1958 void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) {
1959 VisitRR(this, kMips64Float64ExtractLowWord32, node);
1963 void InstructionSelector::VisitFloat64ExtractHighWord32(Node* node) {
1964 VisitRR(this, kMips64Float64ExtractHighWord32, node);
1967 void InstructionSelector::VisitFloat64SilenceNaN(Node* node) {
1968 VisitRR(this, kMips64Float64SilenceNaN, node);
1971 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) {
1973 Node* left = node->InputAt(0);
1974 Node* right = node->InputAt(1);
1975 Emit(kMips64Float64InsertLowWord32, g.DefineSameAsFirst(node),
1980 void InstructionSelector::VisitFloat64InsertHighWord32(Node* node) {
1982 Node* left = node->InputAt(0);
1983 Node* right = node->InputAt(1);
1984 Emit(kMips64Float64InsertHighWord32, g.DefineSameAsFirst(node),
1988 void InstructionSelector::VisitAtomicLoad(Node* node) {
1989 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
1991 Node* base = node->InputAt(0);
1992 Node* index = node->InputAt(1);
2010 g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(index));
2017 g.DefineAsRegister(node), addr_reg, g.TempImmediate(0));
2021 void InstructionSelector::VisitAtomicStore(Node* node) {
2022 MachineRepresentation rep = AtomicStoreRepresentationOf(node->op());
2024 Node* base = node->InputAt(0);
2025 Node* index = node->InputAt(1);
2026 Node* value = node->InputAt(2);
