Lines Matching refs:node
7 #include "src/compiler/node-matchers.h"
8 #include "src/compiler/node-properties.h"
31 InstructionOperand UseOperand(Node* node, ImmediateMode mode) {
32 if (CanBeImmediate(node, mode)) {
33 return UseImmediate(node);
35 return UseRegister(node);
38 bool CanBeImmediate(Node* node, ImmediateMode mode) {
40 if (node->opcode() == IrOpcode::kInt32Constant)
41 value = OpParameter<int32_t>(node);
42 else if (node->opcode() == IrOpcode::kInt64Constant)
43 value = OpParameter<int64_t>(node);
72 void VisitRR(InstructionSelector* selector, ArchOpcode opcode, Node* node) {
74 selector->Emit(opcode, g.DefineAsRegister(node),
75 g.UseRegister(node->InputAt(0)));
78 void VisitRRR(InstructionSelector* selector, ArchOpcode opcode, Node* node) {
80 selector->Emit(opcode, g.DefineAsRegister(node),
81 g.UseRegister(node->InputAt(0)),
82 g.UseRegister(node->InputAt(1)));
85 void VisitRRO(InstructionSelector* selector, ArchOpcode opcode, Node* node,
88 selector->Emit(opcode, g.DefineAsRegister(node),
89 g.UseRegister(node->InputAt(0)),
90 g.UseOperand(node->InputAt(1), operand_mode));
95 Node* node) {
97 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
100 outputs[output_count++] = g.DefineAsRegister(node);
102 Node* success_output = NodeProperties::FindProjection(node, 1);
113 void VisitBinop(InstructionSelector* selector, Node* node,
117 Matcher m(node);
123 inputs[input_count++] = g.UseRegister(m.left().node());
124 inputs[input_count++] = g.UseOperand(m.right().node(), operand_mode);
131 outputs[output_count++] = g.DefineAsRegister(node);
152 void VisitBinop(InstructionSelector* selector, Node* node, ArchOpcode opcode,
155 VisitBinop<Matcher>(selector, node, opcode, operand_mode, &cont);
160 void InstructionSelector::VisitLoad(Node* node) {
161 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
163 Node* base = node->InputAt(0);
164 Node* offset = node->InputAt(1);
203 g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(offset));
206 g.DefineAsRegister(node), g.UseRegister(offset), g.UseImmediate(base));
209 g.DefineAsRegister(node), g.UseRegister(base), g.UseRegister(offset));
213 void InstructionSelector::VisitStore(Node* node) {
215 Node* base = node->InputAt(0);
216 Node* offset = node->InputAt(1);
217 Node* value = node->InputAt(2);
219 StoreRepresentation store_rep = StoreRepresentationOf(node->op());
314 void InstructionSelector::VisitCheckedLoad(Node* node) {
315 CheckedLoadRepresentation load_rep = CheckedLoadRepresentationOf(node->op());
317 Node* const base = node->InputAt(0);
318 Node* const offset = node->InputAt(1);
319 Node* const length = node->InputAt(2);
354 g.DefineAsRegister(node), g.UseRegister(base), g.UseRegister(offset),
358 void InstructionSelector::VisitCheckedStore(Node* node) {
359 MachineRepresentation rep = CheckedStoreRepresentationOf(node->op());
361 Node* const base = node->InputAt(0);
362 Node* const offset = node->InputAt(1);
363 Node* const length = node->InputAt(2);
364 Node* const value = node->InputAt(3);
404 static void VisitLogical(InstructionSelector* selector, Node* node, Matcher* m,
424 Matcher mleft(m->left().node());
426 selector->Emit(inv_opcode, g.DefineAsRegister(node),
427 g.UseRegister(m->right().node()),
428 g.UseRegister(mleft.left().node()));
436 Matcher mright(m->right().node());
439 selector->Emit(inv_opcode, g.DefineAsRegister(node),
440 g.UseRegister(m->left().node()),
441 g.UseRegister(mright.left().node()));
446 VisitBinop<Matcher>(selector, node, opcode, imm_mode);
473 void InstructionSelector::VisitWord32And(Node* node) {
475 Int32BinopMatcher m(node);
480 Nodenode();
482 CanCover(node, left)) {
483 Int32BinopMatcher mleft(m.left().node());
485 left = mleft.left().node();
498 Emit(kS390_RotLeftAndMask32, g.DefineAsRegister(node),
505 this, node, &m, kS390_And, CanCover(node, m.left().node()),
506 CanCover(node, m.right().node()), kInt16Imm_Unsigned);
510 void InstructionSelector::VisitWord64And(Node* node) {
512 Int64BinopMatcher m(node);
517 Node* left = m.left().node();
519 CanCover(node, left)) {
520 Int64BinopMatcher mleft(m.left().node());
522 left = mleft.left().node();
552 Emit(opcode, g.DefineAsRegister(node), g.UseRegister(left),
559 this, node, &m, kS390_And, CanCover(node, m.left().node()),
560 CanCover(node, m.right().node()), kInt16Imm_Unsigned);
564 void InstructionSelector::VisitWord32Or(Node* node) {
565 Int32BinopMatcher m(node);
567 this, node, &m, kS390_Or, CanCover(node, m.left().node()),
568 CanCover(node, m.right().node()), kInt16Imm_Unsigned);
572 void InstructionSelector::VisitWord64Or(Node* node) {
573 Int64BinopMatcher m(node);
575 this, node, &m, kS390_Or, CanCover(node, m.left().node()),
576 CanCover(node, m.right().node()), kInt16Imm_Unsigned);
580 void InstructionSelector::VisitWord32Xor(Node* node) {
582 Int32BinopMatcher m(node);
584 Emit(kS390_Not, g.DefineAsRegister(node), g.UseRegister(m.left().node()));
586 VisitBinop<Int32BinopMatcher>(this, node, kS390_Xor, kInt16Imm_Unsigned);
591 void InstructionSelector::VisitWord64Xor(Node* node) {
593 Int64BinopMatcher m(node);
595 Emit(kS390_Not, g.DefineAsRegister(node), g.UseRegister(m.left().node()));
597 VisitBinop<Int64BinopMatcher>(this, node, kS390_Xor, kInt16Imm_Unsigned);
602 void InstructionSelector::VisitWord32Shl(Node* node) {
604 Int32BinopMatcher m(node);
606 Int32BinopMatcher mleft(m.left().node());
615 Emit(kS390_RotLeftAndMask32, g.DefineAsRegister(node),
616 g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
622 VisitRRO(this, kS390_ShiftLeft32, node, kShift32Imm);
626 void InstructionSelector::VisitWord64Shl(Node* node) {
628 Int64BinopMatcher m(node);
631 Int64BinopMatcher mleft(m.left().node());
657 Emit(opcode, g.DefineAsRegister(node),
658 g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
665 VisitRRO(this, kS390_ShiftLeft64, node, kShift64Imm);
669 void InstructionSelector::VisitWord32Shr(Node* node) {
671 Int32BinopMatcher m(node);
673 Int32BinopMatcher mleft(m.left().node());
683 Emit(kS390_RotLeftAndMask32, g.DefineAsRegister(node),
684 g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
690 VisitRRO(this, kS390_ShiftRight32, node, kShift32Imm);
694 void InstructionSelector::VisitWord64Shr(Node* node) {
696 Int64BinopMatcher m(node);
698 Int64BinopMatcher mleft(m.left().node());
721 Emit(opcode, g.DefineAsRegister(node),
722 g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
729 VisitRRO(this, kS390_ShiftRight64, node, kShift64Imm);
733 void InstructionSelector::VisitWord32Sar(Node* node) {
735 Int32BinopMatcher m(node);
737 if (CanCover(node, m.left().node()) && m.left().IsWord32Shl()) {
738 Int32BinopMatcher mleft(m.left().node());
740 Emit(kS390_ExtendSignWord16, g.DefineAsRegister(node),
741 g.UseRegister(mleft.left().node()));
744 Emit(kS390_ExtendSignWord8, g.DefineAsRegister(node),
745 g.UseRegister(mleft.left().node()));
749 VisitRRO(this, kS390_ShiftRightArith32, node, kShift32Imm);
754 Node* node) {
760 g.UseRegister(node->InputAt(0)), g.UseUniqueRegister(node->InputAt(1)),
761 g.UseRegister(node->InputAt(2)), g.UseUniqueRegister(node->InputAt(3))};
764 g.DefineAsRegister(node),
765 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
770 void InstructionSelector::VisitInt32PairAdd(Node* node) {
771 VisitPairBinop(this, kS390_AddPair, node);
774 void InstructionSelector::VisitInt32PairSub(Node* node) {
775 VisitPairBinop(this, kS390_SubPair, node);
778 void InstructionSelector::VisitInt32PairMul(Node* node) {
780 InstructionOperand inputs[] = {g.UseUniqueRegister(node->InputAt(0)),
781 g.UseUniqueRegister(node->InputAt(1)),
782 g.UseUniqueRegister(node->InputAt(2)),
783 g.UseUniqueRegister(node->InputAt(3))};
786 g.DefineAsRegister(node),
787 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
793 Node* node) {
795 Int32Matcher m(node->InputAt(2));
798 shift_operand = g.UseImmediate(m.node());
800 shift_operand = g.UseUniqueRegister(m.node());
803 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0)),
804 g.UseRegister(node->InputAt(1)),
808 g.DefineSameAsFirst(node),
809 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
814 void InstructionSelector::VisitWord32PairShl(Node* node) {
815 VisitPairShift(this, kS390_ShiftLeftPair, node);
818 void InstructionSelector::VisitWord32PairShr(Node* node) {
819 VisitPairShift(this, kS390_ShiftRightPair, node);
822 void InstructionSelector::VisitWord32PairSar(Node* node) {
823 VisitPairShift(this, kS390_ShiftRightArithPair, node);
828 void InstructionSelector::VisitWord64Sar(Node* node) {
829 VisitRRO(this, kS390_ShiftRightArith64, node, kShift64Imm);
833 void InstructionSelector::VisitWord32Ror(Node* node) {
834 VisitRRO(this, kS390_RotRight32, node, kShift32Imm);
838 void InstructionSelector::VisitWord64Ror(Node* node) {
839 VisitRRO(this, kS390_RotRight64, node, kShift64Imm);
843 void InstructionSelector::VisitWord32Clz(Node* node) {
845 Emit(kS390_Cntlz32, g.DefineAsRegister(node),
846 g.UseRegister(node->InputAt(0)));
850 void InstructionSelector::VisitWord64Clz(Node* node) {
852 Emit(kS390_Cntlz64, g.DefineAsRegister(node),
853 g.UseRegister(node->InputAt(0)));
857 void InstructionSelector::VisitWord32Popcnt(Node* node) {
859 Emit(kS390_Popcnt32, g.DefineAsRegister(node),
860 g.UseRegister(node->InputAt(0)));
864 void InstructionSelector::VisitWord64Popcnt(Node* node) {
866 Emit(kS390_Popcnt64, g.DefineAsRegister(node),
867 g.UseRegister(node->InputAt(0)));
871 void InstructionSelector::VisitWord32Ctz(Node* node) { UNREACHABLE(); }
874 void InstructionSelector::VisitWord64Ctz(Node* node) { UNREACHABLE(); }
877 void InstructionSelector::VisitWord32ReverseBits(Node* node) { UNREACHABLE(); }
880 void InstructionSelector::VisitWord64ReverseBits(Node* node) { UNREACHABLE(); }
883 void InstructionSelector::VisitInt32Add(Node* node) {
884 VisitBinop<Int32BinopMatcher>(this, node, kS390_Add, kInt16Imm);
888 void InstructionSelector::VisitInt64Add(Node* node) {
889 VisitBinop<Int64BinopMatcher>(this, node, kS390_Add, kInt16Imm);
893 void InstructionSelector::VisitInt32Sub(Node* node) {
895 Int32BinopMatcher m(node);
897 Emit(kS390_Neg, g.DefineAsRegister(node), g.UseRegister(m.right().node()));
899 VisitBinop<Int32BinopMatcher>(this, node, kS390_Sub, kInt16Imm_Negate);
904 void InstructionSelector::VisitInt64Sub(Node* node) {
906 Int64BinopMatcher m(node);
908 Emit(kS390_Neg, g.DefineAsRegister(node), g.UseRegister(m.right().node()));
910 VisitBinop<Int64BinopMatcher>(this, node, kS390_Sub, kInt16Imm_Negate);
915 void InstructionSelector::VisitInt32Mul(Node* node) {
916 VisitRRR(this, kS390_Mul32, node);
920 void InstructionSelector::VisitInt64Mul(Node* node) {
921 VisitRRR(this, kS390_Mul64, node);
925 void InstructionSelector::VisitInt32MulHigh(Node* node) {
927 Emit(kS390_MulHigh32, g.DefineAsRegister(node),
928 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
931 void InstructionSelector::VisitUint32MulHigh(Node* node) {
933 Emit(kS390_MulHighU32, g.DefineAsRegister(node),
934 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
937 void InstructionSelector::VisitInt32Div(Node* node) {
938 VisitRRR(this, kS390_Div32, node);
942 void InstructionSelector::VisitInt64Div(Node* node) {
943 VisitRRR(this, kS390_Div64, node);
947 void InstructionSelector::VisitUint32Div(Node* node) {
948 VisitRRR(this, kS390_DivU32, node);
952 void InstructionSelector::VisitUint64Div(Node* node) {
953 VisitRRR(this, kS390_DivU64, node);
957 void InstructionSelector::VisitInt32Mod(Node* node) {
958 VisitRRR(this, kS390_Mod32, node);
962 void InstructionSelector::VisitInt64Mod(Node* node) {
963 VisitRRR(this, kS390_Mod64, node);
967 void InstructionSelector::VisitUint32Mod(Node* node) {
968 VisitRRR(this, kS390_ModU32, node);
972 void InstructionSelector::VisitUint64Mod(Node* node) {
973 VisitRRR(this, kS390_ModU64, node);
977 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
978 VisitRR(this, kS390_Float32ToDouble, node);
981 void InstructionSelector::VisitRoundInt32ToFloat32(Node* node) {
982 VisitRR(this, kS390_Int32ToFloat32, node);
985 void InstructionSelector::VisitRoundUint32ToFloat32(Node* node) {
986 VisitRR(this, kS390_Uint32ToFloat32, node);
989 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) {
990 VisitRR(this, kS390_Int32ToDouble, node);
993 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
994 VisitRR(this, kS390_Uint32ToDouble, node);
997 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) {
998 VisitRR(this, kS390_DoubleToInt32, node);
1001 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) {
1002 VisitRR(this, kS390_DoubleToUint32, node);
1005 void InstructionSelector::VisitTruncateFloat64ToUint32(Node* node) {
1006 VisitRR(this, kS390_DoubleToUint32, node);
1010 void InstructionSelector::VisitTryTruncateFloat32ToInt64(Node* node) {
1011 node);
1014 void InstructionSelector::VisitTryTruncateFloat64ToInt64(Node* node) {
1015 VisitTryTruncateDouble(this, kS390_DoubleToInt64, node);
1018 void InstructionSelector::VisitTryTruncateFloat32ToUint64(Node* node) {
1019 VisitTryTruncateDouble(this, kS390_Float32ToUint64, node);
1022 void InstructionSelector::VisitTryTruncateFloat64ToUint64(Node* node) {
1023 VisitTryTruncateDouble(this, kS390_DoubleToUint64, node);
1026 void InstructionSelector::VisitChangeInt32ToInt64(Node* node) {
1028 VisitRR(this, kS390_ExtendSignWord32, node);
1031 void InstructionSelector::VisitChangeUint32ToUint64(Node* node) {
1033 VisitRR(this, kS390_Uint32ToUint64, node);
1037 void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
1038 VisitRR(this, kS390_DoubleToFloat32, node);
1041 void InstructionSelector::VisitTruncateFloat64ToWord32(Node* node) {
1042 VisitRR(this, kArchTruncateDoubleToI, node);
1045 void InstructionSelector::VisitRoundFloat64ToInt32(Node* node) {
1046 VisitRR(this, kS390_DoubleToInt32, node);
1049 void InstructionSelector::VisitTruncateFloat32ToInt32(Node* node) {
1050 VisitRR(this, kS390_Float32ToInt32, node);
1053 void InstructionSelector::VisitTruncateFloat32ToUint32(Node* node) {
1054 VisitRR(this, kS390_Float32ToUint32, node);
1058 void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) {
1060 VisitRR(this, kS390_Int64ToInt32, node);
1063 void InstructionSelector::VisitRoundInt64ToFloat32(Node* node) {
1064 VisitRR(this, kS390_Int64ToFloat32, node);
1067 void InstructionSelector::VisitRoundInt64ToFloat64(Node* node) {
1068 VisitRR(this, kS390_Int64ToDouble, node);
1071 void InstructionSelector::VisitRoundUint64ToFloat32(Node* node) {
1072 VisitRR(this, kS390_Uint64ToFloat32, node);
1075 void InstructionSelector::VisitRoundUint64ToFloat64(Node* node) {
1076 VisitRR(this, kS390_Uint64ToDouble, node);
1080 void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) {
1081 VisitRR(this, kS390_BitcastFloat32ToInt32, node);
1085 void InstructionSelector::VisitBitcastFloat64ToInt64(Node* node) {
1086 VisitRR(this, kS390_BitcastDoubleToInt64, node);
1090 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) {
1091 VisitRR(this, kS390_BitcastInt32ToFloat32, node);
1095 void InstructionSelector::VisitBitcastInt64ToFloat64(Node* node) {
1096 VisitRR(this, kS390_BitcastInt64ToDouble, node);
1100 void InstructionSelector::VisitFloat32Add(Node* node) {
1101 VisitRRR(this, kS390_AddFloat, node);
1104 void InstructionSelector::VisitFloat64Add(Node* node) {
1106 VisitRRR(this, kS390_AddDouble, node);
1109 void InstructionSelector::VisitFloat32Sub(Node* node) {
1111 Float32BinopMatcher m(node);
1113 Emit(kS390_NegDouble, g.DefineAsRegister(node),
1114 g.UseRegister(m.right().node()));
1117 VisitRRR(this, kS390_SubFloat, node);
1120 void InstructionSelector::VisitFloat32SubPreserveNan(Node* node) {
1122 VisitRRR(this, kS390_SubFloat, node);
1125 void InstructionSelector::VisitFloat64Sub(Node* node) {
1128 Float64BinopMatcher m(node);
1131 CanCover(m.node(), m.right().node())) {
1133 CanCover(m.right().node(), m.right().InputAt(0))) {
1137 Emit(kS390_CeilDouble, g.DefineAsRegister(node),
1138 g.UseRegister(mright0.right().node()));
1143 Emit(kS390_NegDouble, g.DefineAsRegister(node),
1144 g.UseRegister(m.right().node()));
1147 VisitRRR(this, kS390_SubDouble, node);
1150 void InstructionSelector::VisitFloat64SubPreserveNan(Node* node) {
1151 VisitRRR(this, kS390_SubDouble, node);
1154 void InstructionSelector::VisitFloat32Mul(Node* node) {
1155 VisitRRR(this, kS390_MulFloat, node);
1158 void InstructionSelector::VisitFloat64Mul(Node* node) {
1160 VisitRRR(this, kS390_MulDouble, node);
1163 void InstructionSelector::VisitFloat32Div(Node* node) {
1164 VisitRRR(this, kS390_DivFloat, node);
1167 void InstructionSelector::VisitFloat64Div(Node* node) {
1168 VisitRRR(this, kS390_DivDouble, node);
1171 void InstructionSelector::VisitFloat64Mod(Node* node) {
1173 Emit(kS390_ModDouble, g.DefineAsFixed(node, d1),
1174 g.UseFixed(node->InputAt(0), d1), g.UseFixed(node->InputAt(1), d2))
1178 void InstructionSelector::VisitFloat32Max(Node* node) { UNREACHABLE(); }
1180 void InstructionSelector::VisitFloat64Max(Node* node) { UNREACHABLE(); }
1182 void InstructionSelector::VisitFloat64SilenceNaN(Node* node) {
1183 VisitRR(this, kS390_Float64SilenceNaN, node);
1186 void InstructionSelector::VisitFloat32Min(Node* node) { UNREACHABLE(); }
1188 void InstructionSelector::VisitFloat64Min(Node* node) { UNREACHABLE(); }
1190 void InstructionSelector::VisitFloat32Abs(Node* node) {
1191 VisitRR(this, kS390_AbsFloat, node);
1194 void InstructionSelector::VisitFloat64Abs(Node* node) {
1195 VisitRR(this, kS390_AbsDouble, node);
1198 void InstructionSelector::VisitFloat32Sqrt(Node* node) {
1199 VisitRR(this, kS390_SqrtFloat, node);
1202 void InstructionSelector::VisitFloat64Ieee754Unop(Node* node,
1205 Emit(opcode, g.DefineAsFixed(node, d0), g.UseFixed(node->InputAt(0), d0))
1209 void InstructionSelector::VisitFloat64Ieee754Binop(Node* node,
1212 Emit(opcode, g.DefineAsFixed(node, d0), g.UseFixed(node->InputAt(0), d0),
1213 g.UseFixed(node->InputAt(1), d2))
1217 void InstructionSelector::VisitFloat64Sqrt(Node* node) {
1218 VisitRR(this, kS390_SqrtDouble, node);
1221 void InstructionSelector::VisitFloat32RoundDown(Node* node) {
1222 VisitRR(this, kS390_FloorFloat, node);
1225 void InstructionSelector::VisitFloat64RoundDown(Node* node) {
1226 VisitRR(this, kS390_FloorDouble, node);
1229 void InstructionSelector::VisitFloat32RoundUp(Node* node) {
1230 VisitRR(this, kS390_CeilFloat, node);
1233 void InstructionSelector::VisitFloat64RoundUp(Node* node) {
1234 VisitRR(this, kS390_CeilDouble, node);
1237 void InstructionSelector::VisitFloat32RoundTruncate(Node* node) {
1238 VisitRR(this, kS390_TruncateFloat, node);
1241 void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
1242 VisitRR(this, kS390_TruncateDouble, node);
1245 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
1246 VisitRR(this, kS390_RoundDouble, node);
1249 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) {
1253 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) {
1257 void InstructionSelector::VisitFloat32Neg(Node* node) { UNREACHABLE(); }
1259 void InstructionSelector::VisitFloat64Neg(Node* node) { UNREACHABLE(); }
1261 void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
1262 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1264 return VisitBinop<Int32BinopMatcher>(this, node, kS390_AddWithOverflow32,
1268 VisitBinop<Int32BinopMatcher>(this, node, kS390_AddWithOverflow32, kInt16Imm,
1272 void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
1273 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1275 return VisitBinop<Int32BinopMatcher>(this, node, kS390_SubWithOverflow32,
1279 VisitBinop<Int32BinopMatcher>(this, node, kS390_SubWithOverflow32,
1284 void InstructionSelector::VisitInt64AddWithOverflow(Node* node) {
1285 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1287 return VisitBinop<Int64BinopMatcher>(this, node, kS390_Add, kInt16Imm,
1291 VisitBinop<Int64BinopMatcher>(this, node, kS390_Add, kInt16Imm, &cont);
1294 void InstructionSelector::VisitInt64SubWithOverflow(Node* node) {
1295 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1297 return VisitBinop<Int64BinopMatcher>(this, node, kS390_Sub,
1301 VisitBinop<Int64BinopMatcher>(this, node, kS390_Sub, kInt16Imm_Negate, &cont);
1340 void VisitWordCompare(InstructionSelector* selector, Node* node,
1344 Node* left = node->InputAt(0);
1345 Node* right = node->InputAt(1);
1361 void VisitWord32Compare(InstructionSelector* selector, Node* node,
1364 VisitWordCompare(selector, node, kS390_Cmp32, cont, false, mode);
1368 void VisitWord64Compare(InstructionSelector* selector, Node* node,
1371 VisitWordCompare(selector, node, kS390_Cmp64, cont, false, mode);
1376 void VisitFloat32Compare(InstructionSelector* selector, Node* node,
1379 Node* left = node->InputAt(0);
1380 Node* right = node->InputAt(1);
1386 void VisitFloat64Compare(InstructionSelector* selector, Node* node,
1389 Node* left = node->InputAt(0);
1390 Node* right = node->InputAt(1);
1396 void VisitWordCompareZero(InstructionSelector* selector, Node* user,
1397 Node* value, InstructionCode opcode,
1407 value = m.left().node();
1463 // <Operation>WithOverflow node.
1470 Node* const node = value->InputAt(0);
1471 Nodenode, 0);
1473 switch (node->opcode()) {
1477 selector, node, kS390_AddWithOverflow32, kInt16Imm, cont);
1480 return VisitBinop<Int32BinopMatcher>(selector, node,
1486 return VisitBinop<Int64BinopMatcher>(selector, node, kS390_Add,
1490 return VisitBinop<Int64BinopMatcher>(selector, node, kS390_Sub,
1539 void VisitWord32CompareZero(InstructionSelector* selector, Node* user,
1540 Node* value, FlagsContinuation* cont) {
1545 void VisitWord64CompareZero(InstructionSelector* selector, Node* user,
1546 Node* value, FlagsContinuation* cont) {
1553 void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
1559 void InstructionSelector::VisitDeoptimizeIf(Node* node) {
1561 FlagsContinuation::ForDeoptimize(kNotEqual, node->InputAt(1));
1562 VisitWord32CompareZero(this, node, node->InputAt(0), &cont);
1565 void InstructionSelector::VisitDeoptimizeUnless(Node* node) {
1567 FlagsContinuation::ForDeoptimize(kEqual, node->InputAt(1));
1568 VisitWord32CompareZero(this, node, node->InputAt(0), &cont);
1571 void InstructionSelector::VisitSwitch(Node* node, const SwitchInfo& sw) {
1573 InstructionOperand value_operand = g.UseRegister(node->InputAt(0));
1598 void InstructionSelector::VisitWord32Equal(Node* const node) {
1599 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1600 Int32BinopMatcher m(node);
1602 return VisitWord32CompareZero(this, m.node(), m.left().node(), &cont);
1604 VisitWord32Compare(this, node, &cont);
1607 void InstructionSelector::VisitInt32LessThan(Node* node) {
1608 FlagsContinuation cont = FlagsContinuation::ForSet(kSignedLessThan, node);
1609 VisitWord32Compare(this, node, &cont);
1612 void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
1614 FlagsContinuation::ForSet(kSignedLessThanOrEqual, node);
1615 VisitWord32Compare(this, node, &cont);
1618 void InstructionSelector::VisitUint32LessThan(Node* node) {
1619 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1620 VisitWord32Compare(this, node, &cont);
1623 void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
1625 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1626 VisitWord32Compare(this, node, &cont);
1630 void InstructionSelector::VisitWord64Equal(Node* const node) {
1631 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1632 Int64BinopMatcher m(node);
1634 return VisitWord64CompareZero(this, m.node(), m.left().node(), &cont);
1636 VisitWord64Compare(this, node, &cont);
1639 void InstructionSelector::VisitInt64LessThan(Node* node) {
1640 FlagsContinuation cont = FlagsContinuation::ForSet(kSignedLessThan, node);
1641 VisitWord64Compare(this, node, &cont);
1644 void InstructionSelector::VisitInt64LessThanOrEqual(Node* node) {
1646 FlagsContinuation::ForSet(kSignedLessThanOrEqual, node);
1647 VisitWord64Compare(this, node, &cont);
1650 void InstructionSelector::VisitUint64LessThan(Node* node) {
1651 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1652 VisitWord64Compare(this, node, &cont);
1655 void InstructionSelector::VisitUint64LessThanOrEqual(Node* node) {
1657 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1658 VisitWord64Compare(this, node, &cont);
1662 void InstructionSelector::VisitFloat32Equal(Node* node) {
1663 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1664 VisitFloat32Compare(this, node, &cont);
1667 void InstructionSelector::VisitFloat32LessThan(Node* node) {
1668 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1669 VisitFloat32Compare(this, node, &cont);
1672 void InstructionSelector::VisitFloat32LessThanOrEqual(Node* node) {
1674 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1675 VisitFloat32Compare(this, node, &cont);
1678 void InstructionSelector::VisitFloat64Equal(Node* node) {
1679 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1680 VisitFloat64Compare(this, node, &cont);
1683 void InstructionSelector::VisitFloat64LessThan(Node* node) {
1684 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1685 VisitFloat64Compare(this, node, &cont);
1688 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
1690 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1691 VisitFloat64Compare(this, node, &cont);
1696 Node* node) {
1708 Emit(kS390_StoreToStackSlot, g.NoOutput(), g.UseRegister(input.node()),
1718 DCHECK(input.node());
1719 Emit(kS390_PushFrame, g.NoOutput(), g.UseRegister(input.node()),
1723 if (input.node()) {
1725 g.UseRegister(input.node()), g.TempImmediate(slot));
1737 void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) {
1739 Emit(kS390_DoubleExtractLowWord32, g.DefineAsRegister(node),
1740 g.UseRegister(node->InputAt(0)));
1743 void InstructionSelector::VisitFloat64ExtractHighWord32(Node* node) {
1745 Emit(kS390_DoubleExtractHighWord32, g.DefineAsRegister(node),
1746 g.UseRegister(node->InputAt(0)));
1749 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) {
1751 Node* left = node->InputAt(0);
1752 Node* right = node->InputAt(1);
1754 CanCover(node, left)) {
1756 Emit(kS390_DoubleConstruct, g.DefineAsRegister(node), g.UseRegister(left),
1760 Emit(kS390_DoubleInsertLowWord32, g.DefineSameAsFirst(node),
1764 void InstructionSelector::VisitFloat64InsertHighWord32(Node* node) {
1766 Node* left = node->InputAt(0);
1767 Node* right = node->InputAt(1);
1769 CanCover(node, left)) {
1771 Emit(kS390_DoubleConstruct, g.DefineAsRegister(node), g.UseRegister(right),
1775 Emit(kS390_DoubleInsertHighWord32, g.DefineSameAsFirst(node),
1779 void InstructionSelector::VisitAtomicLoad(Node* node) {
1780 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
1782 Node* base = node->InputAt(0);
1783 Node* index = node->InputAt(1);
1800 g.DefineAsRegister(node), g.UseRegister(base), g.UseRegister(index));
1803 void InstructionSelector::VisitAtomicStore(Node* node) {
1804 MachineRepresentation rep = AtomicStoreRepresentationOf(node->op());
1806 Node* base = node->InputAt(0);
1807 Node* index = node->InputAt(1);
1808 Node* value = node->InputAt(2);
