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);
75 Node* node) {
77 selector->Emit(opcode, g.DefineAsRegister(node),
78 g.UseRegister(node->InputAt(0)));
82 Node* node) {
84 selector->Emit(opcode, g.DefineAsRegister(node),
85 g.UseRegister(node->InputAt(0)),
86 g.UseRegister(node->InputAt(1)));
89 void VisitRRO(InstructionSelector* selector, InstructionCode 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 InstructionCode opcode, 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);
141 outputs[output_count++] = g.DefineSameAsFirst(node);
143 outputs[output_count++] = g.DefineAsRegister(node);
169 void VisitBinop(InstructionSelector* selector, Node* node,
172 VisitBinop<Matcher>(selector, node, opcode, operand_mode, &cont);
178 void InstructionSelector::VisitLoad(Node* node) {
179 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
181 Node* base = node->InputAt(0);
182 Node* offset = node->InputAt(1);
228 g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(offset));
231 g.DefineAsRegister(node), g.UseRegister(offset), g.UseImmediate(base));
234 g.DefineAsRegister(node), g.UseRegister(base), g.UseRegister(offset));
238 void InstructionSelector::VisitProtectedLoad(Node* node) {
243 void InstructionSelector::VisitStore(Node* node) {
245 Node* base = node->InputAt(0);
246 Node* offset = node->InputAt(1);
247 Node* value = node->InputAt(2);
249 StoreRepresentation store_rep = StoreRepresentationOf(node->op());
351 void InstructionSelector::VisitProtectedStore(Node* node) {
357 void InstructionSelector::VisitUnalignedLoad(Node* node) { UNREACHABLE(); }
360 void InstructionSelector::VisitUnalignedStore(Node* node) { UNREACHABLE(); }
362 void InstructionSelector::VisitCheckedLoad(Node* node) {
363 CheckedLoadRepresentation load_rep = CheckedLoadRepresentationOf(node->op());
365 Node* const base = node->InputAt(0);
366 Node* const offset = node->InputAt(1);
367 Node* const length = node->InputAt(2);
407 g.DefineAsRegister(node), g.UseRegister(base), g.UseRegister(offset),
412 void InstructionSelector::VisitCheckedStore(Node* node) {
413 MachineRepresentation rep = CheckedStoreRepresentationOf(node->op());
415 Node* const base = node->InputAt(0);
416 Node* const offset = node->InputAt(1);
417 Node* const length = node->InputAt(2);
418 Node* const value = node->InputAt(3);
464 Node* node, Matcher* m,
484 Matcher mleft(m->left().node());
486 selector->Emit(inv_opcode, g.DefineAsRegister(node),
487 g.UseRegister(m->right().node()),
488 g.UseRegister(mleft.left().node()));
496 Matcher mright(m->right().node());
499 selector->Emit(inv_opcode, g.DefineAsRegister(node),
500 g.UseRegister(m->left().node()),
501 g.UseRegister(mright.left().node()));
506 VisitBinop<Matcher>(selector, node, opcode, imm_mode);
537 void InstructionSelector::VisitWord32And(Node* node) {
539 Int32BinopMatcher m(node);
544 Node* left = m.left().node();
546 CanCover(node, left)) {
548 Int32BinopMatcher mleft(m.left().node());
550 left = mleft.left().node();
563 Emit(kPPC_RotLeftAndMask32, g.DefineAsRegister(node), g.UseRegister(left),
569 this, node, &m, kPPC_And, CanCover(node, m.left().node()),
570 CanCover(node, m.right().node()), kInt16Imm_Unsigned);
576 void InstructionSelector::VisitWord64And(Node* node) {
578 Int64BinopMatcher m(node);
583 Node* left = m.left().node();
585 CanCover(node, left)) {
587 Int64BinopMatcher mleft(m.left().node());
589 left = mleft.left().node();
619 Emit(opcode, g.DefineAsRegister(node), g.UseRegister(left),
626 this, node, &m, kPPC_And, CanCover(node, m.left().node()),
627 CanCover(node, m.right().node()), kInt16Imm_Unsigned);
632 void InstructionSelector::VisitWord32Or(Node* node) {
633 Int32BinopMatcher m(node);
635 this, node, &m, kPPC_Or, CanCover(node, m.left().node()),
636 CanCover(node, m.right().node()), kInt16Imm_Unsigned);
641 void InstructionSelector::VisitWord64Or(Node* node) {
642 Int64BinopMatcher m(node);
644 this, node, &m, kPPC_Or, CanCover(node, m.left().node()),
645 CanCover(node, m.right().node()), kInt16Imm_Unsigned);
650 void InstructionSelector::VisitWord32Xor(Node* node) {
652 Int32BinopMatcher m(node);
654 Emit(kPPC_Not, g.DefineAsRegister(node), g.UseRegister(m.left().node()));
656 VisitBinop<Int32BinopMatcher>(this, node, kPPC_Xor, kInt16Imm_Unsigned);
662 void InstructionSelector::VisitWord64Xor(Node* node) {
664 Int64BinopMatcher m(node);
666 Emit(kPPC_Not, g.DefineAsRegister(node), g.UseRegister(m.left().node()));
668 VisitBinop<Int64BinopMatcher>(this, node, kPPC_Xor, kInt16Imm_Unsigned);
674 void InstructionSelector::VisitWord32Shl(Node* node) {
676 Int32BinopMatcher m(node);
679 Int32BinopMatcher mleft(m.left().node());
688 Emit(kPPC_RotLeftAndMask32, g.DefineAsRegister(node),
689 g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
695 VisitRRO(this, kPPC_ShiftLeft32, node, kShift32Imm);
700 void InstructionSelector::VisitWord64Shl(Node* node) {
702 Int64BinopMatcher m(node);
706 Int64BinopMatcher mleft(m.left().node());
732 Emit(opcode, g.DefineAsRegister(node),
733 g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
740 VisitRRO(this, kPPC_ShiftLeft64, node, kShift64Imm);
745 void InstructionSelector::VisitWord32Shr(Node* node) {
747 Int32BinopMatcher m(node);
750 Int32BinopMatcher mleft(m.left().node());
760 Emit(kPPC_RotLeftAndMask32, g.DefineAsRegister(node),
761 g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
767 VisitRRO(this, kPPC_ShiftRight32, node, kShift32Imm);
771 void InstructionSelector::VisitWord64Shr(Node* node) {
773 Int64BinopMatcher m(node);
776 Int64BinopMatcher mleft(m.left().node());
799 Emit(opcode, g.DefineAsRegister(node),
800 g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
807 VisitRRO(this, kPPC_ShiftRight64, node, kShift64Imm);
812 void InstructionSelector::VisitWord32Sar(Node* node) {
814 Int32BinopMatcher m(node);
816 if (CanCover(node, m.left().node()) && m.left().IsWord32Shl()) {
817 Int32BinopMatcher mleft(m.left().node());
819 Emit(kPPC_ExtendSignWord16, g.DefineAsRegister(node),
820 g.UseRegister(mleft.left().node()));
823 Emit(kPPC_ExtendSignWord8, g.DefineAsRegister(node),
824 g.UseRegister(mleft.left().node()));
828 VisitRRO(this, kPPC_ShiftRightAlg32, node, kShift32Imm);
833 InstructionCode opcode2, Node* node) {
836 Node* projection1 = NodeProperties::FindProjection(node, 1);
841 g.UseRegister(node->InputAt(0)), g.UseUniqueRegister(node->InputAt(1)),
842 g.UseRegister(node->InputAt(2)), g.UseUniqueRegister(node->InputAt(3))};
845 g.DefineAsRegister(node),
846 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
852 selector->Emit(opcode2, g.DefineSameAsFirst(node),
853 g.UseRegister(node->InputAt(0)),
854 g.UseRegister(node->InputAt(2)));
858 void InstructionSelector::VisitInt32PairAdd(Node* node) {
859 VisitPairBinop(this, kPPC_AddPair, kPPC_Add32, node);
862 void InstructionSelector::VisitInt32PairSub(Node* node) {
863 VisitPairBinop(this, kPPC_SubPair, kPPC_Sub, node);
866 void InstructionSelector::VisitInt32PairMul(Node* node) {
868 Node* projection1 = NodeProperties::FindProjection(node, 1);
870 InstructionOperand inputs[] = {g.UseUniqueRegister(node->InputAt(0)),
871 g.UseUniqueRegister(node->InputAt(1)),
872 g.UseUniqueRegister(node->InputAt(2)),
873 g.UseUniqueRegister(node->InputAt(3))};
876 g.DefineAsRegister(node),
877 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
885 Emit(kPPC_Mul32, g.DefineSameAsFirst(node), g.UseRegister(node->InputAt(0)),
886 g.UseRegister(node->InputAt(2)));
893 Node* node) {
897 Int32Matcher m(node->InputAt(2));
900 shift_operand = g.UseImmediate(m.node());
902 shift_operand = g.UseUniqueRegister(m.node());
905 InstructionOperand inputs[] = {g.UseUniqueRegister(node->InputAt(0)),
906 g.UseUniqueRegister(node->InputAt(1)),
909 Node* projection1 = NodeProperties::FindProjection(node, 1);
916 outputs[output_count++] = g.DefineAsRegister(node);
927 void InstructionSelector::VisitWord32PairShl(Node* node) {
928 VisitPairShift(this, kPPC_ShiftLeftPair, node);
931 void InstructionSelector::VisitWord32PairShr(Node* node) {
932 VisitPairShift(this, kPPC_ShiftRightPair, node);
935 void InstructionSelector::VisitWord32PairSar(Node* node) {
936 VisitPairShift(this, kPPC_ShiftRightAlgPair, node);
941 void InstructionSelector::VisitWord64Sar(Node* node) {
943 Int64BinopMatcher m(node);
944 if (CanCover(m.node(), m.left().node()) && m.left().IsLoad() &&
948 BaseWithIndexAndDisplacement64Matcher mleft(m.left().node(),
952 Node* displacement = mleft.displacement();
961 g.DefineAsRegister(node), g.UseRegister(mleft.base()),
967 VisitRRO(this, kPPC_ShiftRightAlg64, node, kShift64Imm);
973 void InstructionSelector::VisitWord32Ror(Node* node) {
974 VisitRRO(this, kPPC_RotRight32, node, kShift32Imm);
980 void InstructionSelector::VisitWord64Ror(Node* node) {
981 VisitRRO(this, kPPC_RotRight64, node, kShift64Imm);
986 void InstructionSelector::VisitWord32Clz(Node* node) {
988 Emit(kPPC_Cntlz32, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
993 void InstructionSelector::VisitWord64Clz(Node* node) {
995 Emit(kPPC_Cntlz64, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
1000 void InstructionSelector::VisitWord32Popcnt(Node* node) {
1002 Emit(kPPC_Popcnt32, g.DefineAsRegister(node),
1003 g.UseRegister(node->InputAt(0)));
1008 void InstructionSelector::VisitWord64Popcnt(Node* node) {
1010 Emit(kPPC_Popcnt64, g.DefineAsRegister(node),
1011 g.UseRegister(node->InputAt(0)));
1016 void InstructionSelector::VisitWord32Ctz(Node* node) { UNREACHABLE(); }
1020 void InstructionSelector::VisitWord64Ctz(Node* node) { UNREACHABLE(); }
1024 void InstructionSelector::VisitWord32ReverseBits(Node* node) { UNREACHABLE(); }
1028 void InstructionSelector::VisitWord64ReverseBits(Node* node) { UNREACHABLE(); }
1031 void InstructionSelector::VisitWord64ReverseBytes(Node* node) { UNREACHABLE(); }
1033 void InstructionSelector::VisitWord32ReverseBytes(Node* node) { UNREACHABLE(); }
1035 void InstructionSelector::VisitInt32Add(Node* node) {
1036 VisitBinop<Int32BinopMatcher>(this, node, kPPC_Add32, kInt16Imm);
1041 void InstructionSelector::VisitInt64Add(Node* node) {
1042 VisitBinop<Int64BinopMatcher>(this, node, kPPC_Add64, kInt16Imm);
1046 void InstructionSelector::VisitInt32Sub(Node* node) {
1048 Int32BinopMatcher m(node);
1050 Emit(kPPC_Neg, g.DefineAsRegister(node), g.UseRegister(m.right().node()));
1052 VisitBinop<Int32BinopMatcher>(this, node, kPPC_Sub, kInt16Imm_Negate);
1058 void InstructionSelector::VisitInt64Sub(Node* node) {
1060 Int64BinopMatcher m(node);
1062 Emit(kPPC_Neg, g.DefineAsRegister(node), g.UseRegister(m.right().node()));
1064 VisitBinop<Int64BinopMatcher>(this, node, kPPC_Sub, kInt16Imm_Negate);
1074 void EmitInt32MulWithOverflow(InstructionSelector* selector, Node* node,
1077 Int32BinopMatcher m(node);
1078 InstructionOperand result_operand = g.DefineAsRegister(node);
1083 InstructionOperand inputs[] = {g.UseRegister(m.left().node()),
1084 g.UseRegister(m.right().node())};
1100 void InstructionSelector::VisitInt32Mul(Node* node) {
1101 VisitRRR(this, kPPC_Mul32, node);
1106 void InstructionSelector::VisitInt64Mul(Node* node) {
1107 VisitRRR(this, kPPC_Mul64, node);
1112 void InstructionSelector::VisitInt32MulHigh(Node* node) {
1114 Emit(kPPC_MulHigh32, g.DefineAsRegister(node),
1115 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
1119 void InstructionSelector::VisitUint32MulHigh(Node* node) {
1121 Emit(kPPC_MulHighU32, g.DefineAsRegister(node),
1122 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
1126 void InstructionSelector::VisitInt32Div(Node* node) {
1127 VisitRRR(this, kPPC_Div32, node);
1132 void InstructionSelector::VisitInt64Div(Node* node) {
1133 VisitRRR(this, kPPC_Div64, node);
1138 void InstructionSelector::VisitUint32Div(Node* node) {
1139 VisitRRR(this, kPPC_DivU32, node);
1144 void InstructionSelector::VisitUint64Div(Node* node) {
1145 VisitRRR(this, kPPC_DivU64, node);
1150 void InstructionSelector::VisitInt32Mod(Node* node) {
1151 VisitRRR(this, kPPC_Mod32, node);
1156 void InstructionSelector::VisitInt64Mod(Node* node) {
1157 VisitRRR(this, kPPC_Mod64, node);
1162 void InstructionSelector::VisitUint32Mod(Node* node) {
1163 VisitRRR(this, kPPC_ModU32, node);
1168 void InstructionSelector::VisitUint64Mod(Node* node) {
1169 VisitRRR(this, kPPC_ModU64, node);
1174 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
1175 VisitRR(this, kPPC_Float32ToDouble, node);
1179 void InstructionSelector::VisitRoundInt32ToFloat32(Node* node) {
1180 VisitRR(this, kPPC_Int32ToFloat32, node);
1184 void InstructionSelector::VisitRoundUint32ToFloat32(Node* node) {
1185 VisitRR(this, kPPC_Uint32ToFloat32, node);
1189 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) {
1190 VisitRR(this, kPPC_Int32ToDouble, node);
1194 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
1195 VisitRR(this, kPPC_Uint32ToDouble, node);
1199 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) {
1200 VisitRR(this, kPPC_DoubleToInt32, node);
1204 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) {
1205 VisitRR(this, kPPC_DoubleToUint32, node);
1208 void InstructionSelector::VisitTruncateFloat64ToUint32(Node* node) {
1209 VisitRR(this, kPPC_DoubleToUint32, node);
1213 void InstructionSelector::VisitTryTruncateFloat32ToInt64(Node* node) {
1214 VisitTryTruncateDouble(this, kPPC_DoubleToInt64, node);
1218 void InstructionSelector::VisitTryTruncateFloat64ToInt64(Node* node) {
1219 VisitTryTruncateDouble(this, kPPC_DoubleToInt64, node);
1223 void InstructionSelector::VisitTryTruncateFloat32ToUint64(Node* node) {
1224 VisitTryTruncateDouble(this, kPPC_DoubleToUint64, node);
1228 void InstructionSelector::VisitTryTruncateFloat64ToUint64(Node* node) {
1229 VisitTryTruncateDouble(this, kPPC_DoubleToUint64, node);
1233 void InstructionSelector::VisitChangeInt32ToInt64(Node* node) {
1235 VisitRR(this, kPPC_ExtendSignWord32, node);
1239 void InstructionSelector::VisitChangeUint32ToUint64(Node* node) {
1241 VisitRR(this, kPPC_Uint32ToUint64, node);
1246 void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
1247 VisitRR(this, kPPC_DoubleToFloat32, node);
1250 void InstructionSelector::VisitTruncateFloat64ToWord32(Node* node) {
1251 VisitRR(this, kArchTruncateDoubleToI, node);
1254 void InstructionSelector::VisitRoundFloat64ToInt32(Node* node) {
1255 VisitRR(this, kPPC_DoubleToInt32, node);
1259 void InstructionSelector::VisitTruncateFloat32ToInt32(Node* node) {
1260 VisitRR(this, kPPC_DoubleToInt32, node);
1264 void InstructionSelector::VisitTruncateFloat32ToUint32(Node* node) {
1265 VisitRR(this, kPPC_DoubleToUint32, node);
1270 void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) {
1272 VisitRR(this, kPPC_Int64ToInt32, node);
1276 void InstructionSelector::VisitRoundInt64ToFloat32(Node* node) {
1277 VisitRR(this, kPPC_Int64ToFloat32, node);
1281 void InstructionSelector::VisitRoundInt64ToFloat64(Node* node) {
1282 VisitRR(this, kPPC_Int64ToDouble, node);
1286 void InstructionSelector::VisitRoundUint64ToFloat32(Node* node) {
1287 VisitRR(this, kPPC_Uint64ToFloat32, node);
1291 void InstructionSelector::VisitRoundUint64ToFloat64(Node* node) {
1292 VisitRR(this, kPPC_Uint64ToDouble, node);
1297 void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) {
1298 VisitRR(this, kPPC_BitcastFloat32ToInt32, node);
1303 void InstructionSelector::VisitBitcastFloat64ToInt64(Node* node) {
1304 VisitRR(this, kPPC_BitcastDoubleToInt64, node);
1309 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) {
1310 VisitRR(this, kPPC_BitcastInt32ToFloat32, node);
1315 void InstructionSelector::VisitBitcastInt64ToFloat64(Node* node) {
1316 VisitRR(this, kPPC_BitcastInt64ToDouble, node);
1321 void InstructionSelector::VisitFloat32Add(Node* node) {
1322 VisitRRR(this, kPPC_AddDouble | MiscField::encode(1), node);
1326 void InstructionSelector::VisitFloat64Add(Node* node) {
1328 VisitRRR(this, kPPC_AddDouble, node);
1332 void InstructionSelector::VisitFloat32Sub(Node* node) {
1333 VisitRRR(this, kPPC_SubDouble | MiscField::encode(1), node);
1336 void InstructionSelector::VisitFloat64Sub(Node* node) {
1338 VisitRRR(this, kPPC_SubDouble, node);
1341 void InstructionSelector::VisitFloat32Mul(Node* node) {
1342 VisitRRR(this, kPPC_MulDouble | MiscField::encode(1), node);
1346 void InstructionSelector::VisitFloat64Mul(Node* node) {
1348 VisitRRR(this, kPPC_MulDouble, node);
1352 void InstructionSelector::VisitFloat32Div(Node* node) {
1353 VisitRRR(this, kPPC_DivDouble | MiscField::encode(1), node);
1357 void InstructionSelector::VisitFloat64Div(Node* node) {
1358 VisitRRR(this, kPPC_DivDouble, node);
1362 void InstructionSelector::VisitFloat64Mod(Node* node) {
1364 Emit(kPPC_ModDouble, g.DefineAsFixed(node, d1),
1365 g.UseFixed(node->InputAt(0), d1),
1366 g.UseFixed(node->InputAt(1), d2))->MarkAsCall();
1369 void InstructionSelector::VisitFloat32Max(Node* node) {
1370 VisitRRR(this, kPPC_MaxDouble | MiscField::encode(1), node);
1373 void InstructionSelector::VisitFloat64Max(Node* node) {
1374 VisitRRR(this, kPPC_MaxDouble, node);
1378 void InstructionSelector::VisitFloat64SilenceNaN(Node* node) {
1379 VisitRR(this, kPPC_Float64SilenceNaN, node);
1382 void InstructionSelector::VisitFloat32Min(Node* node) {
1383 VisitRRR(this, kPPC_MinDouble | MiscField::encode(1), node);
1386 void InstructionSelector::VisitFloat64Min(Node* node) {
1387 VisitRRR(this, kPPC_MinDouble, node);
1391 void InstructionSelector::VisitFloat32Abs(Node* node) {
1392 VisitRR(this, kPPC_AbsDouble | MiscField::encode(1), node);
1396 void InstructionSelector::VisitFloat64Abs(Node* node) {
1397 VisitRR(this, kPPC_AbsDouble, node);
1400 void InstructionSelector::VisitFloat32Sqrt(Node* node) {
1401 VisitRR(this, kPPC_SqrtDouble | MiscField::encode(1), node);
1404 void InstructionSelector::VisitFloat64Ieee754Unop(Node* node,
1407 Emit(opcode, g.DefineAsFixed(node, d1), g.UseFixed(node->InputAt(0), d1))
1411 void InstructionSelector::VisitFloat64Ieee754Binop(Node* node,
1414 Emit(opcode, g.DefineAsFixed(node, d1),
1415 g.UseFixed(node->InputAt(0), d1),
1416 g.UseFixed(node->InputAt(1), d2))->MarkAsCall();
1419 void InstructionSelector::VisitFloat64Sqrt(Node* node) {
1420 VisitRR(this, kPPC_SqrtDouble, node);
1424 void InstructionSelector::VisitFloat32RoundDown(Node* node) {
1425 VisitRR(this, kPPC_FloorDouble | MiscField::encode(1), node);
1429 void InstructionSelector::VisitFloat64RoundDown(Node* node) {
1430 VisitRR(this, kPPC_FloorDouble, node);
1434 void InstructionSelector::VisitFloat32RoundUp(Node* node) {
1435 VisitRR(this, kPPC_CeilDouble | MiscField::encode(1), node);
1439 void InstructionSelector::VisitFloat64RoundUp(Node* node) {
1440 VisitRR(this, kPPC_CeilDouble, node);
1444 void InstructionSelector::VisitFloat32RoundTruncate(Node* node) {
1445 VisitRR(this, kPPC_TruncateDouble | MiscField::encode(1), node);
1449 void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
1450 VisitRR(this, kPPC_TruncateDouble, node);
1454 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
1455 VisitRR(this, kPPC_RoundDouble, node);
1459 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) {
1464 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) {
1468 void InstructionSelector::VisitFloat32Neg(Node* node) {
1469 VisitRR(this, kPPC_NegDouble, node);
1472 void InstructionSelector::VisitFloat64Neg(Node* node) {
1473 VisitRR(this, kPPC_NegDouble, node);
1476 void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
1477 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1479 return VisitBinop<Int32BinopMatcher>(this, node, kPPC_AddWithOverflow32,
1483 VisitBinop<Int32BinopMatcher>(this, node, kPPC_AddWithOverflow32, kInt16Imm,
1488 void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
1489 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1491 return VisitBinop<Int32BinopMatcher>(this, node, kPPC_SubWithOverflow32,
1495 VisitBinop<Int32BinopMatcher>(this, node, kPPC_SubWithOverflow32,
1501 void InstructionSelector::VisitInt64AddWithOverflow(Node* node) {
1502 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1504 return VisitBinop<Int64BinopMatcher>(this, node, kPPC_Add64, kInt16Imm,
1508 VisitBinop<Int64BinopMatcher>(this, node, kPPC_Add64, kInt16Imm, &cont);
1512 void InstructionSelector::VisitInt64SubWithOverflow(Node* node) {
1513 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1515 return VisitBinop<Int64BinopMatcher>(this, node, kPPC_Sub, kInt16Imm_Negate,
1519 VisitBinop<Int64BinopMatcher>(this, node, kPPC_Sub, kInt16Imm_Negate, &cont);
1564 void VisitWordCompare(InstructionSelector* selector, Node* node,
1568 Node* left = node->InputAt(0);
1569 Node* right = node->InputAt(1);
1586 void VisitWord32Compare(InstructionSelector* selector, Node* node,
1589 VisitWordCompare(selector, node, kPPC_Cmp32, cont, false, mode);
1594 void VisitWord64Compare(InstructionSelector* selector, Node* node,
1597 VisitWordCompare(selector, node, kPPC_Cmp64, cont, false, mode);
1603 void VisitFloat32Compare(InstructionSelector* selector, Node* node,
1606 Node* left = node->InputAt(0);
1607 Node* right = node->InputAt(1);
1614 void VisitFloat64Compare(InstructionSelector* selector, Node* node,
1617 Node* left = node->InputAt(0);
1618 Node* right = node->InputAt(1);
1625 void VisitWordCompareZero(InstructionSelector* selector, Node* user,
1626 Node* value, InstructionCode opcode,
1635 value = m.left().node();
1693 // <Operation>WithOverflow node.
1700 Node* const node = value->InputAt(0);
1701 Node* const result = NodeProperties::FindProjection(node, 0);
1703 switch (node->opcode()) {
1707 selector, node, kPPC_AddWithOverflow32, kInt16Imm, cont);
1710 return VisitBinop<Int32BinopMatcher>(selector, node,
1715 return EmitInt32MulWithOverflow(selector, node, cont);
1719 return VisitBinop<Int64BinopMatcher>(selector, node, kPPC_Add64,
1723 return VisitBinop<Int64BinopMatcher>(selector, node, kPPC_Sub,
1774 void VisitWord32CompareZero(InstructionSelector* selector, Node* user,
1775 Node* value, FlagsContinuation* cont) {
1781 void VisitWord64CompareZero(InstructionSelector* selector, Node* user,
1782 Node* value, FlagsContinuation* cont) {
1790 void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
1796 void InstructionSelector::VisitDeoptimizeIf(Node* node) {
1797 DeoptimizeParameters p = DeoptimizeParametersOf(node->op());
1799 kNotEqual, p.kind(), p.reason(), node->InputAt(1));
1800 VisitWord32CompareZero(this, node, node->InputAt(0), &cont);
1803 void InstructionSelector::VisitDeoptimizeUnless(Node* node) {
1804 DeoptimizeParameters p = DeoptimizeParametersOf(node->op());
1806 kEqual, p.kind(), p.reason(), node->InputAt(1));
1807 VisitWord32CompareZero(this, node, node->InputAt(0), &cont);
1810 void InstructionSelector::VisitTrapIf(Node* node, Runtime::FunctionId func_id) {
1812 FlagsContinuation::ForTrap(kNotEqual, func_id, node->InputAt(1));
1813 VisitWord32CompareZero(this, node, node->InputAt(0), &cont);
1816 void InstructionSelector::VisitTrapUnless(Node* node,
1819 FlagsContinuation::ForTrap(kEqual, func_id, node->InputAt(1));
1820 VisitWord32CompareZero(this, node, node->InputAt(0), &cont);
1823 void InstructionSelector::VisitSwitch(Node* node, const SwitchInfo& sw) {
1825 InstructionOperand value_operand = g.UseRegister(node->InputAt(0));
1851 void InstructionSelector::VisitWord32Equal(Node* const node) {
1852 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1853 Int32BinopMatcher m(node);
1855 return VisitWord32CompareZero(this, m.node(), m.left().node(), &cont);
1857 VisitWord32Compare(this, node, &cont);
1861 void InstructionSelector::VisitInt32LessThan(Node* node) {
1862 FlagsContinuation cont = FlagsContinuation::ForSet(kSignedLessThan, node);
1863 VisitWord32Compare(this, node, &cont);
1867 void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
1869 FlagsContinuation::ForSet(kSignedLessThanOrEqual, node);
1870 VisitWord32Compare(this, node, &cont);
1874 void InstructionSelector::VisitUint32LessThan(Node* node) {
1875 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1876 VisitWord32Compare(this, node, &cont);
1880 void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
1882 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1883 VisitWord32Compare(this, node, &cont);
1888 void InstructionSelector::VisitWord64Equal(Node* const node) {
1889 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1890 Int64BinopMatcher m(node);
1892 return VisitWord64CompareZero(this, m.node(), m.left().node(), &cont);
1894 VisitWord64Compare(this, node, &cont);
1898 void InstructionSelector::VisitInt64LessThan(Node* node) {
1899 FlagsContinuation cont = FlagsContinuation::ForSet(kSignedLessThan, node);
1900 VisitWord64Compare(this, node, &cont);
1904 void InstructionSelector::VisitInt64LessThanOrEqual(Node* node) {
1906 FlagsContinuation::ForSet(kSignedLessThanOrEqual, node);
1907 VisitWord64Compare(this, node, &cont);
1911 void InstructionSelector::VisitUint64LessThan(Node* node) {
1912 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1913 VisitWord64Compare(this, node, &cont);
1917 void InstructionSelector::VisitUint64LessThanOrEqual(Node* node) {
1919 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1920 VisitWord64Compare(this, node, &cont);
1924 void InstructionSelector::VisitInt32MulWithOverflow(Node* node) {
1925 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1927 return EmitInt32MulWithOverflow(this, node, &cont);
1930 EmitInt32MulWithOverflow(this, node, &cont);
1934 void InstructionSelector::VisitFloat32Equal(Node* node) {
1935 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1936 VisitFloat32Compare(this, node, &cont);
1940 void InstructionSelector::VisitFloat32LessThan(Node* node) {
1941 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1942 VisitFloat32Compare(this, node, &cont);
1946 void InstructionSelector::VisitFloat32LessThanOrEqual(Node* node) {
1948 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1949 VisitFloat32Compare(this, node, &cont);
1953 void InstructionSelector::VisitFloat64Equal(Node* node) {
1954 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1955 VisitFloat64Compare(this, node, &cont);
1959 void InstructionSelector::VisitFloat64LessThan(Node* node) {
1960 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1961 VisitFloat64Compare(this, node, &cont);
1965 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
1967 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1968 VisitFloat64Compare(this, node, &cont);
1974 Node* node) {
1986 Emit(kPPC_StoreToStackSlot, g.NoOutput(), g.UseRegister(input.node()),
1996 DCHECK(input.node());
1997 Emit(kPPC_PushFrame, g.NoOutput(), g.UseRegister(input.node()),
2001 if (input.node()) {
2002 Emit(kPPC_StoreToStackSlot, g.NoOutput(), g.UseRegister(input.node()),
2016 void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) {
2018 Emit(kPPC_DoubleExtractLowWord32, g.DefineAsRegister(node),
2019 g.UseRegister(node->InputAt(0)));
2023 void InstructionSelector::VisitFloat64ExtractHighWord32(Node* node) {
2025 Emit(kPPC_DoubleExtractHighWord32, g.DefineAsRegister(node),
2026 g.UseRegister(node->InputAt(0)));
2030 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) {
2032 Node* left = node->InputAt(0);
2033 Node* right = node->InputAt(1);
2035 CanCover(node, left)) {
2037 Emit(kPPC_DoubleConstruct, g.DefineAsRegister(node), g.UseRegister(left),
2041 Emit(kPPC_DoubleInsertLowWord32, g.DefineSameAsFirst(node),
2046 void InstructionSelector::VisitFloat64InsertHighWord32(Node* node) {
2048 Node* left = node->InputAt(0);
2049 Node* right = node->InputAt(1);
2051 CanCover(node, left)) {
2053 Emit(kPPC_DoubleConstruct, g.DefineAsRegister(node), g.UseRegister(right),
2057 Emit(kPPC_DoubleInsertHighWord32, g.DefineSameAsFirst(node),
2061 void InstructionSelector::VisitAtomicLoad(Node* node) {
2062 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
2064 Node* base = node->InputAt(0);
2065 Node* index = node->InputAt(1);
2082 g.DefineAsRegister(node), g.UseRegister(base), g.UseRegister(index));
2085 void InstructionSelector::VisitAtomicStore(Node* node) {
2086 MachineRepresentation rep = AtomicStoreRepresentationOf(node->op());
2088 Node* base = node->InputAt(0);
2089 Node* index = node->InputAt(1);
2090 Node* value = node->InputAt(2);
