Lines Matching refs:node
7 #include "src/compiler/node-matchers.h"
8 #include "src/compiler/node-properties.h"
32 InstructionOperand UseOperand(Node* node, ImmediateMode mode) {
33 if (CanBeImmediate(node, mode)) {
34 return UseImmediate(node);
36 return UseRegister(node);
39 bool CanBeImmediate(Node* node, ImmediateMode mode) {
41 if (node->opcode() == IrOpcode::kInt32Constant)
42 value = OpParameter<int32_t>(node);
43 else if (node->opcode() == IrOpcode::kInt64Constant)
44 value = OpParameter<int64_t>(node);
74 void VisitRR(InstructionSelector* selector, ArchOpcode opcode, Node* node) {
76 selector->Emit(opcode, g.DefineAsRegister(node),
77 g.UseRegister(node->InputAt(0)));
81 void VisitRRR(InstructionSelector* selector, ArchOpcode opcode, Node* node) {
83 selector->Emit(opcode, g.DefineAsRegister(node),
84 g.UseRegister(node->InputAt(0)),
85 g.UseRegister(node->InputAt(1)));
89 void VisitRRO(InstructionSelector* selector, ArchOpcode opcode, Node* node,
92 selector->Emit(opcode, g.DefineAsRegister(node),
93 g.UseRegister(node->InputAt(0)),
94 g.UseOperand(node->InputAt(1), operand_mode));
100 Node* node) {
102 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
105 outputs[output_count++] = g.DefineAsRegister(node);
107 Node* success_output = NodeProperties::FindProjection(node, 1);
119 void VisitBinop(InstructionSelector* selector, Node* node,
123 Matcher m(node);
129 inputs[input_count++] = g.UseRegister(m.left().node());
130 inputs[input_count++] = g.UseOperand(m.right().node(), operand_mode);
137 outputs[output_count++] = g.DefineAsRegister(node);
154 void VisitBinop(InstructionSelector* selector, Node* node, ArchOpcode opcode,
157 VisitBinop<Matcher>(selector, node, opcode, operand_mode, &cont);
163 void InstructionSelector::VisitLoad(Node* node) {
164 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
166 Node* base = node->InputAt(0);
167 Node* offset = node->InputAt(1);
209 g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(offset));
212 g.DefineAsRegister(node), g.UseRegister(offset), g.UseImmediate(base));
215 g.DefineAsRegister(node), g.UseRegister(base), g.UseRegister(offset));
220 void InstructionSelector::VisitStore(Node* node) {
222 Node* base = node->InputAt(0);
223 Node* offset = node->InputAt(1);
224 Node* value = node->InputAt(2);
226 StoreRepresentation store_rep = StoreRepresentationOf(node->op());
310 void InstructionSelector::VisitCheckedLoad(Node* node) {
311 CheckedLoadRepresentation load_rep = CheckedLoadRepresentationOf(node->op());
313 Node* const base = node->InputAt(0);
314 Node* const offset = node->InputAt(1);
315 Node* const length = node->InputAt(2);
349 g.DefineAsRegister(node), g.UseRegister(base), g.UseRegister(offset),
354 void InstructionSelector::VisitCheckedStore(Node* node) {
355 MachineRepresentation rep = CheckedStoreRepresentationOf(node->op());
357 Node* const base = node->InputAt(0);
358 Node* const offset = node->InputAt(1);
359 Node* const length = node->InputAt(2);
360 Node* const value = node->InputAt(3);
400 static void VisitLogical(InstructionSelector* selector, Node* node, Matcher* m,
420 Matcher mleft(m->left().node());
422 selector->Emit(inv_opcode, g.DefineAsRegister(node),
423 g.UseRegister(m->right().node()),
424 g.UseRegister(mleft.left().node()));
432 Matcher mright(m->right().node());
435 selector->Emit(inv_opcode, g.DefineAsRegister(node),
436 g.UseRegister(m->left().node()),
437 g.UseRegister(mright.left().node()));
442 VisitBinop<Matcher>(selector, node, opcode, imm_mode);
473 void InstructionSelector::VisitWord32And(Node* node) {
475 Int32BinopMatcher m(node);
480 Node* left = m.left().node();
482 CanCover(node, left)) {
484 Int32BinopMatcher mleft(m.left().node());
486 left = mleft.left().node();
499 Emit(kPPC_RotLeftAndMask32, g.DefineAsRegister(node), g.UseRegister(left),
505 this, node, &m, kPPC_And, CanCover(node, m.left().node()),
506 CanCover(node, m.right().node()), kInt16Imm_Unsigned);
512 void InstructionSelector::VisitWord64And(Node* node) {
514 Int64BinopMatcher m(node);
519 Node* left = m.left().node();
521 CanCover(node, left)) {
523 Int64BinopMatcher mleft(m.left().node());
525 left = mleft.left().node();
555 Emit(opcode, g.DefineAsRegister(node), g.UseRegister(left),
562 this, node, &m, kPPC_And, CanCover(node, m.left().node()),
563 CanCover(node, m.right().node()), kInt16Imm_Unsigned);
568 void InstructionSelector::VisitWord32Or(Node* node) {
569 Int32BinopMatcher m(node);
571 this, node, &m, kPPC_Or, CanCover(node, m.left().node()),
572 CanCover(node, m.right().node()), kInt16Imm_Unsigned);
577 void InstructionSelector::VisitWord64Or(Node* node) {
578 Int64BinopMatcher m(node);
580 this, node, &m, kPPC_Or, CanCover(node, m.left().node()),
581 CanCover(node, m.right().node()), kInt16Imm_Unsigned);
586 void InstructionSelector::VisitWord32Xor(Node* node) {
588 Int32BinopMatcher m(node);
590 Emit(kPPC_Not, g.DefineAsRegister(node), g.UseRegister(m.left().node()));
592 VisitBinop<Int32BinopMatcher>(this, node, kPPC_Xor, kInt16Imm_Unsigned);
598 void InstructionSelector::VisitWord64Xor(Node* node) {
600 Int64BinopMatcher m(node);
602 Emit(kPPC_Not, g.DefineAsRegister(node), g.UseRegister(m.left().node()));
604 VisitBinop<Int64BinopMatcher>(this, node, kPPC_Xor, kInt16Imm_Unsigned);
610 void InstructionSelector::VisitWord32Shl(Node* node) {
612 Int32BinopMatcher m(node);
615 Int32BinopMatcher mleft(m.left().node());
624 Emit(kPPC_RotLeftAndMask32, g.DefineAsRegister(node),
625 g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
631 VisitRRO(this, kPPC_ShiftLeft32, node, kShift32Imm);
636 void InstructionSelector::VisitWord64Shl(Node* node) {
638 Int64BinopMatcher m(node);
642 Int64BinopMatcher mleft(m.left().node());
668 Emit(opcode, g.DefineAsRegister(node),
669 g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
676 VisitRRO(this, kPPC_ShiftLeft64, node, kShift64Imm);
681 void InstructionSelector::VisitWord32Shr(Node* node) {
683 Int32BinopMatcher m(node);
686 Int32BinopMatcher mleft(m.left().node());
696 Emit(kPPC_RotLeftAndMask32, g.DefineAsRegister(node),
697 g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
703 VisitRRO(this, kPPC_ShiftRight32, node, kShift32Imm);
708 void InstructionSelector::VisitWord64Shr(Node* node) {
710 Int64BinopMatcher m(node);
713 Int64BinopMatcher mleft(m.left().node());
736 Emit(opcode, g.DefineAsRegister(node),
737 g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
744 VisitRRO(this, kPPC_ShiftRight64, node, kShift64Imm);
749 void InstructionSelector::VisitWord32Sar(Node* node) {
751 Int32BinopMatcher m(node);
753 if (CanCover(node, m.left().node()) && m.left().IsWord32Shl()) {
754 Int32BinopMatcher mleft(m.left().node());
756 Emit(kPPC_ExtendSignWord16, g.DefineAsRegister(node),
757 g.UseRegister(mleft.left().node()));
760 Emit(kPPC_ExtendSignWord8, g.DefineAsRegister(node),
761 g.UseRegister(mleft.left().node()));
765 VisitRRO(this, kPPC_ShiftRightAlg32, node, kShift32Imm);
770 void InstructionSelector::VisitWord64Sar(Node* node) {
771 VisitRRO(this, kPPC_ShiftRightAlg64, node, kShift64Imm);
777 void InstructionSelector::VisitWord32Ror(Node* node) {
778 VisitRRO(this, kPPC_RotRight32, node, kShift32Imm);
784 void InstructionSelector::VisitWord64Ror(Node* node) {
785 VisitRRO(this, kPPC_RotRight64, node, kShift64Imm);
790 void InstructionSelector::VisitWord32Clz(Node* node) {
792 Emit(kPPC_Cntlz32, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
797 void InstructionSelector::VisitWord64Clz(Node* node) {
799 Emit(kPPC_Cntlz64, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
804 void InstructionSelector::VisitWord32Popcnt(Node* node) {
806 Emit(kPPC_Popcnt32, g.DefineAsRegister(node),
807 g.UseRegister(node->InputAt(0)));
812 void InstructionSelector::VisitWord64Popcnt(Node* node) {
814 Emit(kPPC_Popcnt64, g.DefineAsRegister(node),
815 g.UseRegister(node->InputAt(0)));
820 void InstructionSelector::VisitWord32Ctz(Node* node) { UNREACHABLE(); }
824 void InstructionSelector::VisitWord64Ctz(Node* node) { UNREACHABLE(); }
828 void InstructionSelector::VisitInt32Add(Node* node) {
829 VisitBinop<Int32BinopMatcher>(this, node, kPPC_Add, kInt16Imm);
834 void InstructionSelector::VisitInt64Add(Node* node) {
835 VisitBinop<Int64BinopMatcher>(this, node, kPPC_Add, kInt16Imm);
840 void InstructionSelector::VisitInt32Sub(Node* node) {
842 Int32BinopMatcher m(node);
844 Emit(kPPC_Neg, g.DefineAsRegister(node), g.UseRegister(m.right().node()));
846 VisitBinop<Int32BinopMatcher>(this, node, kPPC_Sub, kInt16Imm_Negate);
852 void InstructionSelector::VisitInt64Sub(Node* node) {
854 Int64BinopMatcher m(node);
856 Emit(kPPC_Neg, g.DefineAsRegister(node), g.UseRegister(m.right().node()));
858 VisitBinop<Int64BinopMatcher>(this, node, kPPC_Sub, kInt16Imm_Negate);
864 void InstructionSelector::VisitInt32Mul(Node* node) {
865 VisitRRR(this, kPPC_Mul32, node);
870 void InstructionSelector::VisitInt64Mul(Node* node) {
871 VisitRRR(this, kPPC_Mul64, node);
876 void InstructionSelector::VisitInt32MulHigh(Node* node) {
878 Emit(kPPC_MulHigh32, g.DefineAsRegister(node),
879 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
883 void InstructionSelector::VisitUint32MulHigh(Node* node) {
885 Emit(kPPC_MulHighU32, g.DefineAsRegister(node),
886 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
890 void InstructionSelector::VisitInt32Div(Node* node) {
891 VisitRRR(this, kPPC_Div32, node);
896 void InstructionSelector::VisitInt64Div(Node* node) {
897 VisitRRR(this, kPPC_Div64, node);
902 void InstructionSelector::VisitUint32Div(Node* node) {
903 VisitRRR(this, kPPC_DivU32, node);
908 void InstructionSelector::VisitUint64Div(Node* node) {
909 VisitRRR(this, kPPC_DivU64, node);
914 void InstructionSelector::VisitInt32Mod(Node* node) {
915 VisitRRR(this, kPPC_Mod32, node);
920 void InstructionSelector::VisitInt64Mod(Node* node) {
921 VisitRRR(this, kPPC_Mod64, node);
926 void InstructionSelector::VisitUint32Mod(Node* node) {
927 VisitRRR(this, kPPC_ModU32, node);
932 void InstructionSelector::VisitUint64Mod(Node* node) {
933 VisitRRR(this, kPPC_ModU64, node);
938 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
939 VisitRR(this, kPPC_Float32ToDouble, node);
943 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) {
944 VisitRR(this, kPPC_Int32ToDouble, node);
948 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
949 VisitRR(this, kPPC_Uint32ToDouble, node);
953 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) {
954 VisitRR(this, kPPC_DoubleToInt32, node);
958 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) {
959 VisitRR(this, kPPC_DoubleToUint32, node);
964 void InstructionSelector::VisitTryTruncateFloat32ToInt64(Node* node) {
965 VisitTryTruncateDouble(this, kPPC_DoubleToInt64, node);
969 void InstructionSelector::VisitTryTruncateFloat64ToInt64(Node* node) {
970 VisitTryTruncateDouble(this, kPPC_DoubleToInt64, node);
974 void InstructionSelector::VisitTryTruncateFloat32ToUint64(Node* node) {
975 VisitTryTruncateDouble(this, kPPC_DoubleToUint64, node);
979 void InstructionSelector::VisitTryTruncateFloat64ToUint64(Node* node) {
980 VisitTryTruncateDouble(this, kPPC_DoubleToUint64, node);
984 void InstructionSelector::VisitChangeInt32ToInt64(Node* node) {
986 VisitRR(this, kPPC_ExtendSignWord32, node);
990 void InstructionSelector::VisitChangeUint32ToUint64(Node* node) {
992 VisitRR(this, kPPC_Uint32ToUint64, node);
997 void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
998 VisitRR(this, kPPC_DoubleToFloat32, node);
1002 void InstructionSelector::VisitTruncateFloat64ToInt32(Node* node) {
1003 switch (TruncationModeOf(node->op())) {
1005 return VisitRR(this, kArchTruncateDoubleToI, node);
1007 return VisitRR(this, kPPC_DoubleToInt32, node);
1014 void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) {
1016 VisitRR(this, kPPC_Int64ToInt32, node);
1020 void InstructionSelector::VisitRoundInt64ToFloat32(Node* node) {
1021 VisitRR(this, kPPC_Int64ToFloat32, node);
1025 void InstructionSelector::VisitRoundInt64ToFloat64(Node* node) {
1026 VisitRR(this, kPPC_Int64ToDouble, node);
1030 void InstructionSelector::VisitRoundUint64ToFloat32(Node* node) {
1031 VisitRR(this, kPPC_Uint64ToFloat32, node);
1035 void InstructionSelector::VisitRoundUint64ToFloat64(Node* node) {
1036 VisitRR(this, kPPC_Uint64ToDouble, node);
1041 void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) {
1042 VisitRR(this, kPPC_BitcastFloat32ToInt32, node);
1047 void InstructionSelector::VisitBitcastFloat64ToInt64(Node* node) {
1048 VisitRR(this, kPPC_BitcastDoubleToInt64, node);
1053 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) {
1054 VisitRR(this, kPPC_BitcastInt32ToFloat32, node);
1059 void InstructionSelector::VisitBitcastInt64ToFloat64(Node* node) {
1060 VisitRR(this, kPPC_BitcastInt64ToDouble, node);
1065 void InstructionSelector::VisitFloat32Add(Node* node) {
1066 VisitRRR(this, kPPC_AddDouble, node);
1070 void InstructionSelector::VisitFloat64Add(Node* node) {
1072 VisitRRR(this, kPPC_AddDouble, node);
1076 void InstructionSelector::VisitFloat32Sub(Node* node) {
1078 Float32BinopMatcher m(node);
1080 Emit(kPPC_NegDouble, g.DefineAsRegister(node),
1081 g.UseRegister(m.right().node()));
1084 VisitRRR(this, kPPC_SubDouble, node);
1088 void InstructionSelector::VisitFloat64Sub(Node* node) {
1091 Float64BinopMatcher m(node);
1094 CanCover(m.node(), m.right().node())) {
1096 CanCover(m.right().node(), m.right().InputAt(0))) {
1100 Emit(kPPC_CeilDouble, g.DefineAsRegister(node),
1101 g.UseRegister(mright0.right().node()));
1106 Emit(kPPC_NegDouble, g.DefineAsRegister(node),
1107 g.UseRegister(m.right().node()));
1110 VisitRRR(this, kPPC_SubDouble, node);
1114 void InstructionSelector::VisitFloat32Mul(Node* node) {
1115 VisitRRR(this, kPPC_MulDouble, node);
1119 void InstructionSelector::VisitFloat64Mul(Node* node) {
1121 VisitRRR(this, kPPC_MulDouble, node);
1125 void InstructionSelector::VisitFloat32Div(Node* node) {
1126 VisitRRR(this, kPPC_DivDouble, node);
1130 void InstructionSelector::VisitFloat64Div(Node* node) {
1131 VisitRRR(this, kPPC_DivDouble, node);
1135 void InstructionSelector::VisitFloat64Mod(Node* node) {
1137 Emit(kPPC_ModDouble, g.DefineAsFixed(node, d1),
1138 g.UseFixed(node->InputAt(0), d1),
1139 g.UseFixed(node->InputAt(1), d2))->MarkAsCall();
1143 void InstructionSelector::VisitFloat32Max(Node* node) { UNREACHABLE(); }
1146 void InstructionSelector::VisitFloat64Max(Node* node) { UNREACHABLE(); }
1149 void InstructionSelector::VisitFloat32Min(Node* node) { UNREACHABLE(); }
1152 void InstructionSelector::VisitFloat64Min(Node* node) { UNREACHABLE(); }
1155 void InstructionSelector::VisitFloat32Abs(Node* node) {
1156 VisitRR(this, kPPC_AbsDouble, node);
1160 void InstructionSelector::VisitFloat64Abs(Node* node) {
1161 VisitRR(this, kPPC_AbsDouble, node);
1165 void InstructionSelector::VisitFloat32Sqrt(Node* node) {
1166 VisitRR(this, kPPC_SqrtDouble, node);
1170 void InstructionSelector::VisitFloat64Sqrt(Node* node) {
1171 VisitRR(this, kPPC_SqrtDouble, node);
1175 void InstructionSelector::VisitFloat32RoundDown(Node* node) {
1176 VisitRR(this, kPPC_FloorDouble, node);
1180 void InstructionSelector::VisitFloat64RoundDown(Node* node) {
1181 VisitRR(this, kPPC_FloorDouble, node);
1185 void InstructionSelector::VisitFloat32RoundUp(Node* node) {
1186 VisitRR(this, kPPC_CeilDouble, node);
1190 void InstructionSelector::VisitFloat64RoundUp(Node* node) {
1191 VisitRR(this, kPPC_CeilDouble, node);
1195 void InstructionSelector::VisitFloat32RoundTruncate(Node* node) {
1196 VisitRR(this, kPPC_TruncateDouble, node);
1200 void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
1201 VisitRR(this, kPPC_TruncateDouble, node);
1205 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
1206 VisitRR(this, kPPC_RoundDouble, node);
1210 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) {
1215 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) {
1220 void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
1221 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1223 return VisitBinop<Int32BinopMatcher>(this, node, kPPC_AddWithOverflow32,
1227 VisitBinop<Int32BinopMatcher>(this, node, kPPC_AddWithOverflow32, kInt16Imm,
1232 void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
1233 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1235 return VisitBinop<Int32BinopMatcher>(this, node, kPPC_SubWithOverflow32,
1239 VisitBinop<Int32BinopMatcher>(this, node, kPPC_SubWithOverflow32,
1245 void InstructionSelector::VisitInt64AddWithOverflow(Node* node) {
1246 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1248 return VisitBinop<Int64BinopMatcher>(this, node, kPPC_Add, kInt16Imm,
1252 VisitBinop<Int64BinopMatcher>(this, node, kPPC_Add, kInt16Imm, &cont);
1256 void InstructionSelector::VisitInt64SubWithOverflow(Node* node) {
1257 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1259 return VisitBinop<Int64BinopMatcher>(this, node, kPPC_Sub, kInt16Imm_Negate,
1263 VisitBinop<Int64BinopMatcher>(this, node, kPPC_Sub, kInt16Imm_Negate, &cont);
1302 void VisitWordCompare(InstructionSelector* selector, Node* node,
1306 Node* left = node->InputAt(0);
1307 Node* right = node->InputAt(1);
1324 void VisitWord32Compare(InstructionSelector* selector, Node* node,
1327 VisitWordCompare(selector, node, kPPC_Cmp32, cont, false, mode);
1332 void VisitWord64Compare(InstructionSelector* selector, Node* node,
1335 VisitWordCompare(selector, node, kPPC_Cmp64, cont, false, mode);
1341 void VisitFloat32Compare(InstructionSelector* selector, Node* node,
1344 Node* left = node->InputAt(0);
1345 Node* right = node->InputAt(1);
1352 void VisitFloat64Compare(InstructionSelector* selector, Node* node,
1355 Node* left = node->InputAt(0);
1356 Node* right = node->InputAt(1);
1363 void VisitWordCompareZero(InstructionSelector* selector, Node* user,
1364 Node* value, InstructionCode opcode,
1374 value = m.left().node();
1430 // <Operation>WithOverflow node.
1437 Node* const node = value->InputAt(0);
1438 Node* const result = NodeProperties::FindProjection(node, 0);
1440 switch (node->opcode()) {
1444 selector, node, kPPC_AddWithOverflow32, kInt16Imm, cont);
1447 return VisitBinop<Int32BinopMatcher>(selector, node,
1453 return VisitBinop<Int64BinopMatcher>(selector, node, kPPC_Add,
1457 return VisitBinop<Int64BinopMatcher>(selector, node, kPPC_Sub,
1509 void VisitWord32CompareZero(InstructionSelector* selector, Node* user,
1510 Node* value, FlagsContinuation* cont) {
1516 void VisitWord64CompareZero(InstructionSelector* selector, Node* user,
1517 Node* value, FlagsContinuation* cont) {
1525 void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
1532 void InstructionSelector::VisitSwitch(Node* node, const SwitchInfo& sw) {
1534 InstructionOperand value_operand = g.UseRegister(node->InputAt(0));
1560 void InstructionSelector::VisitWord32Equal(Node* const node) {
1561 FlagsContinuation cont(kEqual, node);
1562 Int32BinopMatcher m(node);
1564 return VisitWord32CompareZero(this, m.node(), m.left().node(), &cont);
1566 VisitWord32Compare(this, node, &cont);
1570 Node* node) {
1571 FlagsContinuation cont(kSignedLessThan, node);
1572 VisitWord32Compare(this, node, &cont);
1576 void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
1577 FlagsContinuation cont(kSignedLessThanOrEqual, node);
1578 VisitWord32Compare(this, node, &cont);
1582 void InstructionSelector::VisitUint32LessThan(Node* node) {
1583 FlagsContinuation cont(kUnsignedLessThan, node);
1584 VisitWord32Compare(this, node, &cont);
1588 void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
1589 FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
1590 VisitWord32Compare(this, node, &cont);
1595 void InstructionSelector::VisitWord64Equal(Node* const node) {
1596 FlagsContinuation cont(kEqual, node);
1597 Int64BinopMatcher m(node);
1599 return VisitWord64CompareZero(this, m.node(), m.left().node(), &cont);
1601 VisitWord64Compare(this, node, &cont);
1605 void InstructionSelector::VisitInt64LessThan(Node* node) {
1606 FlagsContinuation cont(kSignedLessThan, node);
1607 VisitWord64Compare(this, node, &cont);
1611 void InstructionSelector::VisitInt64LessThanOrEqual(Node* node) {
1612 FlagsContinuation cont(kSignedLessThanOrEqual, node);
1613 VisitWord64Compare(this, node, &cont);
1617 void InstructionSelector::VisitUint64LessThan(Node* node) {
1618 FlagsContinuation cont(kUnsignedLessThan, node);
1619 VisitWord64Compare(this, node, &cont);
1623 void InstructionSelector::VisitUint64LessThanOrEqual(Node* node) {
1624 FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
1625 VisitWord64Compare(this, node, &cont);
1630 void InstructionSelector::VisitFloat32Equal(Node* node) {
1631 FlagsContinuation cont(kEqual, node);
1632 VisitFloat32Compare(this, node, &cont);
1636 void InstructionSelector::VisitFloat32LessThan(Node* node) {
1637 FlagsContinuation cont(kUnsignedLessThan, node);
1638 VisitFloat32Compare(this, node, &cont);
1642 void InstructionSelector::VisitFloat32LessThanOrEqual(Node* node) {
1643 FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
1644 VisitFloat32Compare(this, node, &cont);
1648 void InstructionSelector::VisitFloat64Equal(Node* node) {
1649 FlagsContinuation cont(kEqual, node);
1650 VisitFloat64Compare(this, node, &cont);
1654 void InstructionSelector::VisitFloat64LessThan(Node* node) {
1655 FlagsContinuation cont(kUnsignedLessThan, node);
1656 VisitFloat64Compare(this, node, &cont);
1660 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
1661 FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
1662 VisitFloat64Compare(this, node, &cont);
1668 Node* node) {
1680 Emit(kPPC_StoreToStackSlot, g.NoOutput(), g.UseRegister(input.node()),
1690 DCHECK(input.node());
1691 Emit(kPPC_PushFrame, g.NoOutput(), g.UseRegister(input.node()),
1695 if (input.node()) {
1696 Emit(kPPC_StoreToStackSlot, g.NoOutput(), g.UseRegister(input.node()),
1709 void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) {
1711 Emit(kPPC_DoubleExtractLowWord32, g.DefineAsRegister(node),
1712 g.UseRegister(node->InputAt(0)));
1716 void InstructionSelector::VisitFloat64ExtractHighWord32(Node* node) {
1718 Emit(kPPC_DoubleExtractHighWord32, g.DefineAsRegister(node),
1719 g.UseRegister(node->InputAt(0)));
1723 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) {
1725 Node* left = node->InputAt(0);
1726 Node* right = node->InputAt(1);
1728 CanCover(node, left)) {
1730 Emit(kPPC_DoubleConstruct, g.DefineAsRegister(node), g.UseRegister(left),
1734 Emit(kPPC_DoubleInsertLowWord32, g.DefineSameAsFirst(node),
1739 void InstructionSelector::VisitFloat64InsertHighWord32(Node* node) {
1741 Node* left = node->InputAt(0);
1742 Node* right = node->InputAt(1);
1744 CanCover(node, left)) {
1746 Emit(kPPC_DoubleConstruct, g.DefineAsRegister(node), g.UseRegister(right),
1750 Emit(kPPC_DoubleInsertHighWord32, g.DefineSameAsFirst(node),
