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) {
35 Int32Matcher m(node);
65 Node* node) {
67 selector->Emit(opcode, g.DefineAsRegister(node),
68 g.UseRegister(node->InputAt(0)),
69 g.UseRegister(node->InputAt(1)));
74 Node* node) {
76 selector->Emit(opcode, g.DefineAsRegister(node),
77 g.UseRegister(node->InputAt(0)));
82 Node* node) {
84 selector->Emit(opcode, g.DefineAsRegister(node),
85 g.UseRegister(node->InputAt(0)),
86 g.UseOperand(node->InputAt(1), opcode));
90 static void VisitBinop(InstructionSelector* selector, Node* node,
93 Int32BinopMatcher m(node);
99 inputs[input_count++] = g.UseRegister(m.left().node());
100 inputs[input_count++] = g.UseOperand(m.right().node(), opcode);
107 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);
168 g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(index));
175 g.DefineAsRegister(node), addr_reg, g.TempImmediate(0));
180 void InstructionSelector::VisitStore(Node* node) {
182 Node* base = node->InputAt(0);
183 Node* index = node->InputAt(1);
184 Node* value = node->InputAt(2);
186 StoreRepresentation store_rep = StoreRepresentationOf(node->op());
260 void InstructionSelector::VisitWord32And(Node* node) {
262 Int32BinopMatcher m(node);
263 if (m.left().IsWord32Shr() && CanCover(node, m.left().node()) &&
274 Int32BinopMatcher mleft(m.left().node());
285 Emit(kMipsExt, g.DefineAsRegister(node),
286 g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
300 Emit(kMipsIns, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
305 VisitBinop(this, node, kMipsAnd);
309 void InstructionSelector::VisitWord32Or(Node* node) {
310 VisitBinop(this, node, kMipsOr);
314 void InstructionSelector::VisitWord32Xor(Node* node) {
315 Int32BinopMatcher m(node);
316 if (m.left().IsWord32Or() && CanCover(node, m.left().node()) &&
318 Int32BinopMatcher mleft(m.left().node());
321 Emit(kMipsNor, g.DefineAsRegister(node),
322 g.UseRegister(mleft.left().node()),
323 g.UseRegister(mleft.right().node()));
330 Emit(kMipsNor, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
334 VisitBinop(this, node, kMipsXor);
338 void InstructionSelector::VisitWord32Shl(Node* node) {
339 Int32BinopMatcher m(node);
340 if (m.left().IsWord32And() && CanCover(node, m.left().node()) &&
343 Int32BinopMatcher mleft(m.left().node());
357 Emit(kMipsShl, g.DefineAsRegister(node),
358 g.UseRegister(mleft.left().node()),
359 g.UseImmediate(m.right().node()));
365 VisitRRO(this, kMipsShl, node);
369 void InstructionSelector::VisitWord32Shr(Node* node) {
370 Int32BinopMatcher m(node);
373 Int32BinopMatcher mleft(m.left().node());
383 Emit(kMipsExt, g.DefineAsRegister(node),
384 g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
390 VisitRRO(this, kMipsShr, node);
394 void InstructionSelector::VisitWord32Sar(Node* node) {
395 VisitRRO(this, kMipsSar, node);
399 InstructionCode opcode, Node* node) {
404 InstructionOperand inputs[] = {g.UseUniqueRegister(node->InputAt(0)),
405 g.UseUniqueRegister(node->InputAt(1)),
406 g.UseUniqueRegister(node->InputAt(2)),
407 g.UseUniqueRegister(node->InputAt(3))};
410 g.DefineAsRegister(node),
411 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
415 void InstructionSelector::VisitInt32PairAdd(Node* node) {
416 VisitInt32PairBinop(this, kMipsAddPair, node);
419 void InstructionSelector::VisitInt32PairSub(Node* node) {
420 VisitInt32PairBinop(this, kMipsSubPair, node);
423 void InstructionSelector::VisitInt32PairMul(Node* node) {
424 VisitInt32PairBinop(this, kMipsMulPair, node);
429 InstructionCode opcode, Node* node) {
431 Int32Matcher m(node->InputAt(2));
434 shift_operand = g.UseImmediate(m.node());
436 shift_operand = g.UseUniqueRegister(m.node());
441 InstructionOperand inputs[] = {g.UseUniqueRegister(node->InputAt(0)),
442 g.UseUniqueRegister(node->InputAt(1)),
446 g.DefineAsRegister(node),
447 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
452 void InstructionSelector::VisitWord32PairShl(Node* node) {
453 VisitWord32PairShift(this, kMipsShlPair, node);
456 void InstructionSelector::VisitWord32PairShr(Node* node) {
457 VisitWord32PairShift(this, kMipsShrPair, node);
460 void InstructionSelector::VisitWord32PairSar(Node* node) {
461 VisitWord32PairShift(this, kMipsSarPair, node);
464 void InstructionSelector::VisitWord32Ror(Node* node) {
465 VisitRRO(this, kMipsRor, node);
469 void InstructionSelector::VisitWord32Clz(Node* node) {
470 VisitRR(this, kMipsClz, node);
474 void InstructionSelector::VisitWord32ReverseBits(Node* node) { UNREACHABLE(); }
477 Node* node) {
479 Emit(kMipsCtz, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
483 void InstructionSelector::VisitWord32Popcnt(Node* node) {
485 Emit(kMipsPopcnt, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
489 void InstructionSelector::VisitInt32Add(Node* node) {
491 Int32BinopMatcher m(node);
495 CanCover(node, m.left().node()) && CanCover(node, m.right().node())) {
496 Int32BinopMatcher mright(m.right().node());
499 Emit(kMipsLsa, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
500 g.UseRegister(mright.left().node()), g.TempImmediate(shift_value));
507 CanCover(node, m.right().node()) && CanCover(node, m.left().node())) {
508 Int32BinopMatcher mleft(m.left().node());
511 Emit(kMipsLsa, g.DefineAsRegister(node), g.UseRegister(m.right().node()),
512 g.UseRegister(mleft.left().node()), g.TempImmediate(shift_value));
517 VisitBinop(this, node, kMipsAdd);
521 void InstructionSelector::VisitInt32Sub(Node* node) {
522 VisitBinop(this, node, kMipsSub);
526 void InstructionSelector::VisitInt32Mul(Node* node) {
528 Int32BinopMatcher m(node);
533 g.DefineAsRegister(node), g.UseRegister(m.left().node()),
538 Emit(kMipsLsa, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
539 g.UseRegister(m.left().node()),
546 g.UseRegister(m.left().node()),
549 g.DefineAsRegister(node), temp, g.UseRegister(m.left().node()));
553 VisitRRR(this, kMipsMul, node);
557 void InstructionSelector::VisitInt32MulHigh(Node* node) {
558 VisitRRR(this, kMipsMulHigh, node);
562 void InstructionSelector::VisitUint32MulHigh(Node* node) {
564 Emit(kMipsMulHighU, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)),
565 g.UseRegister(node->InputAt(1)));
569 void InstructionSelector::VisitInt32Div(Node* node) {
571 Int32BinopMatcher m(node);
572 Emit(kMipsDiv, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
573 g.UseRegister(m.right().node()));
577 void InstructionSelector::VisitUint32Div(Node* node) {
579 Int32BinopMatcher m(node);
580 Emit(kMipsDivU, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
581 g.UseRegister(m.right().node()));
585 void InstructionSelector::VisitInt32Mod(Node* node) {
587 Int32BinopMatcher m(node);
588 Emit(kMipsMod, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
589 g.UseRegister(m.right().node()));
593 void InstructionSelector::VisitUint32Mod(Node* node) {
595 Int32BinopMatcher m(node);
596 Emit(kMipsModU, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
597 g.UseRegister(m.right().node()));
601 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
602 VisitRR(this, kMipsCvtDS, node);
606 void InstructionSelector::VisitRoundInt32ToFloat32(Node* node) {
607 VisitRR(this, kMipsCvtSW, node);
611 void InstructionSelector::VisitRoundUint32ToFloat32(Node* node) {
612 VisitRR(this, kMipsCvtSUw, node);
616 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) {
617 VisitRR(this, kMipsCvtDW, node);
621 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
622 VisitRR(this, kMipsCvtDUw, node);
626 void InstructionSelector::VisitTruncateFloat32ToInt32(Node* node) {
627 VisitRR(this, kMipsTruncWS, node);
631 void InstructionSelector::VisitTruncateFloat32ToUint32(Node* node) {
632 VisitRR(this, kMipsTruncUwS, node);
636 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) {
638 Node* value = node->InputAt(0);
641 if (CanCover(node, value)) {
644 Emit(kMipsFloorWD, g.DefineAsRegister(node),
648 Emit(kMipsCeilWD, g.DefineAsRegister(node),
652 Emit(kMipsRoundWD, g.DefineAsRegister(node),
656 Emit(kMipsTruncWD, g.DefineAsRegister(node),
663 Node* next = value->InputAt(0);
668 Emit(kMipsFloorWS, g.DefineAsRegister(node),
672 Emit(kMipsCeilWS, g.DefineAsRegister(node),
676 Emit(kMipsRoundWS, g.DefineAsRegister(node),
680 Emit(kMipsTruncWS, g.DefineAsRegister(node),
684 Emit(kMipsTruncWS, g.DefineAsRegister(node),
690 Emit(kMipsTruncWS, g.DefineAsRegister(node),
696 VisitRR(this, kMipsTruncWD, node);
700 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) {
701 VisitRR(this, kMipsTruncUwD, node);
704 void InstructionSelector::VisitTruncateFloat64ToUint32(Node* node) {
705 VisitRR(this, kMipsTruncUwD, node);
708 void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
710 Node* value = node->InputAt(0);
713 if (CanCover(node, value) &&
715 Emit(kMipsCvtSW, g.DefineAsRegister(node),
719 VisitRR(this, kMipsCvtSD, node);
722 void InstructionSelector::VisitTruncateFloat64ToWord32(Node* node) {
723 VisitRR(this, kArchTruncateDoubleToI, node);
726 void InstructionSelector::VisitRoundFloat64ToInt32(Node* node) {
727 VisitRR(this, kMipsTruncWD, node);
730 void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) {
731 VisitRR(this, kMipsFloat64ExtractLowWord32, node);
735 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) {
737 Emit(kMipsFloat64InsertLowWord32, g.DefineAsRegister(node),
739 g.UseRegister(node->InputAt(0)));
743 void InstructionSelector::VisitFloat32Add(Node* node) {
744 VisitRRR(this, kMipsAddS, node);
748 void InstructionSelector::VisitFloat64Add(Node* node) {
749 VisitRRR(this, kMipsAddD, node);
753 void InstructionSelector::VisitFloat32Sub(Node* node) {
754 VisitRRR(this, kMipsSubS, node);
757 void InstructionSelector::VisitFloat32SubPreserveNan(Node* node) {
758 VisitRRR(this, kMipsSubPreserveNanS, node);
761 void InstructionSelector::VisitFloat64Sub(Node* node) {
763 Float64BinopMatcher m(node);
765 CanCover(m.node(), m.right().node())) {
767 CanCover(m.right().node(), m.right().InputAt(0))) {
770 Emit(kMipsFloat64RoundUp, g.DefineAsRegister(node),
771 g.UseRegister(mright0.right().node()));
776 VisitRRR(this, kMipsSubD, node);
779 void InstructionSelector::VisitFloat64SubPreserveNan(Node* node) {
780 VisitRRR(this, kMipsSubPreserveNanD, node);
783 void InstructionSelector::VisitFloat32Mul(Node* node) {
784 VisitRRR(this, kMipsMulS, node);
788 void InstructionSelector::VisitFloat64Mul(Node* node) {
789 VisitRRR(this, kMipsMulD, node);
793 void InstructionSelector::VisitFloat32Div(Node* node) {
794 VisitRRR(this, kMipsDivS, node);
798 void InstructionSelector::VisitFloat64Div(Node* node) {
799 VisitRRR(this, kMipsDivD, node);
803 void InstructionSelector::VisitFloat64Mod(Node* node) {
805 Emit(kMipsModD, g.DefineAsFixed(node, f0), g.UseFixed(node->InputAt(0), f12),
806 g.UseFixed(node->InputAt(1), f14))->MarkAsCall();
810 void InstructionSelector::VisitFloat32Max(Node* node) {
813 Emit(kMipsFloat32Max, g.DefineAsRegister(node),
814 g.UseUniqueRegister(node->InputAt(0)),
815 g.UseUniqueRegister(node->InputAt(1)));
819 Emit(kMipsFloat32Max, g.DefineSameAsFirst(node),
820 g.UseRegister(node->InputAt(1)), g.UseRegister(node->InputAt(0)));
825 void InstructionSelector::VisitFloat64Max(Node* node) {
828 Emit(kMipsFloat64Max, g.DefineAsRegister(node),
829 g.UseUniqueRegister(node->InputAt(0)),
830 g.UseUniqueRegister(node->InputAt(1)));
834 Emit(kMipsFloat64Max, g.DefineSameAsFirst(node),
835 g.UseRegister(node->InputAt(1)), g.UseRegister(node->InputAt(0)));
840 void InstructionSelector::VisitFloat32Min(Node* node) {
843 Emit(kMipsFloat32Min, g.DefineAsRegister(node),
844 g.UseUniqueRegister(node->InputAt(0)),
845 g.UseUniqueRegister(node->InputAt(1)));
849 Emit(kMipsFloat32Min, g.DefineSameAsFirst(node),
850 g.UseRegister(node->InputAt(1)), g.UseRegister(node->InputAt(0)));
855 void InstructionSelector::VisitFloat64Min(Node* node) {
858 Emit(kMipsFloat64Min, g.DefineAsRegister(node),
859 g.UseUniqueRegister(node->InputAt(0)),
860 g.UseUniqueRegister(node->InputAt(1)));
864 Emit(kMipsFloat64Min, g.DefineSameAsFirst(node),
865 g.UseRegister(node->InputAt(1)), g.UseRegister(node->InputAt(0)));
870 void InstructionSelector::VisitFloat32Abs(Node* node) {
871 VisitRR(this, kMipsAbsS, node);
875 void InstructionSelector::VisitFloat64Abs(Node* node) {
876 VisitRR(this, kMipsAbsD, node);
879 void InstructionSelector::VisitFloat32Sqrt(Node* node) {
880 VisitRR(this, kMipsSqrtS, node);
884 void InstructionSelector::VisitFloat64Sqrt(Node* node) {
885 VisitRR(this, kMipsSqrtD, node);
889 void InstructionSelector::VisitFloat32RoundDown(Node* node) {
890 VisitRR(this, kMipsFloat32RoundDown, node);
894 void InstructionSelector::VisitFloat64RoundDown(Node* node) {
895 VisitRR(this, kMipsFloat64RoundDown, node);
899 void InstructionSelector::VisitFloat32RoundUp(Node* node) {
900 VisitRR(this, kMipsFloat32RoundUp, node);
904 void InstructionSelector::VisitFloat64RoundUp(Node* node) {
905 VisitRR(this, kMipsFloat64RoundUp, node);
909 void InstructionSelector::VisitFloat32RoundTruncate(Node* node) {
910 VisitRR(this, kMipsFloat32RoundTruncate, node);
914 void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
915 VisitRR(this, kMipsFloat64RoundTruncate, node);
919 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
924 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) {
925 VisitRR(this, kMipsFloat32RoundTiesEven, node);
929 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) {
930 VisitRR(this, kMipsFloat64RoundTiesEven, node);
933 void InstructionSelector::VisitFloat32Neg(Node* node) { UNREACHABLE(); }
935 void InstructionSelector::VisitFloat64Neg(Node* node) { UNREACHABLE(); }
937 void InstructionSelector::VisitFloat64Ieee754Binop(Node* node,
940 Emit(opcode, g.DefineAsFixed(node, f0), g.UseFixed(node->InputAt(0), f12),
941 g.UseFixed(node->InputAt(1), f14))
945 void InstructionSelector::VisitFloat64Ieee754Unop(Node* node,
948 Emit(opcode, g.DefineAsFixed(node, f0), g.UseFixed(node->InputAt(0), f12))
954 Node* node) {
966 if (input.node()) {
967 Emit(kMipsStoreToStackSlot, g.NoOutput(), g.UseRegister(input.node()),
981 if (input.node()) {
982 Emit(kMipsStoreToStackSlot, g.NoOutput(), g.UseRegister(input.node()),
994 void InstructionSelector::VisitCheckedLoad(Node* node) {
995 CheckedLoadRepresentation load_rep = CheckedLoadRepresentationOf(node->op());
997 Node* const buffer = node->InputAt(0);
998 Node* const offset = node->InputAt(1);
999 Node* const length = node->InputAt(2);
1036 g.DefineAsRegister(node), offset_operand, length_operand,
1041 void InstructionSelector::VisitCheckedStore(Node* node) {
1042 MachineRepresentation rep = CheckedStoreRepresentationOf(node->op());
1044 Node* const buffer = node->InputAt(0);
1045 Node* const offset = node->InputAt(1);
1046 Node* const length = node->InputAt(2);
1047 Node* const value = node->InputAt(3);
1106 void VisitFloat32Compare(InstructionSelector* selector, Node* node,
1109 Float32BinopMatcher m(node);
1112 lhs = m.left().IsZero() ? g.UseImmediate(m.left().node())
1113 : g.UseRegister(m.left().node());
1114 rhs = m.right().IsZero() ? g.UseImmediate(m.right().node())
1115 : g.UseRegister(m.right().node());
1121 void VisitFloat64Compare(InstructionSelector* selector, Node* node,
1124 Float64BinopMatcher m(node);
1127 lhs = m.left().IsZero() ? g.UseImmediate(m.left().node())
1128 : g.UseRegister(m.left().node());
1129 rhs = m.right().IsZero() ? g.UseImmediate(m.right().node())
1130 : g.UseRegister(m.right().node());
1136 void VisitWordCompare(InstructionSelector* selector, Node* node,
1140 Node* left = node->InputAt(0);
1141 Node* right = node->InputAt(1);
1198 void VisitWordCompare(InstructionSelector* selector, Node* node,
1200 VisitWordCompare(selector, node, kMipsCmp, cont, false);
1204 void VisitWordCompareZero(InstructionSelector* selector, Node* user,
1205 Node* value, FlagsContinuation* cont) {
1214 value = m.left().node();
1253 // <Operation>WithOverflow node.
1260 Node* const node = value->InputAt(0);
1261 Node* const result = NodeProperties::FindProjection(node, 0);
1263 switch (node->opcode()) {
1266 return VisitBinop(selector, node, kMipsAddOvf, cont);
1269 return VisitBinop(selector, node, kMipsSubOvf, cont);
1303 void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
1309 void InstructionSelector::VisitDeoptimizeIf(Node* node) {
1311 FlagsContinuation::ForDeoptimize(kNotEqual, node->InputAt(1));
1312 VisitWordCompareZero(this, node, node->InputAt(0), &cont);
1315 void InstructionSelector::VisitDeoptimizeUnless(Node* node) {
1317 FlagsContinuation::ForDeoptimize(kEqual, node->InputAt(1));
1318 VisitWordCompareZero(this, node, node->InputAt(0), &cont);
1321 void InstructionSelector::VisitSwitch(Node* node, const SwitchInfo& sw) {
1323 InstructionOperand value_operand = g.UseRegister(node->InputAt(0));
1349 void InstructionSelector::VisitWord32Equal(Node* const node) {
1350 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1351 Int32BinopMatcher m(node);
1353 return VisitWordCompareZero(this, m.node(), m.left().node(), &cont);
1355 VisitWordCompare(this, node, &cont);
1359 void InstructionSelector::VisitInt32LessThan(Node* node) {
1360 FlagsContinuation cont = FlagsContinuation::ForSet(kSignedLessThan, node);
1361 VisitWordCompare(this, node, &cont);
1365 void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
1367 FlagsContinuation::ForSet(kSignedLessThanOrEqual, node);
1368 VisitWordCompare(this, node, &cont);
1372 void InstructionSelector::VisitUint32LessThan(Node* node) {
1373 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1374 VisitWordCompare(this, node, &cont);
1378 void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
1380 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1381 VisitWordCompare(this, node, &cont);
1385 void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
1386 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1388 return VisitBinop(this, node, kMipsAddOvf, &cont);
1391 VisitBinop(this, node, kMipsAddOvf, &cont);
1395 void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
1396 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1398 return VisitBinop(this, node, kMipsSubOvf, &cont);
1401 VisitBinop(this, node, kMipsSubOvf, &cont);
1405 void InstructionSelector::VisitFloat32Equal(Node* node) {
1406 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1407 VisitFloat32Compare(this, node, &cont);
1411 void InstructionSelector::VisitFloat32LessThan(Node* node) {
1412 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1413 VisitFloat32Compare(this, node, &cont);
1417 void InstructionSelector::VisitFloat32LessThanOrEqual(Node* node) {
1419 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1420 VisitFloat32Compare(this, node, &cont);
1424 void InstructionSelector::VisitFloat64Equal(Node* node) {
1425 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1426 VisitFloat64Compare(this, node, &cont);
1430 void InstructionSelector::VisitFloat64LessThan(Node* node) {
1431 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1432 VisitFloat64Compare(this, node, &cont);
1436 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
1438 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1439 VisitFloat64Compare(this, node, &cont);
1443 void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) {
1445 Emit(kMipsFloat64ExtractLowWord32, g.DefineAsRegister(node),
1446 g.UseRegister(node->InputAt(0)));
1450 Node* node) {
1452 Emit(kMipsFloat64ExtractHighWord32, g.DefineAsRegister(node),
1453 g.UseRegister(node->InputAt(0)));
1457 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) {
1459 Node* left = node->InputAt(0);
1460 Node* right = node->InputAt(1);
1461 Emit(kMipsFloat64InsertLowWord32, g.DefineSameAsFirst(node),
1466 void InstructionSelector::VisitFloat64InsertHighWord32(Node* node) {
1468 Node* left = node->InputAt(0);
1469 Node* right = node->InputAt(1);
1470 Emit(kMipsFloat64InsertHighWord32, g.DefineSameAsFirst(node),
1474 void InstructionSelector::VisitFloat64SilenceNaN(Node* node) {
1476 Node* left = node->InputAt(0);
1478 Emit(kMipsFloat64SilenceNaN, g.DefineSameAsFirst(node), g.UseRegister(left),
1482 void InstructionSelector::VisitAtomicLoad(Node* node) {
1483 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
1485 Node* base = node->InputAt(0);
1486 Node* index = node->InputAt(1);
1504 g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(index));
1511 g.DefineAsRegister(node), addr_reg, g.TempImmediate(0));
1515 void InstructionSelector::VisitAtomicStore(Node* node) {
1516 MachineRepresentation rep = AtomicStoreRepresentationOf(node->op());
1518 Node* base = node->InputAt(0);
1519 Node* index = node->InputAt(1);
1520 Node* value = node->InputAt(2);
