Lines Matching refs:Node
7 #include "src/compiler/node-matchers.h"
8 #include "src/compiler/node-properties.h"
20 InstructionOperand UseByteRegister(Node* node) {
22 return UseFixed(node, edx);
25 InstructionOperand DefineAsByteRegister(Node* node) {
27 return DefineAsRegister(node);
30 bool CanBeImmediate(Node* node) {
31 switch (node->opcode()) {
39 Handle<HeapObject> value = OpParameter<Handle<HeapObject>>(node);
48 AddressingMode GenerateMemoryOperandInputs(Node* index, int scale, Node* base,
49 Node* displacement_node,
107 AddressingMode GetEffectiveAddressMemoryOperand(Node* node,
110 BaseWithIndexAndDisplacement32Matcher m(node, true);
116 inputs[(*input_count)++] = UseRegister(node->InputAt(0));
117 inputs[(*input_count)++] = UseRegister(node->InputAt(1));
122 bool CanBeBetterLeftOperand(Node* node) const {
123 return !selector()->IsLive(node);
130 void VisitRO(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
132 selector->Emit(opcode, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
136 void VisitRR(InstructionSelector* selector, Node* node,
139 selector->Emit(opcode, g.DefineAsRegister(node),
140 g.UseRegister(node->InputAt(0)));
144 void VisitRROFloat(InstructionSelector* selector, Node* node,
147 InstructionOperand operand0 = g.UseRegister(node->InputAt(0));
148 InstructionOperand operand1 = g.Use(node->InputAt(1));
150 selector->Emit(avx_opcode, g.DefineAsRegister(node), operand0, operand1);
152 selector->Emit(sse_opcode, g.DefineSameAsFirst(node), operand0, operand1);
157 void VisitFloatUnop(InstructionSelector* selector, Node* node, Node* input,
161 selector->Emit(avx_opcode, g.DefineAsRegister(node), g.Use(input));
163 selector->Emit(sse_opcode, g.DefineSameAsFirst(node), g.UseRegister(input));
171 void InstructionSelector::VisitLoad(Node* node) {
172 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
201 outputs[0] = g.DefineAsRegister(node);
205 g.GetEffectiveAddressMemoryOperand(node, inputs, &input_count);
211 void InstructionSelector::VisitStore(Node* node) {
213 Node* base = node->InputAt(0);
214 Node* index = node->InputAt(1);
215 Node* value = node->InputAt(2);
217 StoreRepresentation store_rep = StoreRepresentationOf(node->op());
297 g.GetEffectiveAddressMemoryOperand(node, inputs, &input_count);
307 void InstructionSelector::VisitCheckedLoad(Node* node) {
308 CheckedLoadRepresentation load_rep = CheckedLoadRepresentationOf(node->op());
310 Node* const buffer = node->InputAt(0);
311 Node* const offset = node->InputAt(1);
312 Node* const length = node->InputAt(2);
342 g.DefineAsRegister(node), offset_operand, length_operand,
346 g.DefineAsRegister(node), offset_operand, length_operand,
352 void InstructionSelector::VisitCheckedStore(Node* node) {
353 MachineRepresentation rep = CheckedStoreRepresentationOf(node->op());
355 Node* const buffer = node->InputAt(0);
356 Node* const offset = node->InputAt(1);
357 Node* const length = node->InputAt(2);
358 Node* const value = node->InputAt(3);
405 static void VisitBinop(InstructionSelector* selector, Node* node,
408 Int32BinopMatcher m(node);
409 Node* left = m.left().node();
410 Node* right = m.right().node();
432 if (node->op()->HasProperty(Operator::kCommutative) &&
445 outputs[output_count++] = g.DefineSameAsFirst(node);
461 static void VisitBinop(InstructionSelector* selector, Node* node,
464 VisitBinop(selector, node, opcode, &cont);
468 void InstructionSelector::VisitWord32And(Node* node) {
469 VisitBinop(this, node, kIA32And);
473 void InstructionSelector::VisitWord32Or(Node* node) {
474 VisitBinop(this, node, kIA32Or);
478 void InstructionSelector::VisitWord32Xor(Node* node) {
480 Int32BinopMatcher m(node);
482 Emit(kIA32Not, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()));
484 VisitBinop(this, node, kIA32Xor);
490 static inline void VisitShift(InstructionSelector* selector, Node* node,
493 Node* left = node->InputAt(0);
494 Node* right = node->InputAt(1);
497 selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
500 selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
508 void VisitMulHigh(InstructionSelector* selector, Node* node,
511 selector->Emit(opcode, g.DefineAsFixed(node, edx),
512 g.UseFixed(node->InputAt(0), eax),
513 g.UseUniqueRegister(node->InputAt(1)));
517 void VisitDiv(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
520 selector->Emit(opcode, g.DefineAsFixed(node, eax),
521 g.UseFixed(node->InputAt(0), eax),
522 g.UseUnique(node->InputAt(1)), arraysize(temps), temps);
526 void VisitMod(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
528 selector->Emit(opcode, g.DefineAsFixed(node, edx),
529 g.UseFixed(node->InputAt(0), eax),
530 g.UseUnique(node->InputAt(1)));
533 void EmitLea(InstructionSelector* selector, Node* result, Node* index,
534 int scale, Node* base, Node* displacement) {
555 void InstructionSelector::VisitWord32Shl(Node* node) {
556 Int32ScaleMatcher m(node, true);
558 Node* index = node->InputAt(0);
559 Node* base = m.power_of_two_plus_one() ? index : nullptr;
560 EmitLea(this, node, index, m.scale(), base, nullptr);
563 VisitShift(this, node, kIA32Shl);
567 void InstructionSelector::VisitWord32Shr(Node* node) {
568 VisitShift(this, node, kIA32Shr);
572 void InstructionSelector::VisitWord32Sar(Node* node) {
573 VisitShift(this, node, kIA32Sar);
577 void InstructionSelector::VisitWord32Ror(Node* node) {
578 VisitShift(this, node, kIA32Ror);
582 void InstructionSelector::VisitWord32Clz(Node* node) {
584 Emit(kIA32Lzcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
588 void InstructionSelector::VisitWord32Ctz(Node* node) {
590 Emit(kIA32Tzcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
594 void InstructionSelector::VisitWord32Popcnt(Node* node) {
596 Emit(kIA32Popcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
600 void InstructionSelector::VisitInt32Add(Node* node) {
604 BaseWithIndexAndDisplacement32Matcher m(node);
616 outputs[0] = g.DefineAsRegister(node);
624 VisitBinop(this, node, kIA32Add);
628 void InstructionSelector::VisitInt32Sub(Node* node) {
630 Int32BinopMatcher m(node);
632 Emit(kIA32Neg, g.DefineSameAsFirst(node), g.Use(m.right().node()));
634 VisitBinop(this, node, kIA32Sub);
639 void InstructionSelector::VisitInt32Mul(Node* node) {
640 Int32ScaleMatcher m(node, true);
642 Node* index = node->InputAt(0);
643 Node* base = m.power_of_two_plus_one() ? index : nullptr;
644 EmitLea(this, node, index, m.scale(), base, nullptr);
648 Node* left = node->InputAt(0);
649 Node* right = node->InputAt(1);
651 Emit(kIA32Imul, g.DefineAsRegister(node), g.Use(left),
657 Emit(kIA32Imul, g.DefineSameAsFirst(node), g.UseRegister(left),
663 void InstructionSelector::VisitInt32MulHigh(Node* node) {
664 VisitMulHigh(this, node, kIA32ImulHigh);
668 void InstructionSelector::VisitUint32MulHigh(Node* node) {
669 VisitMulHigh(this, node, kIA32UmulHigh);
673 void InstructionSelector::VisitInt32Div(Node* node) {
674 VisitDiv(this, node, kIA32Idiv);
678 void InstructionSelector::VisitUint32Div(Node* node) {
679 VisitDiv(this, node, kIA32Udiv);
683 void InstructionSelector::VisitInt32Mod(Node* node) {
684 VisitMod(this, node, kIA32Idiv);
688 void InstructionSelector::VisitUint32Mod(Node* node) {
689 VisitMod(this, node, kIA32Udiv);
693 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
694 VisitRO(this, node, kSSEFloat32ToFloat64);
698 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) {
699 VisitRO(this, node, kSSEInt32ToFloat64);
703 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
704 VisitRO(this, node, kSSEUint32ToFloat64);
708 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) {
709 VisitRO(this, node, kSSEFloat64ToInt32);
713 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) {
714 VisitRO(this, node, kSSEFloat64ToUint32);
718 void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
719 VisitRO(this, node, kSSEFloat64ToFloat32);
723 void InstructionSelector::VisitTruncateFloat64ToInt32(Node* node) {
724 switch (TruncationModeOf(node->op())) {
726 return VisitRR(this, node, kArchTruncateDoubleToI);
728 return VisitRO(this, node, kSSEFloat64ToInt32);
734 void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) {
736 Emit(kIA32BitcastFI, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
740 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) {
742 Emit(kIA32BitcastIF, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
746 void InstructionSelector::VisitFloat32Add(Node* node) {
747 VisitRROFloat(this, node, kAVXFloat32Add, kSSEFloat32Add);
751 void InstructionSelector::VisitFloat64Add(Node* node) {
752 VisitRROFloat(this, node, kAVXFloat64Add, kSSEFloat64Add);
756 void InstructionSelector::VisitFloat32Sub(Node* node) {
758 Float32BinopMatcher m(node);
760 VisitFloatUnop(this, node, m.right().node(), kAVXFloat32Neg,
764 VisitRROFloat(this, node, kAVXFloat32Sub, kSSEFloat32Sub);
768 void InstructionSelector::VisitFloat64Sub(Node* node) {
770 Float64BinopMatcher m(node);
773 CanCover(m.node(), m.right().node())) {
775 CanCover(m.right().node(), m.right().InputAt(0))) {
779 g.DefineAsRegister(node), g.UseRegister(mright0.right().node()));
784 VisitFloatUnop(this, node, m.right().node(), kAVXFloat64Neg,
788 VisitRROFloat(this, node, kAVXFloat64Sub, kSSEFloat64Sub);
792 void InstructionSelector::VisitFloat32Mul(Node* node) {
793 VisitRROFloat(this, node, kAVXFloat32Mul, kSSEFloat32Mul);
797 void InstructionSelector::VisitFloat64Mul(Node* node) {
798 VisitRROFloat(this, node, kAVXFloat64Mul, kSSEFloat64Mul);
802 void InstructionSelector::VisitFloat32Div(Node* node) {
803 VisitRROFloat(this, node, kAVXFloat32Div, kSSEFloat32Div);
807 void InstructionSelector::VisitFloat64Div(Node* node) {
808 VisitRROFloat(this, node, kAVXFloat64Div, kSSEFloat64Div);
812 void InstructionSelector::VisitFloat64Mod(Node* node) {
815 Emit(kSSEFloat64Mod, g.DefineSameAsFirst(node),
816 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)), 1,
821 void InstructionSelector::VisitFloat32Max(Node* node) {
822 VisitRROFloat(this, node, kAVXFloat32Max, kSSEFloat32Max);
826 void InstructionSelector::VisitFloat64Max(Node* node) {
827 VisitRROFloat(this, node, kAVXFloat64Max, kSSEFloat64Max);
831 void InstructionSelector::VisitFloat32Min(Node* node) {
832 VisitRROFloat(this, node, kAVXFloat32Min, kSSEFloat32Min);
836 void InstructionSelector::VisitFloat64Min(Node* node) {
837 VisitRROFloat(this, node, kAVXFloat64Min, kSSEFloat64Min);
841 void InstructionSelector::VisitFloat32Abs(Node* node) {
843 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat32Abs, kSSEFloat32Abs);
847 void InstructionSelector::VisitFloat64Abs(Node* node) {
849 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat64Abs, kSSEFloat64Abs);
853 void InstructionSelector::VisitFloat32Sqrt(Node* node) {
854 VisitRO(this, node, kSSEFloat32Sqrt);
858 void InstructionSelector::VisitFloat64Sqrt(Node* node) {
859 VisitRO(this, node, kSSEFloat64Sqrt);
863 void InstructionSelector::VisitFloat32RoundDown(Node* node) {
864 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundDown));
868 void InstructionSelector::VisitFloat64RoundDown(Node* node) {
869 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundDown));
873 void InstructionSelector::VisitFloat32RoundUp(Node* node) {
874 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundUp));
878 void InstructionSelector::VisitFloat64RoundUp(Node* node) {
879 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundUp));
883 void InstructionSelector::VisitFloat32RoundTruncate(Node* node) {
884 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundToZero));
888 void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
889 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundToZero));
893 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
898 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) {
899 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundToNearest));
903 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) {
904 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundToNearest));
910 Node* node) {
924 if (input.node()) {
926 InstructionOperand value = g.CanBeImmediate(node)
927 ? g.UseImmediate(input.node())
928 : g.UseRegister(input.node());
936 if (input.node() == nullptr) continue;
938 g.CanBeImmediate(input.node())
939 ? g.UseImmediate(input.node())
941 sequence()->IsFloat(GetVirtualRegister(input.node()))
942 ? g.UseRegister(input.node())
943 : g.Use(input.node());
979 Node* left, Node* right, FlagsContinuation* cont,
990 void VisitFloat32Compare(InstructionSelector* selector, Node* node,
992 Node* const left = node->InputAt(0);
993 Node* const right = node->InputAt(1);
999 void VisitFloat64Compare(InstructionSelector* selector, Node* node,
1001 Node* const left = node->InputAt(0);
1002 Node* const right = node->InputAt(1);
1008 void VisitWordCompare(InstructionSelector* selector, Node* node,
1011 Node* const left = node->InputAt(0);
1012 Node* const right = node->InputAt(1);
1018 if (!node
1022 node->op()->HasProperty(Operator::kCommutative));
1027 void VisitWordCompare(InstructionSelector* selector, Node* node,
1030 Int32BinopMatcher m(node);
1032 LoadMatcher<ExternalReferenceMatcher> mleft(m.left().node());
1037 if (!node->op()->HasProperty(Operator::kCommutative)) cont->Commute();
1049 VisitWordCompare(selector, node, kIA32Cmp, cont);
1054 void VisitWordCompareZero(InstructionSelector* selector, Node* user,
1055 Node* value, FlagsContinuation* cont) {
1065 value = m.left().node();
1104 // <Operation>WithOverflow node.
1111 Node* const node = value->InputAt(0);
1112 Node* const result = NodeProperties::FindProjection(node, 0);
1114 switch (node->opcode()) {
1117 return VisitBinop(selector, node, kIA32Add, cont);
1120 return VisitBinop(selector, node, kIA32Sub, cont);
1145 void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
1152 void InstructionSelector::VisitSwitch(Node* node, const SwitchInfo& sw) {
1154 InstructionOperand value_operand = g.UseRegister(node->InputAt(0));
1180 void InstructionSelector::VisitWord32Equal(Node* const node) {
1181 FlagsContinuation cont(kEqual, node);
1182 Int32BinopMatcher m(node);
1184 return VisitWordCompareZero(this, m.node(), m.left().node(), &cont);
1186 VisitWordCompare(this, node, &cont);
1190 void InstructionSelector::VisitInt32LessThan(Node* node) {
1191 FlagsContinuation cont(kSignedLessThan, node);
1192 VisitWordCompare(this, node, &cont);
1196 void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
1197 FlagsContinuation cont(kSignedLessThanOrEqual, node);
1198 VisitWordCompare(this, node, &cont);
1202 void InstructionSelector::VisitUint32LessThan(Node* node) {
1203 FlagsContinuation cont(kUnsignedLessThan, node);
1204 VisitWordCompare(this, node, &cont);
1208 void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
1209 FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
1210 VisitWordCompare(this, node, &cont);
1214 void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
1215 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1217 return VisitBinop(this, node, kIA32Add, &cont);
1220 VisitBinop(this, node, kIA32Add, &cont);
1224 void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
1225 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1227 return VisitBinop(this, node, kIA32Sub, &cont);
1230 VisitBinop(this, node, kIA32Sub, &cont);
1234 void InstructionSelector::VisitFloat32Equal(Node* node) {
1235 FlagsContinuation cont(kUnorderedEqual, node);
1236 VisitFloat32Compare(this, node, &cont);
1240 void InstructionSelector::VisitFloat32LessThan(Node* node) {
1241 FlagsContinuation cont(kUnsignedGreaterThan, node);
1242 VisitFloat32Compare(this, node, &cont);
1246 void InstructionSelector::VisitFloat32LessThanOrEqual(Node* node) {
1247 FlagsContinuation cont(kUnsignedGreaterThanOrEqual, node);
1248 VisitFloat32Compare(this, node, &cont);
1252 void InstructionSelector::VisitFloat64Equal(Node* node) {
1253 FlagsContinuation cont(kUnorderedEqual, node);
1254 VisitFloat64Compare(this, node, &cont);
1258 void InstructionSelector::VisitFloat64LessThan(Node* node) {
1259 FlagsContinuation cont(kUnsignedGreaterThan, node);
1260 VisitFloat64Compare(this, node, &cont);
1264 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
1265 FlagsContinuation cont(kUnsignedGreaterThanOrEqual, node);
1266 VisitFloat64Compare(this, node, &cont);
1270 void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) {
1272 Emit(kSSEFloat64ExtractLowWord32, g.DefineAsRegister(node),
1273 g.Use(node->InputAt(0)));
1277 void InstructionSelector::VisitFloat64ExtractHighWord32(Node* node) {
1279 Emit(kSSEFloat64ExtractHighWord32, g.DefineAsRegister(node),
1280 g.Use(node->InputAt(0)));
1284 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) {
1286 Node* left = node->InputAt(0);
1287 Node* right = node->InputAt(1);
1290 Emit(kSSEFloat64LoadLowWord32, g.DefineAsRegister(node), g.Use(right));
1293 Emit(kSSEFloat64InsertLowWord32, g.DefineSameAsFirst(node),
1298 void InstructionSelector::VisitFloat64InsertHighWord32(Node* node) {
1300 Node* left = node->InputAt(0);
1301 Node* right = node->InputAt(1);
1302 Emit(kSSEFloat64InsertHighWord32, g.DefineSameAsFirst(node),
