Lines Matching refs:node
8 #include "src/compiler/node-matchers.h"
9 #include "src/compiler/node-properties.h"
29 bool CanBeImmediate(Node* node, InstructionCode opcode) {
30 Int32Matcher m(node);
81 void VisitRR(InstructionSelector* selector, ArchOpcode opcode, Node* node) {
83 selector->Emit(opcode, g.DefineAsRegister(node),
84 g.UseRegister(node->InputAt(0)));
88 void VisitRRR(InstructionSelector* selector, ArchOpcode opcode, Node* node) {
90 selector->Emit(opcode, g.DefineAsRegister(node),
91 g.UseRegister(node->InputAt(0)),
92 g.UseRegister(node->InputAt(1)));
99 InstructionCode* opcode_return, Node* node,
103 if (node->opcode() == kOpcode) {
104 Int32BinopMatcher m(node);
105 *value_return = g.UseRegister(m.left().node());
108 *shift_return = g.UseImmediate(m.right().node());
111 *shift_return = g.UseRegister(m.right().node());
121 InstructionCode* opcode_return, Node* node,
125 if (node->opcode() == kOpcode) {
126 Int32BinopMatcher m(node);
129 *value_return = g.UseRegister(m.left().node());
130 *shift_return = g.UseImmediate(m.right().node());
138 Node* node, InstructionOperand* value_return,
141 kMode_Operand2_R_ROR_R>(selector, opcode_return, node,
147 Node* node, InstructionOperand* value_return,
150 kMode_Operand2_R_ASR_R>(selector, opcode_return, node,
156 Node* node, InstructionOperand* value_return,
159 kMode_Operand2_R_LSL_R>(selector, opcode_return, node,
164 InstructionCode* opcode_return, Node* node,
169 selector, opcode_return, node, value_return, shift_return);
173 Node* node, InstructionOperand* value_return,
176 kMode_Operand2_R_LSR_R>(selector, opcode_return, node,
182 InstructionCode* opcode_return, Node* node,
186 TryMatchASR(selector, opcode_return, node, value_return, shift_return) ||
187 TryMatchLSL(selector, opcode_return, node, value_return, shift_return) ||
188 TryMatchLSR(selector, opcode_return, node, value_return, shift_return) ||
189 TryMatchROR(selector, opcode_return, node, value_return, shift_return));
194 InstructionCode* opcode_return, Node* node,
198 if (g.CanBeImmediate(node, *opcode_return)) {
200 inputs[0] = g.UseImmediate(node);
204 if (TryMatchShift(selector, opcode_return, node, &inputs[0], &inputs[1])) {
212 void VisitBinop(InstructionSelector* selector, Node* node,
216 Int32BinopMatcher m(node);
222 if (m.left().node() == m.right().node()) {
230 InstructionOperand const input = g.UseRegister(m.left().node());
234 } else if (TryMatchImmediateOrShift(selector, &opcode, m.right().node(),
236 inputs[0] = g.UseRegister(m.left().node());
239 m.left().node(), &input_count,
241 inputs[0] = g.UseRegister(m.right().node());
246 inputs[input_count++] = g.UseRegister(m.left().node());
247 inputs[input_count++] = g.UseRegister(m.right().node());
259 outputs[output_count++] = g.DefineSameAsFirst(node);
261 outputs[output_count++] = g.DefineAsRegister(node);
283 void VisitBinop(InstructionSelector* selector, Node* node,
286 VisitBinop(selector, node, opcode, reverse_opcode, &cont);
310 void VisitDiv(InstructionSelector* selector, Node* node, ArchOpcode div_opcode,
313 Int32BinopMatcher m(node);
315 g.DefineAsRegister(node), g.UseRegister(m.left().node()),
316 g.UseRegister(m.right().node()));
320 void VisitMod(InstructionSelector* selector, Node* node, ArchOpcode div_opcode,
323 Int32BinopMatcher m(node);
325 InstructionOperand result_operand = g.DefineAsRegister(node);
326 InstructionOperand left_operand = g.UseRegister(m.left().node());
327 InstructionOperand right_operand = g.UseRegister(m.right().node());
344 void InstructionSelector::VisitLoad(Node* node) {
345 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
347 Node* base = node->InputAt(0);
348 Node* index = node->InputAt(1);
379 outputs[0] = g.DefineAsRegister(node);
400 void InstructionSelector::VisitStore(Node* node) {
402 Node* base = node->InputAt(0);
403 Node* index = node->InputAt(1);
404 Node* value = node->InputAt(2);
406 StoreRepresentation store_rep = StoreRepresentationOf(node->op());
498 void InstructionSelector::VisitCheckedLoad(Node* node) {
499 CheckedLoadRepresentation load_rep = CheckedLoadRepresentationOf(node->op());
501 Node* const buffer = node->InputAt(0);
502 Node* const offset = node->InputAt(1);
503 Node* const length = node->InputAt(2);
534 g.DefineAsRegister(node), offset_operand, length_operand,
539 void InstructionSelector::VisitCheckedStore(Node* node) {
540 MachineRepresentation rep = CheckedStoreRepresentationOf(node->op());
542 Node* const buffer = node->InputAt(0);
543 Node* const offset = node->InputAt(1);
544 Node* const length = node->InputAt(2);
545 Node* const value = node->InputAt(3);
583 void EmitBic(InstructionSelector* selector, Node* node, Node* left,
584 Node* right) {
590 selector->Emit(opcode, g.DefineAsRegister(node), g.UseRegister(left),
595 g.DefineAsRegister(node), g.UseRegister(left),
600 void EmitUbfx(InstructionSelector* selector, Node* node, Node* left,
605 selector->Emit(kArmUbfx, g.DefineAsRegister(node), g.UseRegister(left),
612 void InstructionSelector::VisitWord32And(Node* node) {
614 Int32BinopMatcher m(node);
615 if (m.left().IsWord32Xor() && CanCover(node, m.left().node())) {
616 Int32BinopMatcher mleft(m.left().node());
618 EmitBic(this, node, m.right().node(), mleft.left().node());
622 if (m.right().IsWord32Xor() && CanCover(node, m.right().node())) {
623 Int32BinopMatcher mright(m.right().node());
625 EmitBic(this, node, m.left().node(), mright.left().node());
636 Int32BinopMatcher mshr(m.left().node());
645 g.DefineAsRegister(m.node()), g.UseRegister(mshr.left().node()),
657 EmitUbfx(this, node, mshr.left().node(), shift,
666 Emit(kArmUxth, g.DefineAsRegister(m.node()),
667 g.UseRegister(m.left().node()), g.TempImmediate(0));
673 g.DefineAsRegister(node), g.UseRegister(m.left().node()),
684 EmitUbfx(this, node, m.left().node(), 0, width);
693 Emit(kArmBfc, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
699 VisitBinop(this, node, kArmAnd, kArmAnd);
703 void InstructionSelector::VisitWord32Or(Node* node) {
704 VisitBinop(this, node, kArmOrr, kArmOrr);
708 void InstructionSelector::VisitWord32Xor(Node* node) {
710 Int32BinopMatcher m(node);
715 if (TryMatchShift(this, &opcode, m.left().node(), &value_operand,
717 Emit(opcode, g.DefineAsRegister(node), value_operand, shift_operand);
721 g.DefineAsRegister(node), g.UseRegister(m.left().node()));
724 VisitBinop(this, node, kArmEor, kArmEor);
731 void VisitShift(InstructionSelector* selector, Node* node,
740 CHECK(try_match_shift(selector, &opcode, node, &inputs[0], &inputs[1]));
747 outputs[output_count++] = g.DefineAsRegister(node);
769 void VisitShift(InstructionSelector* selector, Node* node,
772 VisitShift(selector, node, try_match_shift, &cont);
778 void InstructionSelector::VisitWord32Shl(Node* node) {
779 VisitShift(this, node, TryMatchLSL);
783 void InstructionSelector::VisitWord32Shr(Node* node) {
785 Int32BinopMatcher m(node);
789 Int32BinopMatcher mleft(m.left().node());
796 return EmitUbfx(this, node, mleft.left().node(), lsb, width);
800 VisitShift(this, node, TryMatchLSR);
804 void InstructionSelector::VisitWord32Sar(Node* node) {
806 Int32BinopMatcher m(node);
807 if (CanCover(m.node(), m.left().node()) && m.left().IsWord32Shl()) {
808 Int32BinopMatcher mleft(m.left().node());
813 Emit(kArmSxth, g.DefineAsRegister(node),
814 g.UseRegister(mleft.left().node()), g.TempImmediate(0));
817 Emit(kArmSxtb, g.DefineAsRegister(node),
818 g.UseRegister(mleft.left().node()), g.TempImmediate(0));
821 Emit(kArmSbfx, g.DefineAsRegister(node),
822 g.UseRegister(mleft.left().node()), g.TempImmediate(sar - shl),
828 VisitShift(this, node, TryMatchASR);
831 void InstructionSelector::VisitInt32PairAdd(Node* node) {
837 g.UseRegister(node->InputAt(0)), g.UseUniqueRegister(node->InputAt(1)),
838 g.UseRegister(node->InputAt(2)), g.UseUniqueRegister(node->InputAt(3))};
841 g.DefineAsRegister(node),
842 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
847 void InstructionSelector::VisitInt32PairSub(Node* node) {
853 g.UseRegister(node->InputAt(0)), g.UseUniqueRegister(node->InputAt(1)),
854 g.UseRegister(node->InputAt(2)), g.UseUniqueRegister(node->InputAt(3))};
857 g.DefineAsRegister(node),
858 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
863 void InstructionSelector::VisitInt32PairMul(Node* node) {
865 InstructionOperand inputs[] = {g.UseUniqueRegister(node->InputAt(0)),
866 g.UseUniqueRegister(node->InputAt(1)),
867 g.UseUniqueRegister(node->InputAt(2)),
868 g.UseUniqueRegister(node->InputAt(3))};
871 g.DefineAsRegister(node),
872 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
877 void InstructionSelector::VisitWord32PairShl(Node* node) {
881 Int32Matcher m(node->InputAt(2));
884 shift_operand = g.UseImmediate(m.node());
886 shift_operand = g.UseUniqueRegister(m.node());
889 InstructionOperand inputs[] = {g.UseUniqueRegister(node->InputAt(0)),
890 g.UseRegister(node->InputAt(1)),
894 g.DefineAsRegister(node),
895 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
900 void InstructionSelector::VisitWord32PairShr(Node* node) {
904 Int32Matcher m(node->InputAt(2));
907 shift_operand = g.UseImmediate(m.node());
909 shift_operand = g.UseUniqueRegister(m.node());
912 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0)),
913 g.UseUniqueRegister(node->InputAt(1)),
917 g.DefineAsRegister(node),
918 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
923 void InstructionSelector::VisitWord32PairSar(Node* node) {
927 Int32Matcher m(node->InputAt(2));
930 shift_operand = g.UseImmediate(m.node());
932 shift_operand = g.UseUniqueRegister(m.node());
935 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0)),
936 g.UseUniqueRegister(node->InputAt(1)),
940 g.DefineAsRegister(node),
941 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
946 void InstructionSelector::VisitWord32Ror(Node* node) {
947 VisitShift(this, node, TryMatchROR);
951 void InstructionSelector::VisitWord32Clz(Node* node) {
952 VisitRR(this, kArmClz, node);
956 void InstructionSelector::VisitWord32Ctz(Node* node) { UNREACHABLE(); }
959 void InstructionSelector::VisitWord32ReverseBits(Node* node) {
961 VisitRR(this, kArmRbit, node);
965 void InstructionSelector::VisitWord32Popcnt(Node* node) { UNREACHABLE(); }
968 void InstructionSelector::VisitInt32Add(Node* node) {
970 Int32BinopMatcher m(node);
971 if (CanCover(node, m.left().node())) {
974 Int32BinopMatcher mleft(m.left().node());
975 Emit(kArmMla, g.DefineAsRegister(node),
976 g.UseRegister(mleft.left().node()),
977 g.UseRegister(mleft.right().node()),
978 g.UseRegister(m.right().node()));
982 Int32BinopMatcher mleft(m.left().node());
983 Emit(kArmSmmla, g.DefineAsRegister(node),
984 g.UseRegister(mleft.left().node()),
985 g.UseRegister(mleft.right().node()),
986 g.UseRegister(m.right().node()));
990 Int32BinopMatcher mleft(m.left().node());
992 Emit(kArmUxtab, g.DefineAsRegister(node),
993 g.UseRegister(m.right().node()),
994 g.UseRegister(mleft.left().node()), g.TempImmediate(0));
997 Emit(kArmUxtah, g.DefineAsRegister(node),
998 g.UseRegister(m.right().node()),
999 g.UseRegister(mleft.left().node()), g.TempImmediate(0));
1004 Int32BinopMatcher mleft(m.left().node());
1005 if (CanCover(mleft.node(), mleft.left().node()) &&
1007 Int32BinopMatcher mleftleft(mleft.left().node());
1009 Emit(kArmSxtab, g.DefineAsRegister(node),
1010 g.UseRegister(m.right().node()),
1011 g.UseRegister(mleftleft.left().node()), g.TempImmediate(0));
1014 Emit(kArmSxtah, g.DefineAsRegister(node),
1015 g.UseRegister(m.right().node()),
1016 g.UseRegister(mleftleft.left().node()), g.TempImmediate(0));
1025 if (CanCover(node, m.right().node())) {
1028 Int32BinopMatcher mright(m.right().node());
1029 Emit(kArmMla, g.DefineAsRegister(node),
1030 g.UseRegister(mright.left().node()),
1031 g.UseRegister(mright.right().node()),
1032 g.UseRegister(m.left().node()));
1036 Int32BinopMatcher mright(m.right().node());
1037 Emit(kArmSmmla, g.DefineAsRegister(node),
1038 g.UseRegister(mright.left().node()),
1039 g.UseRegister(mright.right().node()),
1040 g.UseRegister(m.left().node()));
1044 Int32BinopMatcher mright(m.right().node());
1046 Emit(kArmUxtab, g.DefineAsRegister(node),
1047 g.UseRegister(m.left().node()),
1048 g.UseRegister(mright.left().node()), g.TempImmediate(0));
1051 Emit(kArmUxtah, g.DefineAsRegister(node),
1052 g.UseRegister(m.left().node()),
1053 g.UseRegister(mright.left().node()), g.TempImmediate(0));
1058 Int32BinopMatcher mright(m.right().node());
1059 if (CanCover(mright.node(), mright.left().node()) &&
1061 Int32BinopMatcher mrightleft(mright.left().node());
1063 Emit(kArmSxtab, g.DefineAsRegister(node),
1064 g.UseRegister(m.left().node()),
1065 g.UseRegister(mrightleft.left().node()), g.TempImmediate(0));
1068 Emit(kArmSxtah, g.DefineAsRegister(node),
1069 g.UseRegister(m.left().node()),
1070 g.UseRegister(mrightleft.left().node()), g.TempImmediate(0));
1079 VisitBinop(this, node, kArmAdd, kArmAdd);
1083 void InstructionSelector::VisitInt32Sub(Node* node) {
1085 Int32BinopMatcher m(node);
1087 CanCover(node, m.right().node())) {
1088 Int32BinopMatcher mright(m.right().node());
1089 Emit(kArmMls, g.DefineAsRegister(node), g.UseRegister(mright.left().node()),
1090 g.UseRegister(mright.right().node()), g.UseRegister(m.left().node()));
1093 VisitBinop(this, node, kArmSub, kArmRsb);
1097 void InstructionSelector::VisitInt32Mul(Node* node) {
1099 Int32BinopMatcher m(node);
1104 g.DefineAsRegister(node), g.UseRegister(m.left().node()),
1105 g.UseRegister(m.left().node()),
1111 g.DefineAsRegister(node), g.UseRegister(m.left().node()),
1112 g.UseRegister(m.left().node()),
1117 VisitRRR(this, kArmMul, node);
1121 void InstructionSelector::VisitInt32MulHigh(Node* node) {
1122 VisitRRR(this, kArmSmmul, node);
1126 void InstructionSelector::VisitUint32MulHigh(Node* node) {
1128 InstructionOperand outputs[] = {g.TempRegister(), g.DefineAsRegister(node)};
1129 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0)),
1130 g.UseRegister(node->InputAt(1))};
1135 void InstructionSelector::VisitInt32Div(Node* node) {
1136 VisitDiv(this, node, kArmSdiv, kArmVcvtF64S32, kArmVcvtS32F64);
1140 void InstructionSelector::VisitUint32Div(Node* node) {
1141 VisitDiv(this, node, kArmUdiv, kArmVcvtF64U32, kArmVcvtU32F64);
1145 void InstructionSelector::VisitInt32Mod(Node* node) {
1146 VisitMod(this, node, kArmSdiv, kArmVcvtF64S32, kArmVcvtS32F64);
1150 void InstructionSelector::VisitUint32Mod(Node* node) {
1151 VisitMod(this, node, kArmUdiv, kArmVcvtF64U32, kArmVcvtU32F64);
1155 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
1156 VisitRR(this, kArmVcvtF64F32, node);
1160 void InstructionSelector::VisitRoundInt32ToFloat32(Node* node) {
1161 VisitRR(this, kArmVcvtF32S32, node);
1165 void InstructionSelector::VisitRoundUint32ToFloat32(Node* node) {
1166 VisitRR(this, kArmVcvtF32U32, node);
1170 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) {
1171 VisitRR(this, kArmVcvtF64S32, node);
1175 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
1176 VisitRR(this, kArmVcvtF64U32, node);
1180 void InstructionSelector::VisitTruncateFloat32ToInt32(Node* node) {
1181 VisitRR(this, kArmVcvtS32F32, node);
1185 void InstructionSelector::VisitTruncateFloat32ToUint32(Node* node) {
1186 VisitRR(this, kArmVcvtU32F32, node);
1190 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) {
1191 VisitRR(this, kArmVcvtS32F64, node);
1195 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) {
1196 VisitRR(this, kArmVcvtU32F64, node);
1199 void InstructionSelector::VisitTruncateFloat64ToUint32(Node* node) {
1200 VisitRR(this, kArmVcvtU32F64, node);
1202 void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
1203 VisitRR(this, kArmVcvtF32F64, node);
1206 void InstructionSelector::VisitTruncateFloat64ToWord32(Node* node) {
1207 VisitRR(this, kArchTruncateDoubleToI, node);
1210 void InstructionSelector::VisitRoundFloat64ToInt32(Node* node) {
1211 VisitRR(this, kArmVcvtS32F64, node);
1214 void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) {
1215 VisitRR(this, kArmVmovU32F32, node);
1218 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) {
1219 VisitRR(this, kArmVmovF32U32, node);
1222 void InstructionSelector::VisitFloat32Add(Node* node) {
1224 Float32BinopMatcher m(node);
1225 if (m.left().IsFloat32Mul() && CanCover(node, m.left().node())) {
1226 Float32BinopMatcher mleft(m.left().node());
1227 Emit(kArmVmlaF32, g.DefineSameAsFirst(node),
1228 g.UseRegister(m.right().node()), g.UseRegister(mleft.left().node()),
1229 g.UseRegister(mleft.right().node()));
1232 if (m.right().IsFloat32Mul() && CanCover(node, m.right().node())) {
1233 Float32BinopMatcher mright(m.right().node());
1234 Emit(kArmVmlaF32, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
1235 g.UseRegister(mright.left().node()),
1236 g.UseRegister(mright.right().node()));
1239 VisitRRR(this, kArmVaddF32, node);
1243 void InstructionSelector::VisitFloat64Add(Node* node) {
1245 Float64BinopMatcher m(node);
1246 if (m.left().IsFloat64Mul() && CanCover(node, m.left().node())) {
1247 Float64BinopMatcher mleft(m.left().node());
1248 Emit(kArmVmlaF64, g.DefineSameAsFirst(node),
1249 g.UseRegister(m.right().node()), g.UseRegister(mleft.left().node()),
1250 g.UseRegister(mleft.right().node()));
1253 if (m.right().IsFloat64Mul() && CanCover(node, m.right().node())) {
1254 Float64BinopMatcher mright(m.right().node());
1255 Emit(kArmVmlaF64, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()),
1256 g.UseRegister(mright.left().node()),
1257 g.UseRegister(mright.right().node()));
1260 VisitRRR(this, kArmVaddF64, node);
1264 void VisitFloat32SubHelper(InstructionSelector* selector, Node* node) {
1266 Float32BinopMatcher m(node);
1267 if (m.right().IsFloat32Mul() && selector->CanCover(node, m.right().node())) {
1268 Float32BinopMatcher mright(m.right().node());
1269 selector->Emit(kArmVmlsF32, g.DefineSameAsFirst(node),
1270 g.UseRegister(m.left().node()),
1271 g.UseRegister(mright.left().node()),
1272 g.UseRegister(mright.right().node()));
1275 VisitRRR(selector, kArmVsubF32, node);
1278 void VisitFloat64SubHelper(InstructionSelector* selector, Node* node) {
1280 Float64BinopMatcher m(node);
1281 if (m.right().IsFloat64Mul() && selector->CanCover(node, m.right().node())) {
1282 Float64BinopMatcher mright(m.right().node());
1283 selector->Emit(kArmVmlsF64, g.DefineSameAsFirst(node),
1284 g.UseRegister(m.left().node()),
1285 g.UseRegister(mright.left().node()),
1286 g.UseRegister(mright.right().node()));
1289 VisitRRR(selector, kArmVsubF64, node);
1293 void InstructionSelector::VisitFloat32Sub(Node* node) {
1295 Float32BinopMatcher m(node);
1297 Emit(kArmVnegF32, g.DefineAsRegister(node),
1298 g.UseRegister(m.right().node()));
1301 VisitFloat32SubHelper(this, node);
1304 void InstructionSelector::VisitFloat32SubPreserveNan(Node* node) {
1305 VisitFloat32SubHelper(this, node);
1308 void InstructionSelector::VisitFloat64Sub(Node* node) {
1310 Float64BinopMatcher m(node);
1313 CanCover(m.node(), m.right().node())) {
1315 CanCover(m.right().node(), m.right().InputAt(0))) {
1318 Emit(kArmVrintpF64, g.DefineAsRegister(node),
1319 g.UseRegister(mright0.right().node()));
1324 Emit(kArmVnegF64, g.DefineAsRegister(node),
1325 g.UseRegister(m.right().node()));
1328 VisitFloat64SubHelper(this, node);
1331 void InstructionSelector::VisitFloat64SubPreserveNan(Node* node) {
1332 VisitFloat64SubHelper(this, node);
1335 void InstructionSelector::VisitFloat32Mul(Node* node) {
1336 VisitRRR(this, kArmVmulF32, node);
1340 void InstructionSelector::VisitFloat64Mul(Node* node) {
1341 VisitRRR(this, kArmVmulF64, node);
1345 void InstructionSelector::VisitFloat32Div(Node* node) {
1346 VisitRRR(this, kArmVdivF32, node);
1350 void InstructionSelector::VisitFloat64Div(Node* node) {
1351 VisitRRR(this, kArmVdivF64, node);
1355 void InstructionSelector::VisitFloat64Mod(Node* node) {
1357 Emit(kArmVmodF64, g.DefineAsFixed(node, d0), g.UseFixed(node->InputAt(0), d0),
1358 g.UseFixed(node->InputAt(1), d1))->MarkAsCall();
1361 void InstructionSelector::VisitFloat32Max(Node* node) {
1363 VisitRRR(this, kArmFloat32Max, node);
1366 void InstructionSelector::VisitFloat64Max(Node* node) {
1368 VisitRRR(this, kArmFloat64Max, node);
1371 void InstructionSelector::VisitFloat64SilenceNaN(Node* node) {
1372 VisitRR(this, kArmFloat64SilenceNaN, node);
1375 void InstructionSelector::VisitFloat32Min(Node* node) {
1377 VisitRRR(this, kArmFloat32Min, node);
1380 void InstructionSelector::VisitFloat64Min(Node* node) {
1382 VisitRRR(this, kArmFloat64Min, node);
1385 void InstructionSelector::VisitFloat32Abs(Node* node) {
1386 VisitRR(this, kArmVabsF32, node);
1390 void InstructionSelector::VisitFloat64Abs(Node* node) {
1391 VisitRR(this, kArmVabsF64, node);
1394 void InstructionSelector::VisitFloat32Sqrt(Node* node) {
1395 VisitRR(this, kArmVsqrtF32, node);
1399 void InstructionSelector::VisitFloat64Sqrt(Node* node) {
1400 VisitRR(this, kArmVsqrtF64, node);
1404 void InstructionSelector::VisitFloat32RoundDown(Node* node) {
1405 VisitRR(this, kArmVrintmF32, node);
1409 void InstructionSelector::VisitFloat64RoundDown(Node* node) {
1410 VisitRR(this, kArmVrintmF64, node);
1414 void InstructionSelector::VisitFloat32RoundUp(Node* node) {
1415 VisitRR(this, kArmVrintpF32, node);
1419 void InstructionSelector::VisitFloat64RoundUp(Node* node) {
1420 node);
1424 void InstructionSelector::VisitFloat32RoundTruncate(Node* node) {
1425 VisitRR(this, kArmVrintzF32, node);
1429 void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
1430 VisitRR(this, kArmVrintzF64, node);
1434 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
1435 VisitRR(this, kArmVrintaF64, node);
1439 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) {
1440 VisitRR(this, kArmVrintnF32, node);
1444 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) {
1445 VisitRR(this, kArmVrintnF64, node);
1448 void InstructionSelector::VisitFloat32Neg(Node* node) {
1449 VisitRR(this, kArmVnegF32, node);
1452 void InstructionSelector::VisitFloat64Neg(Node* node) {
1453 VisitRR(this, kArmVnegF64, node);
1456 void InstructionSelector::VisitFloat64Ieee754Binop(Node* node,
1459 Emit(opcode, g.DefineAsFixed(node, d0), g.UseFixed(node->InputAt(0), d0),
1460 g.UseFixed(node->InputAt(1), d1))
1464 void InstructionSelector::VisitFloat64Ieee754Unop(Node* node,
1467 Emit(opcode, g.DefineAsFixed(node, d0), g.UseFixed(node->InputAt(0), d0))
1473 Node* node) {
1485 if (input.node()) {
1488 g.UseRegister(input.node()));
1495 if (input.node() == nullptr) continue;
1496 Emit(kArmPush, g.NoOutput(), g.UseRegister(input.node()));
1528 void VisitFloat32Compare(InstructionSelector* selector, Node* node,
1531 Float32BinopMatcher m(node);
1533 VisitCompare(selector, kArmVcmpF32, g.UseRegister(m.left().node()),
1534 g.UseImmediate(m.right().node()), cont);
1537 VisitCompare(selector, kArmVcmpF32, g.UseRegister(m.right().node()),
1538 g.UseImmediate(m.left().node()), cont);
1540 VisitCompare(selector, kArmVcmpF32, g.UseRegister(m.left().node()),
1541 g.UseRegister(m.right().node()), cont);
1547 void VisitFloat64Compare(InstructionSelector* selector, Node* node,
1550 Float64BinopMatcher m(node);
1552 VisitCompare(selector, kArmVcmpF64, g.UseRegister(m.left().node()),
1553 g.UseImmediate(m.right().node()), cont);
1556 VisitCompare(selector, kArmVcmpF64, g.UseRegister(m.right().node()),
1557 g.UseImmediate(m.left().node()), cont);
1559 VisitCompare(selector, kArmVcmpF64, g.UseRegister(m.left().node()),
1560 g.UseRegister(m.right().node()), cont);
1566 void VisitWordCompare(InstructionSelector* selector, Node* node,
1569 Int32BinopMatcher m(node);
1575 if (TryMatchImmediateOrShift(selector, &opcode, m.right().node(),
1577 inputs[0] = g.UseRegister(m.left().node());
1579 } else if (TryMatchImmediateOrShift(selector, &opcode, m.left().node(),
1581 if (!node->op()->HasProperty(Operator::kCommutative)) cont->Commute();
1582 inputs[0] = g.UseRegister(m.right().node());
1586 inputs[input_count++] = g.UseRegister(m.left().node());
1587 inputs[input_count++] = g.UseRegister(m.right().node());
1611 void VisitWordCompare(InstructionSelector* selector, Node* node,
1613 VisitWordCompare(selector, node, kArmCmp, cont);
1618 void VisitWordCompareZero(InstructionSelector* selector, Node* user,
1619 Node* value, FlagsContinuation* cont) {
1628 value = m.left().node();
1667 // <Operation>WithOverflow node.
1674 Node* const node = value->InputAt(0);
1675 Node* const result = NodeProperties::FindProjection(node, 0);
1677 switch (node->opcode()) {
1680 return VisitBinop(selector, node, kArmAdd, kArmAdd, cont);
1683 return VisitBinop(selector, node, kArmSub, kArmRsb, cont);
1734 void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
1740 void InstructionSelector::VisitDeoptimizeIf(Node* node) {
1742 FlagsContinuation::ForDeoptimize(kNotEqual, node->InputAt(1));
1743 VisitWordCompareZero(this, node, node->InputAt(0), &cont);
1746 void InstructionSelector::VisitDeoptimizeUnless(Node* node) {
1748 FlagsContinuation::ForDeoptimize(kEqual, node->InputAt(1));
1749 VisitWordCompareZero(this, node, node->InputAt(0), &cont);
1752 void InstructionSelector::VisitSwitch(Node* node, const SwitchInfo& sw) {
1754 InstructionOperand value_operand = g.UseRegister(node->InputAt(0));
1780 void InstructionSelector::VisitWord32Equal(Node* const node) {
1781 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1782 Int32BinopMatcher m(node);
1784 return VisitWordCompareZero(this, m.node(), m.left().node(), &cont);
1786 VisitWordCompare(this, node, &cont);
1790 void InstructionSelector::VisitInt32LessThan(Node* node) {
1791 FlagsContinuation cont = FlagsContinuation::ForSet(kSignedLessThan, node);
1792 VisitWordCompare(this, node, &cont);
1796 void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
1798 FlagsContinuation::ForSet(kSignedLessThanOrEqual, node);
1799 VisitWordCompare(this, node, &cont);
1803 void InstructionSelector::VisitUint32LessThan(Node* node) {
1804 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1805 VisitWordCompare(this, node, &cont);
1809 void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
1811 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1812 VisitWordCompare(this, node, &cont);
1816 void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
1817 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1819 return VisitBinop(this, node, kArmAdd, kArmAdd, &cont);
1822 VisitBinop(this, node, kArmAdd, kArmAdd, &cont);
1826 void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
1827 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1829 return VisitBinop(this, node, kArmSub, kArmRsb, &cont);
1832 VisitBinop(this, node, kArmSub, kArmRsb, &cont);
1836 void InstructionSelector::VisitFloat32Equal(Node* node) {
1837 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1838 VisitFloat32Compare(this, node, &cont);
1842 void InstructionSelector::VisitFloat32LessThan(Node* node) {
1843 FlagsContinuation cont = FlagsContinuation::ForSet(kFloatLessThan, node);
1844 VisitFloat32Compare(this, node, &cont);
1848 void InstructionSelector::VisitFloat32LessThanOrEqual(Node* node) {
1850 FlagsContinuation::ForSet(kFloatLessThanOrEqual, node);
1851 VisitFloat32Compare(this, node, &cont);
1855 void InstructionSelector::VisitFloat64Equal(Node* node) {
1856 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1857 VisitFloat64Compare(this, node, &cont);
1861 void InstructionSelector::VisitFloat64LessThan(Node* node) {
1862 FlagsContinuation cont = FlagsContinuation::ForSet(kFloatLessThan, node);
1863 VisitFloat64Compare(this, node, &cont);
1867 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
1869 FlagsContinuation::ForSet(kFloatLessThanOrEqual, node);
1870 node, &cont);
1874 void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) {
1875 VisitRR(this, kArmVmovLowU32F64, node);
1879 void InstructionSelector::VisitFloat64ExtractHighWord32(Node* node) {
1880 VisitRR(this, kArmVmovHighU32F64, node);
1884 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) {
1886 Node* left = node->InputAt(0);
1887 Node* right = node->InputAt(1);
1889 CanCover(node, left)) {
1891 Emit(kArmVmovF64U32U32, g.DefineAsRegister(node), g.UseRegister(right),
1895 Emit(kArmVmovLowF64U32, g.DefineSameAsFirst(node), g.UseRegister(left),
1900 void InstructionSelector::VisitFloat64InsertHighWord32(Node* node) {
1902 Node* left = node->InputAt(0);
1903 Node* right = node->InputAt(1);
1905 CanCover(node, left)) {
1907 Emit(kArmVmovF64U32U32, g.DefineAsRegister(node), g.UseRegister(left),
1911 Emit(kArmVmovHighF64U32, g.DefineSameAsFirst(node), g.UseRegister(left),
1915 void InstructionSelector::VisitAtomicLoad(Node* node) {
1916 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
1918 Node* base = node->InputAt(0);
1919 Node* index = node->InputAt(1);
1936 g.DefineAsRegister(node), g.UseRegister(base), g.UseRegister(index));
1939 void InstructionSelector::VisitAtomicStore(Node* node) {
1940 MachineRepresentation rep = AtomicStoreRepresentationOf(node->op());
1942 Node* base = node->InputAt(0);
1943 Node* index = node->InputAt(1);
1944 Node* value = node->InputAt(2);
