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 // Use the zero register if the node has the immediate value zero, otherwise
36 InstructionOperand UseRegisterOrImmediateZero(Node* node) {
37 if ((IsIntegerConstant(node) && (GetIntegerConstantValue(node) == 0)) ||
38 (IsFloatConstant(node) &&
39 (bit_cast<int64_t>(GetFloatConstantValue(node)) == V8_INT64_C(0)))) {
40 return UseImmediate(node);
42 return UseRegister(node);
45 bool IsIntegerConstant(Node* node) {
46 return (node->opcode() == IrOpcode::kInt32Constant);
49 int64_t GetIntegerConstantValue(Node* node) {
50 DCHECK(node->opcode() == IrOpcode::kInt32Constant);
51 return OpParameter<int32_t>(node);
54 bool IsFloatConstant(Node* node) {
55 return (node->opcode() == IrOpcode::kFloat32Constant) ||
56 (node->opcode() == IrOpcode::kFloat64Constant);
59 double GetFloatConstantValue(Node* node) {
60 if (node->opcode() == IrOpcode::kFloat32Constant) {
61 return OpParameter<float>(node);
63 DCHECK_EQ(IrOpcode::kFloat64Constant, node->opcode());
64 return OpParameter<double>(node);
67 bool CanBeImmediate(Node* node, InstructionCode opcode) {
68 Int32Matcher m(node);
124 Node* node) {
126 selector->Emit(opcode, g.DefineAsRegister(node),
127 g.UseRegister(node->InputAt(0)),
128 g.UseRegister(node->InputAt(1)));
133 Node* node) {
135 selector->Emit(opcode, g.DefineAsRegister(node),
136 g.UseRegister(node->InputAt(0)));
141 Node* node) {
143 selector->Emit(opcode, g.DefineAsRegister(node),
144 g.UseRegister(node->InputAt(0)),
145 g.UseOperand(node->InputAt(1), opcode));
149 InstructionCode* opcode_return, Node* node,
152 if (g.CanBeImmediate(node, *opcode_return)) {
154 inputs[0] = g.UseImmediate(node);
161 static void VisitBinop(InstructionSelector* selector, Node* node,
166 Int32BinopMatcher m(node);
172 if (TryMatchImmediate(selector, &opcode, m.right().node(), &input_count,
174 inputs[0] = g.UseRegister(m.left().node());
177 TryMatchImmediate(selector, &reverse_opcode, m.left().node(),
179 inputs[0] = g.UseRegister(m.right().node());
183 inputs[input_count++] = g.UseRegister(m.left().node());
184 inputs[input_count++] = g.UseOperand(m.right().node(), opcode);
198 outputs[output_count++] = g.DefineSameAsFirst(node);
200 outputs[output_count++] = g.DefineAsRegister(node);
220 static void VisitBinop(InstructionSelector* selector, Node* node,
224 VisitBinop(selector, node, opcode, has_reverse_opcode, reverse_opcode, &cont);
227 static void VisitBinop(InstructionSelector* selector, Node* node,
229 VisitBinop(selector, node, opcode, false, kArchNop, cont);
232 static void VisitBinop(InstructionSelector* selector, Node* node,
234 VisitBinop(selector, node, opcode, false, kArchNop);
238 void InstructionSelector::VisitLoad(Node* node) {
239 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
241 Node* base = node->InputAt(0);
242 Node* index = node->InputAt(1);
277 g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(index));
284 g.DefineAsRegister(node), addr_reg, g.TempImmediate(0));
288 void InstructionSelector::VisitProtectedLoad(Node* node) {
293 void InstructionSelector::VisitStore(Node* node) {
295 Node* base = node->InputAt(0);
296 Node* index = node->InputAt(1);
297 Node* value = node->InputAt(2);
299 StoreRepresentation store_rep = StoreRepresentationOf(node->op());
378 void InstructionSelector::VisitProtectedStore(Node* node) {
383 void InstructionSelector::VisitWord32And(Node* node) {
385 Int32BinopMatcher m(node);
386 if (m.left().IsWord32Shr() && CanCover(node, m.left().node()) &&
397 Int32BinopMatcher mleft(m.left().node());
409 Emit(kArchNop, g.DefineSameAsFirst(node), g.Use(mleft.left().node()));
411 Emit(kMipsExt, g.DefineAsRegister(node),
412 g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
427 Emit(kMipsIns, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
432 VisitBinop(this, node, kMipsAnd, true, kMipsAnd);
436 void InstructionSelector::VisitWord32Or(Node* node) {
437 VisitBinop(this, node, kMipsOr, true, kMipsOr);
441 void InstructionSelector::VisitWord32Xor(Node* node) {
442 Int32BinopMatcher m(node);
443 if (m.left().IsWord32Or() && CanCover(node, m.left().node()) &&
445 Int32BinopMatcher mleft(m.left().node());
448 Emit(kMipsNor, g.DefineAsRegister(node),
449 g.UseRegister(mleft.left().node()),
450 g.UseRegister(mleft.right().node()));
457 Emit(kMipsNor, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
461 VisitBinop(this, node, kMipsXor, true, kMipsXor);
465 void InstructionSelector::VisitWord32Shl(Node* node) {
466 Int32BinopMatcher m(node);
467 if (m.left().IsWord32And() && CanCover(nodenode()) &&
470 Int32BinopMatcher mleft(m.left().node());
484 Emit(kMipsShl, g.DefineAsRegister(node),
485 g.UseRegister(mleft.left().node()),
486 g.UseImmediate(m.right().node()));
492 VisitRRO(this, kMipsShl, node);
496 void InstructionSelector::VisitWord32Shr(Node* node) {
497 Int32BinopMatcher m(node);
500 Int32BinopMatcher mleft(m.left().node());
510 Emit(kMipsExt, g.DefineAsRegister(node),
511 g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
517 VisitRRO(this, kMipsShr, node);
521 void InstructionSelector::VisitWord32Sar(Node* node) {
522 Int32BinopMatcher m(node);
523 if (m.left().IsWord32Shl() && CanCover(node, m.left().node())) {
524 Int32BinopMatcher mleft(m.left().node());
530 Emit(kMipsSeh, g.DefineAsRegister(node),
531 g.UseRegister(mleft.left().node()));
534 Emit(kMipsSeb, g.DefineAsRegister(node),
535 g.UseRegister(mleft.left().node()));
540 VisitRRO(this, kMipsSar, node);
545 InstructionCode single_opcode, Node* node) {
548 Node* projection1 = NodeProperties::FindProjection(node, 1);
553 InstructionOperand inputs[] = {g.UseUniqueRegister(node->InputAt(0)),
554 g.UseUniqueRegister(node->InputAt(1)),
555 g.UseUniqueRegister(node->InputAt(2)),
556 g.UseUniqueRegister(node->InputAt(3))};
559 g.DefineAsRegister(node),
560 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
565 selector->Emit(single_opcode, g.DefineSameAsFirst(node),
566 g.UseRegister(node->InputAt(0)),
567 g.UseRegister(node->InputAt(2)));
571 void InstructionSelector::VisitInt32PairAdd(Node* node) {
572 VisitInt32PairBinop(this, kMipsAddPair, kMipsAdd, node);
575 void InstructionSelector::VisitInt32PairSub(Node* node) {
576 VisitInt32PairBinop(this, kMipsSubPair, kMipsSub, node);
579 void InstructionSelector::VisitInt32PairMul(Node* node) {
580 VisitInt32PairBinop(this, kMipsMulPair, kMipsMul, node);
585 InstructionCode opcode, Node* node) {
587 Int32Matcher m(node->InputAt(2));
590 shift_operand = g.UseImmediate(m.node());
592 shift_operand = g.UseUniqueRegister(m.node());
597 InstructionOperand inputs[] = {g.UseUniqueRegister(node->InputAt(0)),
598 g.UseUniqueRegister(node->InputAt(1)),
601 Node* projection1 = NodeProperties::FindProjection(node, 1);
608 outputs[output_count++] = g.DefineAsRegister(node);
618 void InstructionSelector::VisitWord32PairShl(Node* node) {
619 VisitWord32PairShift(this, kMipsShlPair, node);
622 void InstructionSelector::VisitWord32PairShr(Node* node) {
623 VisitWord32PairShift(this, kMipsShrPair, node);
626 void InstructionSelector::VisitWord32PairSar(Node* node) {
627 VisitWord32PairShift(this, kMipsSarPair, node);
630 void InstructionSelector::VisitWord32Ror(Node* node) {
631 VisitRRO(this, kMipsRor, node);
635 void InstructionSelector::VisitWord32Clz(Node* node) {
636 VisitRR(this, kMipsClz, node);
640 void InstructionSelector::VisitWord32ReverseBits(Node* node) { UNREACHABLE(); }
642 void InstructionSelector::VisitWord64ReverseBytes(Node* node) { UNREACHABLE(); }
644 void InstructionSelector::VisitWord32ReverseBytes(Node* node) {
646 Emit(kMipsByteSwap32, g.DefineAsRegister(node),
647 g.UseRegister(node->InputAt(0)));
650 void InstructionSelector::VisitWord32Ctz(Node* node) {
652 Emit(kMipsCtz, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
656 void InstructionSelector::VisitWord32Popcnt(Node* node) {
658 Emit(kMipsPopcnt, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
662 void InstructionSelector::VisitInt32Add(Node* node) {
664 Int32BinopMatcher m(node);
668 CanCover(node, m.left().node()) && CanCover(node, m.right().node())) {
669 Int32BinopMatcher mright(m.right().node());
672 Emit(kMipsLsa, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
673 g.UseRegister(mright.left().node()), g.TempImmediate(shift_value));
680 CanCover(node, m.right().node()) && CanCover(node, m.left().node())) {
681 Int32BinopMatcher mleft(m.left().node());
684 Emit(kMipsLsa, g.DefineAsRegister(node), g.UseRegister(m.right().node()),
685 g.UseRegister(mleft.left().node()), g.TempImmediate(shift_value));
690 VisitBinop(this, node, kMipsAdd, true, kMipsAdd);
694 void InstructionSelector::VisitInt32Sub(Node* node) {
695 VisitBinop(this, node, kMipsSub);
699 void InstructionSelector::VisitInt32Mul(Node* node) {
701 Int32BinopMatcher m(node);
706 g.DefineAsRegister(node), g.UseRegister(m.left().node()),
711 Emit(kMipsLsa, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
712 g.UseRegister(m.left().node()),
719 g.UseRegister(m.left().node()),
722 g.DefineAsRegister(node), temp, g.UseRegister(m.left().node()));
726 VisitRRR(this, kMipsMul, node);
730 void InstructionSelector::VisitInt32MulHigh(Node* node) {
731 VisitRRR(this, kMipsMulHigh, node);
735 void InstructionSelector::VisitUint32MulHigh(Node* node) {
737 Emit(kMipsMulHighU, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)),
738 g.UseRegister(node->InputAt(1)));
742 void InstructionSelector::VisitInt32Div(Node* node) {
744 Int32BinopMatcher m(node);
745 Emit(kMipsDiv, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
746 g.UseRegister(m.right().node()));
750 void InstructionSelector::VisitUint32Div(Node* node) {
752 Int32BinopMatcher m(node);
753 Emit(kMipsDivU, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
754 g.UseRegister(m.right().node()));
758 void InstructionSelector::VisitInt32Mod(Node* node) {
760 Int32BinopMatcher m(node);
761 Emit(kMipsMod, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
762 g.UseRegister(m.right().node()));
766 void InstructionSelector::VisitUint32Mod(Node* node) {
768 Int32BinopMatcher m(node);
769 Emit(kMipsModU, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
770 g.UseRegister(m.right().node()));
774 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
775 VisitRR(this, kMipsCvtDS, node);
779 void InstructionSelector::VisitRoundInt32ToFloat32(Node* node) {
780 VisitRR(this, kMipsCvtSW, node);
784 void InstructionSelector::VisitRoundUint32ToFloat32(Node* node) {
785 VisitRR(this, kMipsCvtSUw, node);
789 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) {
790 VisitRR(this, kMipsCvtDW, node);
794 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
795 VisitRR(this, kMipsCvtDUw, node);
799 void InstructionSelector::VisitTruncateFloat32ToInt32(Node* node) {
800 VisitRR(this, kMipsTruncWS, node);
804 void InstructionSelector::VisitTruncateFloat32ToUint32(Node* node) {
805 VisitRR(this, kMipsTruncUwS, node);
809 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) {
811 Node* value = node->InputAt(0);
814 if (CanCover(node, value)) {
817 Emit(kMipsFloorWD, g.DefineAsRegister(node),
821 Emit(kMipsCeilWD, g.DefineAsRegister(node),
825 Emit(kMipsRoundWD, g.DefineAsRegister(node),
829 Emit(kMipsTruncWD, g.DefineAsRegister(node),
836 Node* next = value->InputAt(0);
841 Emit(kMipsFloorWS, g.DefineAsRegister(node),
845 Emit(kMipsCeilWS, g.DefineAsRegister(node),
849 Emit(kMipsRoundWS, g.DefineAsRegister(node),
853 Emit(kMipsTruncWS, g.DefineAsRegister(node),
857 Emit(kMipsTruncWS, g.DefineAsRegister(node),
863 Emit(kMipsTruncWS, g.DefineAsRegister(node),
869 VisitRR(this, kMipsTruncWD, node);
873 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) {
874 VisitRR(this, kMipsTruncUwD, node);
877 void InstructionSelector::VisitTruncateFloat64ToUint32(Node* node) {
878 VisitRR(this, kMipsTruncUwD, node);
881 void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
883 Node* value = node->InputAt(0);
886 if (CanCover(node, value) &&
888 Emit(kMipsCvtSW, g.DefineAsRegister(node),
892 VisitRR(this, kMipsCvtSD, node);
895 void InstructionSelector::VisitTruncateFloat64ToWord32(Node* node) {
896 VisitRR(this, kArchTruncateDoubleToI, node);
899 void InstructionSelector::VisitRoundFloat64ToInt32(Node* node) {
900 VisitRR(this, kMipsTruncWD, node);
903 void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) {
904 VisitRR(this, kMipsFloat64ExtractLowWord32, node);
908 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) {
910 Emit(kMipsFloat64InsertLowWord32, g.DefineAsRegister(node),
912 g.UseRegister(node->InputAt(0)));
916 void InstructionSelector::VisitFloat32Add(Node* node) {
919 Float32BinopMatcher m(node);
920 if (m.left().IsFloat32Mul() && CanCover(node, m.left().node())) {
922 Float32BinopMatcher mleft(m.left().node());
923 Emit(kMipsMaddS, g.DefineAsRegister(node),
924 g.UseRegister(m.right().node()), g.UseRegister(mleft.left().node()),
925 g.UseRegister(mleft.right().node()));
928 if (m.right().IsFloat32Mul() && CanCover(node, m.right().node())) {
930 Float32BinopMatcher mright(m.right().node());
931 Emit(kMipsMaddS, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
932 g.UseRegister(mright.left().node()),
933 g.UseRegister(mright.right().node()));
937 VisitRRR(this, kMipsAddS, node);
941 void InstructionSelector::VisitFloat64Add(Node* node) {
944 Float64BinopMatcher m(node);
945 if (m.left().IsFloat64Mul() && CanCover(node, m.left().node())) {
947 Float64BinopMatcher mleft(m.left().node());
948 Emit(kMipsMaddD, g.DefineAsRegister(node),
949 g.UseRegister(m.right().node()), g.UseRegister(mleft.left().node()),
950 node()));
953 if (m.right().IsFloat64Mul() && CanCover(node, m.right().node())) {
955 Float64BinopMatcher mright(m.right().node());
956 Emit(kMipsMaddD, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
957 g.UseRegister(mright.left().node()),
958 g.UseRegister(mright.right().node()));
962 VisitRRR(this, kMipsAddD, node);
966 void InstructionSelector::VisitFloat32Sub(Node* node) {
969 Float32BinopMatcher m(node);
970 if (m.left().IsFloat32Mul() && CanCover(node, m.left().node())) {
972 Float32BinopMatcher mleft(m.left().node());
973 Emit(kMipsMsubS, g.DefineAsRegister(node),
974 g.UseRegister(m.right().node()), g.UseRegister(mleft.left().node()),
975 g.UseRegister(mleft.right().node()));
979 VisitRRR(this, kMipsSubS, node);
982 void InstructionSelector::VisitFloat64Sub(Node* node) {
985 Float64BinopMatcher m(node);
986 if (m.left().IsFloat64Mul() && CanCover(node, m.left().node())) {
988 Float64BinopMatcher mleft(m.left().node());
989 Emit(kMipsMsubD, g.DefineAsRegister(node),
990 g.UseRegister(m.right().node()), g.UseRegister(mleft.left().node()),
991 g.UseRegister(mleft.right().node()));
995 VisitRRR(this, kMipsSubD, node);
998 void InstructionSelector::VisitFloat32Mul(Node* node) {
999 VisitRRR(this, kMipsMulS, node);
1003 void InstructionSelector::VisitFloat64Mul(Node* node) {
1004 VisitRRR(this, kMipsMulD, node);
1008 void InstructionSelector::VisitFloat32Div(Node* node) {
1009 VisitRRR(this, kMipsDivS, node);
1013 void InstructionSelector::VisitFloat64Div(Node* node) {
1014 VisitRRR(this, kMipsDivD, node);
1018 void InstructionSelector::VisitFloat64Mod(Node* node) {
1020 Emit(kMipsModD, g.DefineAsFixed(node, f0), g.UseFixed(node->InputAt(0), f12),
1021 g.UseFixed(node->InputAt(1), f14))->MarkAsCall();
1024 void InstructionSelector::VisitFloat32Max(Node* node) {
1026 Emit(kMipsFloat32Max, g.DefineAsRegister(node),
1027 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
1030 void InstructionSelector::VisitFloat64Max(Node* node) {
1032 Emit(kMipsFloat64Max, g.DefineAsRegister(node),
1033 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
1036 void InstructionSelector::VisitFloat32Min(Node* node) {
1038 Emit(kMipsFloat32Min, g.DefineAsRegister(node),
1039 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
1042 void InstructionSelector::VisitFloat64Min(Node* node) {
1044 Emit(kMipsFloat64Min, g.DefineAsRegister(node),
1045 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
1049 void InstructionSelector::VisitFloat32Abs(Node* node) {
1050 VisitRR(this, kMipsAbsS, node);
1054 void InstructionSelector::VisitFloat64Abs(Node* node) {
1055 VisitRR(this, kMipsAbsD, node);
1058 void InstructionSelector::VisitFloat32Sqrt(Node* node) {
1059 VisitRR(this, kMipsSqrtS, node);
1063 void InstructionSelector::VisitFloat64Sqrt(Node* node) {
1064 VisitRR(this, kMipsSqrtD, node);
1068 void InstructionSelector::VisitFloat32RoundDown(Node* node) {
1069 VisitRR(this, kMipsFloat32RoundDown, node);
1073 void InstructionSelector::VisitFloat64RoundDown(Node* node) {
1074 VisitRR(this, kMipsFloat64RoundDown, node);
1078 void InstructionSelector::VisitFloat32RoundUp(Node* node) {
1079 VisitRR(this, kMipsFloat32RoundUp, node);
1083 void InstructionSelector::VisitFloat64RoundUp(Node* node) {
1084 VisitRR(this, kMipsFloat64RoundUp, node);
1088 void InstructionSelector::VisitFloat32RoundTruncate(Node* node) {
1089 VisitRR(this, kMipsFloat32RoundTruncate, node);
1093 void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
1094 VisitRR(this, kMipsFloat64RoundTruncate, node);
1098 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
1103 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) {
1104 VisitRR(this, kMipsFloat32RoundTiesEven, node);
1108 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) {
1109 VisitRR(this, kMipsFloat64RoundTiesEven, node);
1112 void InstructionSelector::VisitFloat32Neg(Node* node) {
1113 VisitRR(this, kMipsNegS, node);
1116 void InstructionSelector::VisitFloat64Neg(Node* node) {
1117 VisitRR(this, kMipsNegD, node);
1120 void InstructionSelector::VisitFloat64Ieee754Binop(Node* node,
1123 Emit(opcode, g.DefineAsFixed(node, f0), g.UseFixed(node->InputAt(0), f2),
1124 g.UseFixed(node->InputAt(1), f4))
1128 void InstructionSelector::VisitFloat64Ieee754Unop(Node* node,
1131 Emit(opcode, g.DefineAsFixed(node, f0), g.UseFixed(node->InputAt(0), f12))
1137 Node* node) {
1149 if (input.node()) {
1150 Emit(kMipsStoreToStackSlot, g.NoOutput(), g.UseRegister(input.node()),
1164 if (input.node()) {
1165 Emit(kMipsStoreToStackSlot, g.NoOutput(), g.UseRegister(input.node()),
1177 void InstructionSelector::VisitUnalignedLoad(Node* node) {
1179 UnalignedLoadRepresentationOf(node->op());
1181 Node* base = node->InputAt(0);
1182 Node* index = node->InputAt(1);
1217 g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(index));
1224 g.DefineAsRegister(node), addr_reg, g.TempImmediate(0));
1228 void InstructionSelector::VisitUnalignedStore(Node* node) {
1230 Node* base = node->InputAt(0);
1231 Node* index = node->InputAt(1);
1232 Node* value = node->InputAt(2);
1234 UnalignedStoreRepresentation rep = UnalignedStoreRepresentationOf(node->op());
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);
1329 g.DefineAsRegister(node), offset_operand, length_operand,
1334 void InstructionSelector::VisitCheckedStore(Node* node) {
1335 MachineRepresentation rep = CheckedStoreRepresentationOf(node->op());
1337 Node* const buffer = node->InputAt(0);
1338 Node* const offset = node->InputAt(1);
1339 Node* const length = node->InputAt(2);
1340 Node* const value = node->InputAt(3);
1402 void VisitFloat32Compare(InstructionSelector* selector, Node* node,
1405 Float32BinopMatcher m(node);
1408 lhs = m.left().IsZero() ? g.UseImmediate(m.left().node())
1409 : g.UseRegister(m.left().node());
1410 rhs = m.right().IsZero() ? g.UseImmediate(m.right().node())
1411 : g.UseRegister(m.right().node());
1417 void VisitFloat64Compare(InstructionSelector* selector, Node* node,
1420 Float64BinopMatcher m(node);
1423 lhs = m.left().IsZero() ? g.UseImmediate(m.left().node())
1424 node());
1425 rhs = m.right().IsZero() ? g.UseImmediate(m.right().node())
1426 : g.UseRegister(m.right().node());
1432 void VisitWordCompare(InstructionSelector* selector, Node* node,
1436 Node* left = node->InputAt(0);
1437 Node* right = node->InputAt(1);
1504 void VisitWordCompare(InstructionSelector* selector, Node* node,
1506 VisitWordCompare(selector, node, kMipsCmp, cont, false);
1510 void VisitWordCompareZero(InstructionSelector* selector, Node* user,
1511 Node* value, FlagsContinuation* cont) {
1519 value = m.left().node();
1560 // <Operation>WithOverflow node.
1567 Node* const node = value->InputAt(0);
1568 Node* const result = NodeProperties::FindProjection(node, 0);
1570 switch (node->opcode()) {
1573 return VisitBinop(selector, node, kMipsAddOvf, cont);
1576 return VisitBinop(selector, node, kMipsSubOvf, cont);
1579 return VisitBinop(selector, node, kMipsMulOvf, cont);
1616 void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
1622 void InstructionSelector::VisitDeoptimizeIf(Node* node) {
1623 DeoptimizeParameters p = DeoptimizeParametersOf(node->op());
1625 kNotEqual, p.kind(), p.reason(), node->InputAt(1));
1626 VisitWordCompareZero(this, node, node->InputAt(0), &cont);
1629 void InstructionSelector::VisitDeoptimizeUnless(Node* node) {
1630 DeoptimizeParameters p = DeoptimizeParametersOf(node->op());
1632 kEqual, p.kind(), p.reason(), node->InputAt(1));
1633 VisitWordCompareZero(this, node, node->InputAt(0), &cont);
1636 void InstructionSelector::VisitTrapIf(Node* node, Runtime::FunctionId func_id) {
1638 FlagsContinuation::ForTrap(kNotEqual, func_id, node->InputAt(1));
1639 VisitWordCompareZero(this, node, node->InputAt(0), &cont);
1642 void InstructionSelector::VisitTrapUnless(Node* node,
1645 FlagsContinuation::ForTrap(kEqual, func_id, node->InputAt(1));
1646 VisitWordCompareZero(this, node, node->InputAt(0), &cont);
1649 void InstructionSelector::VisitSwitch(Node* node, const SwitchInfo& sw) {
1651 InstructionOperand value_operand = g.UseRegister(node->InputAt(0));
1677 void InstructionSelector::VisitWord32Equal(Node* const node) {
1678 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1679 Int32BinopMatcher m(node);
1681 return VisitWordCompareZero(this, m.node(), m.left().node(), &cont);
1683 VisitWordCompare(this, node, &cont);
1687 void InstructionSelector::VisitInt32LessThan(Node* node) {
1688 FlagsContinuation cont = FlagsContinuation::ForSet(kSignedLessThan, node);
1689 VisitWordCompare(this, node, &cont);
1693 void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
1695 FlagsContinuation::ForSet(kSignedLessThanOrEqual, node);
1696 VisitWordCompare(this, node, &cont);
1700 void InstructionSelector::VisitUint32LessThan(Node* node) {
1701 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1702 VisitWordCompare(this, node, &cont);
1706 void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
1708 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1709 VisitWordCompare(this, node, &cont);
1713 void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
1714 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1716 return VisitBinop(this, node, kMipsAddOvf, &cont);
1719 VisitBinop(this, node, kMipsAddOvf, &cont);
1723 void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
1724 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1726 return VisitBinop(this, node, kMipsSubOvf, &cont);
1729 VisitBinop(this, node, kMipsSubOvf, &cont);
1732 void InstructionSelector::VisitInt32MulWithOverflow(Node* node) {
1733 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1735 return VisitBinop(this, node, kMipsMulOvf, &cont);
1738 VisitBinop(this, node, kMipsMulOvf, &cont);
1741 void InstructionSelector::VisitFloat32Equal(Node* node) {
1742 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1743 VisitFloat32Compare(this, node, &cont);
1747 void InstructionSelector::VisitFloat32LessThan(Node* node) {
1748 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1749 VisitFloat32Compare(this, node, &cont);
1753 void InstructionSelector::VisitFloat32LessThanOrEqual(Node* node) {
1755 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1756 VisitFloat32Compare(this, node, &cont);
1760 void InstructionSelector::VisitFloat64Equal(Node* node) {
1761 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1762 VisitFloat64Compare(this, node, &cont);
1766 void InstructionSelector::VisitFloat64LessThan(Node* node) {
1767 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1768 VisitFloat64Compare(this, node, &cont);
1772 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
1774 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1775 VisitFloat64Compare(this, node, &cont);
1779 void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) {
1781 Emit(kMipsFloat64ExtractLowWord32, g.DefineAsRegister(node),
1782 g.UseRegister(node->InputAt(0)));
1786 void InstructionSelector::VisitFloat64ExtractHighWord32(Node* node) {
1788 Emit(kMipsFloat64ExtractHighWord32, g.DefineAsRegister(node),
1789 g.UseRegister(node->InputAt(0)));
1793 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) {
1795 Node* left = node->InputAt(0);
1796 Node* right = node->InputAt(1);
1797 Emit(kMipsFloat64InsertLowWord32, g.DefineSameAsFirst(node),
1802 void InstructionSelector::VisitFloat64InsertHighWord32(Node* node) {
1804 Node* left = node->InputAt(0);
1805 Node* right = node->InputAt(1);
1806 Emit(kMipsFloat64InsertHighWord32, g.DefineSameAsFirst(node),
1810 void InstructionSelector::VisitFloat64SilenceNaN(Node* node) {
1812 Node* left = node->InputAt(0);
1814 Emit(kMipsFloat64SilenceNaN, g.DefineSameAsFirst(node), g.UseRegister(left),
1818 void InstructionSelector::VisitAtomicLoad(Node* node) {
1819 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
1821 Node* base = node->InputAt(0);
1822 Node* index = node->InputAt(1);
1841 g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(index));
1848 g.DefineAsRegister(node), addr_reg, g.TempImmediate(0));
1852 void InstructionSelector::VisitAtomicStore(Node* node) {
1853 MachineRepresentation rep = AtomicStoreRepresentationOf(node->op());
1855 Node* base = node->InputAt(0);
1856 Node* index = node->InputAt(1);
1857 Node* value = node->InputAt(2);
