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);
34 bool CanBeImmediate(Node* node) {
35 switch (node->opcode()) {
43 Handle<HeapObject> value = OpParameter<Handle<HeapObject>>(node);
52 AddressingMode GenerateMemoryOperandInputs(Node* index, int scale, Node* base,
53 Node* displacement_node,
111 AddressingMode GetEffectiveAddressMemoryOperand(Node* node,
114 BaseWithIndexAndDisplacement32Matcher m(node, true);
120 inputs[(*input_count)++] = UseRegister(node->InputAt(0));
121 inputs[(*input_count)++] = UseRegister(node->InputAt(1));
126 bool CanBeBetterLeftOperand(Node* node) const {
127 return !selector()->IsLive(node);
132 void InstructionSelector::VisitLoad(Node* node) {
133 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
162 outputs[0] = g.DefineAsRegister(node);
166 g.GetEffectiveAddressMemoryOperand(node, inputs, &input_count);
172 void InstructionSelector::VisitStore(Node* node) {
174 Node* base = node->InputAt(0);
175 Node* index = node->InputAt(1);
176 Node* value = node->InputAt(2);
178 StoreRepresentation store_rep = StoreRepresentationOf(node->op());
258 g.GetEffectiveAddressMemoryOperand(node, inputs, &input_count);
268 void InstructionSelector::VisitCheckedLoad(Node* node) {
269 CheckedLoadRepresentation load_rep = CheckedLoadRepresentationOf(node->op());
271 Node* const buffer = node->InputAt(0);
272 Node* const offset = node->InputAt(1);
273 Node* const length = node->InputAt(2);
303 g.DefineAsRegister(node), offset_operand, length_operand,
307 g.DefineAsRegister(node), offset_operand, length_operand,
313 void InstructionSelector::VisitCheckedStore(Node* node) {
314 MachineRepresentation rep = CheckedStoreRepresentationOf(node->op());
316 Node* const buffer = node->InputAt(0);
317 Node* const offset = node->InputAt(1);
318 Node* const length = node->InputAt(2);
319 Node* const value = node->InputAt(3);
366 static void VisitBinop(InstructionSelector* selector, Node* node,
369 Int32BinopMatcher m(node);
370 Node* left = m.left().node();
371 Node* right = m.right().node();
393 if (node->op()->HasProperty(Operator::kCommutative) &&
406 outputs[output_count++] = g.DefineSameAsFirst(node);
422 static void VisitBinop(InstructionSelector* selector, Node* node,
425 VisitBinop(selector, node, opcode, &cont);
429 void InstructionSelector::VisitWord32And(Node* node) {
430 VisitBinop(this, node, kX87And);
434 void InstructionSelector::VisitWord32Or(Node* node) {
435 VisitBinop(this, node, kX87Or);
439 void InstructionSelector::VisitWord32Xor(Node* node) {
441 Int32BinopMatcher m(node);
443 Emit(kX87Not, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()));
445 VisitBinop(this, node, kX87Xor);
451 static inline void VisitShift(InstructionSelector* selector, Node* node,
454 Node* left = node->InputAt(0);
455 Node* right = node->InputAt(1);
458 selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
461 selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
469 Node* node,
472 selector->Emit(opcode, g.DefineAsFixed(node, edx),
473 g.UseFixed(node->InputAt(0), eax),
474 g.UseUniqueRegister(node->InputAt(1)));
478 void VisitDiv(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
481 selector->Emit(opcode, g.DefineAsFixed(node, eax),
482 g.UseFixed(node->InputAt(0), eax),
483 g.UseUnique(node->InputAt(1)), arraysize(temps), temps);
487 void VisitMod(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
489 selector->Emit(opcode, g.DefineAsFixed(node, edx),
490 g.UseFixed(node->InputAt(0), eax),
491 g.UseUnique(node->InputAt(1)));
494 void EmitLea(InstructionSelector* selector, Node* result, Node* index,
495 int scale, Node* base, Node* displacement) {
516 void InstructionSelector::VisitWord32Shl(Node* node) {
517 Int32ScaleMatcher m(node, true);
519 Node* index = node->InputAt(0);
520 Node* base = m.power_of_two_plus_one() ? index : nullptr;
521 EmitLea(this, node, index, m.scale(), base, nullptr);
524 VisitShift(this, node, kX87Shl);
528 void InstructionSelector::VisitWord32Shr(Node* node) {
529 VisitShift(this, node, kX87Shr);
533 void InstructionSelector::VisitWord32Sar(Node* node) {
534 VisitShift(this, node, kX87Sar);
538 void InstructionSelector::VisitWord32Ror(Node* node) {
539 VisitShift(this, node, kX87Ror);
543 void InstructionSelector::VisitWord32Clz(Node* node) {
545 Emit(kX87Lzcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
549 void InstructionSelector::VisitWord32Ctz(Node* node) { UNREACHABLE(); }
552 void InstructionSelector::VisitWord32Popcnt(Node* node) {
554 Emit(kX87Popcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
558 void InstructionSelector::VisitInt32Add(Node* node) {
562 BaseWithIndexAndDisplacement32Matcher m(node);
574 outputs[0] = g.DefineAsRegister(node);
582 VisitBinop(this, node, kX87Add);
586 void InstructionSelector::VisitInt32Sub(Node* node) {
588 Int32BinopMatcher m(node);
590 Emit(kX87Neg, g.DefineSameAsFirst(node), g.Use(m.right().node()));
592 VisitBinop(this, node, kX87Sub);
597 void InstructionSelector::VisitInt32Mul(Node* node) {
598 Int32ScaleMatcher m(node, true);
600 Node* index = node->InputAt(0);
601 Node* base = m.power_of_two_plus_one() ? index : nullptr;
602 EmitLea(this, node, index, m.scale(), base, nullptr);
606 Node* left = node->InputAt(0);
607 Node* right = node->InputAt(1);
609 Emit(kX87Imul, g.DefineAsRegister(node), g.Use(left),
615 Emit(kX87Imul, g.DefineSameAsFirst(node), g.UseRegister(left),
621 void InstructionSelector::VisitInt32MulHigh(Node* node) {
622 VisitMulHigh(this, node, kX87ImulHigh);
626 void InstructionSelector::VisitUint32MulHigh(Node* node) {
627 VisitMulHigh(this, node, kX87UmulHigh);
631 void InstructionSelector::VisitInt32Div(Node* node) {
632 VisitDiv(this, node, kX87Idiv);
636 void InstructionSelector::VisitUint32Div(Node* node) {
637 VisitDiv(this, node, kX87Udiv);
641 void InstructionSelector::VisitInt32Mod(Node* node) {
642 VisitMod(this, node, kX87Idiv);
646 void InstructionSelector::VisitUint32Mod(Node* node) {
647 VisitMod(this, node, kX87Udiv);
651 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
653 Emit(kX87Float32ToFloat64, g.DefineAsFixed(node, stX_0),
654 g.Use(node->InputAt(0)));
658 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) {
660 Emit(kX87Int32ToFloat64, g.DefineAsFixed(node, stX_0),
661 g.Use(node->InputAt(0)));
665 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
667 Emit(kX87Uint32ToFloat64, g.DefineAsFixed(node, stX_0),
668 g.UseRegister(node->InputAt(0)));
672 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) {
674 Emit(kX87Float64ToInt32, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
678 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) {
680 Emit(kX87Float64ToUint32, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
684 void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
686 Emit(kX87Float64ToFloat32, g.DefineAsFixed(node, stX_0),
687 g.Use(node->InputAt(0)));
691 void InstructionSelector::VisitTruncateFloat64ToInt32(Node* node) {
694 switch (TruncationModeOf(node->op())) {
696 Emit(kArchTruncateDoubleToI, g.DefineAsRegister(node),
697 g.Use(node->InputAt(0)));
700 Emit(kX87Float64ToInt32, g.DefineAsRegister(node),
701 g.Use(node->InputAt(0)));
708 void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) {
710 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(0)));
711 Emit(kX87BitcastFI, g.DefineAsRegister(node), 0, nullptr);
715 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) {
717 Emit(kX87BitcastIF, g.DefineAsFixed(node, stX_0), g.Use(node->InputAt(0)));
721 void InstructionSelector::VisitFloat32Add(Node* node) {
723 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(0)));
724 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(1)));
725 Emit(kX87Float32Add, g.DefineAsFixed(node, stX_0), 0, nullptr);
729 void InstructionSelector::VisitFloat64Add(Node* node) {
731 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(0)));
732 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(1)));
733 Emit(kX87Float64Add, g.DefineAsFixed(node, stX_0), 0, nullptr);
737 void InstructionSelector::VisitFloat32Sub(Node* node) {
739 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(0)));
740 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(1)));
741 Emit(kX87Float32Sub, g.DefineAsFixed(node, stX_0), 0, nullptr);
745 void InstructionSelector::VisitFloat64Sub(Node* node) {
747 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(0)));
748 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(1)));
749 Emit(kX87Float64Sub, g.DefineAsFixed(node, stX_0), 0, nullptr);
753 void InstructionSelector::VisitFloat32Mul(Node* node) {
755 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(0)));
756 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(1)));
757 Emit(kX87Float32Mul, g.DefineAsFixed(node, stX_0), 0, nullptr);
761 void InstructionSelector::VisitFloat64Mul(Node* node) {
763 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(0)));
764 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(1)));
765 Emit(kX87Float64Mul, g.DefineAsFixed(node, stX_0), 0, nullptr);
769 void InstructionSelector::VisitFloat32Div(Node* node) {
771 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(0)));
772 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(1)));
773 Emit(kX87Float32Div, g.DefineAsFixed(node, stX_0), 0, nullptr);
777 void InstructionSelector::VisitFloat64Div(Node* node) {
779 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(0)));
780 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(1)));
781 Emit(kX87Float64Div, g.DefineAsFixed(node, stX_0), 0, nullptr);
785 void InstructionSelector::VisitFloat64Mod(Node* node) {
788 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(0)));
789 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(1)));
790 Emit(kX87Float64Mod, g.DefineAsFixed(node, stX_0), 1, temps)->MarkAsCall();
794 void InstructionSelector::VisitFloat32Max(Node* node) {
796 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(0)));
797 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(1)));
798 Emit(kX87Float32Max, g.DefineAsFixed(node, stX_0), 0, nullptr);
802 void InstructionSelector::VisitFloat64Max(Node* node) {
804 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(0)));
805 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(1)));
806 Emit(kX87Float64Max, g.DefineAsFixed(node, stX_0), 0, nullptr);
810 void InstructionSelector::VisitFloat32Min(Node* node) {
812 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(0)));
813 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(1)));
814 Emit(kX87Float32Min, g.DefineAsFixed(node, stX_0), 0, nullptr);
818 void InstructionSelector::VisitFloat64Min(Node* node) {
820 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(0)));
821 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(1)));
822 Emit(kX87Float64Min, g.DefineAsFixed(node, stX_0), 0, nullptr);
826 void InstructionSelector::VisitFloat32Abs(Node* node) {
828 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(0)));
829 Emit(kX87Float32Abs, g.DefineAsFixed(node, stX_0), 0, nullptr);
833 void InstructionSelector::VisitFloat64Abs(Node* node) {
835 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(0)));
836 Emit(kX87Float64Abs, g.DefineAsFixed(node, stX_0), 0, nullptr);
840 void InstructionSelector::VisitFloat32Sqrt(Node* node) {
842 Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(0)));
843 Emit(kX87Float32Sqrt, g.DefineAsFixed(node, stX_0), 0, nullptr);
847 void InstructionSelector::VisitFloat64Sqrt(Node* node) {
849 Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(0)));
850 Emit(kX87Float64Sqrt, g.DefineAsFixed(node, stX_0), 0, nullptr);
854 void InstructionSelector::VisitFloat32RoundDown(Node* node) {
857 g.UseFixed(node, stX_0), g.Use(node->InputAt(0)));
861 void InstructionSelector::VisitFloat64RoundDown(Node* node) {
864 g.UseFixed(node, stX_0), g.Use(node->InputAt(0)));
868 void InstructionSelector::VisitFloat32RoundUp(Node* node) {
870 Emit(kX87Float32Round | MiscField::encode(kRoundUp), g.UseFixed(node, stX_0),
871 g.Use(node->InputAt(0)));
875 void InstructionSelector::VisitFloat64RoundUp(Node* node) {
877 Emit(kX87Float64Round | MiscField::encode(kRoundUp), g.UseFixed(node, stX_0),
878 g.Use(node->InputAt(0)));
882 void InstructionSelector::VisitFloat32RoundTruncate(Node* node) {
885 g.UseFixed(node, stX_0), g.Use(node->InputAt(0)));
889 void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
892 g.UseFixed(node, stX_0), g.Use(node->InputAt(0)));
896 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
901 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) {
904 g.UseFixed(node, stX_0), g.Use(node->InputAt(0)));
908 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) {
911 g.UseFixed(node, stX_0), g.Use(node->InputAt(0)));
917 Node* node) {
931 if (input.node()) {
933 InstructionOperand value = g.CanBeImmediate(input.node())
934 ? g.UseImmediate(input.node())
935 : g.UseRegister(input.node());
943 if (input.node() == nullptr) continue;
945 g.CanBeImmediate(input.node())
946 ? g.UseImmediate(input.node())
948 sequence()->IsFloat(GetVirtualRegister(input.node()))
949 ? g.UseRegister(input.node())
950 : g.Use(input.node());
980 Node* left, Node* right, FlagsContinuation* cont,
991 void VisitFloat32Compare(InstructionSelector* selector, Node* node,
994 node->InputAt(0)));
995 selector->Emit(kX87PushFloat32, g.NoOutput(), g.Use(node->InputAt(1)));
1008 void VisitFloat64Compare(InstructionSelector* selector, Node* node,
1011 selector->Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(0)));
1012 selector->Emit(kX87PushFloat64, g.NoOutput(), g.Use(node->InputAt(1)));
1025 void VisitWordCompare(InstructionSelector* selector, Node* node,
1028 Node* const left = node->InputAt(0);
1029 Node* const right = node->InputAt(1);
1035 if (!node->op()->HasProperty(Operator::kCommutative)) cont->Commute();
1039 node->op()->HasProperty(Operator::kCommutative));
1044 void VisitWordCompare(InstructionSelector* selector, Node* node,
1047 Int32BinopMatcher m(node);
1049 LoadMatcher<ExternalReferenceMatcher> mleft(m.left().node());
1054 if (!node->op()->HasProperty(Operator::kCommutative)) cont->Commute();
1066 VisitWordCompare(selector, node, kX87Cmp, cont);
1071 void VisitWordCompareZero(InstructionSelector* selector, Node* user,
1072 Node* value, FlagsContinuation* cont) {
1082 value = m.left().node();
1121 // <Operation>WithOverflow node.
1128 Node* const node = value->InputAt(0);
1129 Node* const result = NodeProperties::FindProjection(node, 0);
1131 switch (node->opcode()) {
1134 return VisitBinop(selector, node, kX87Add, cont);
1137 return VisitBinop(selector, node, kX87Sub, cont);
1162 void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
1169 void InstructionSelector::VisitSwitch(Node* node, const SwitchInfo& sw) {
1171 InstructionOperand value_operand = g.UseRegister(node->InputAt(0));
1197 void InstructionSelector::VisitWord32Equal(Node* const node) {
1198 FlagsContinuation cont(kEqual, node);
1199 Int32BinopMatcher m(node);
1201 return VisitWordCompareZero(this, m.node(), m.left().node(), &cont);
1203 VisitWordCompare(this, node, &cont);
1207 void InstructionSelector::VisitInt32LessThan(Node* node) {
1208 FlagsContinuation cont(kSignedLessThan, node);
1209 VisitWordCompare(this, node, &cont);
1213 void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
1214 FlagsContinuation cont(kSignedLessThanOrEqual, node);
1215 VisitWordCompare(this, node, &cont);
1219 void InstructionSelector::VisitUint32LessThan(Node* node) {
1220 FlagsContinuation cont(kUnsignedLessThan, node);
1221 VisitWordCompare(this, node, &cont);
1225 void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
1226 FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
1227 VisitWordCompare(this, node, &cont);
1231 void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
1232 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1234 return VisitBinop(this, node, kX87Add, &cont);
1237 VisitBinop(this, node, kX87Add, &cont);
1241 void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
1242 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1244 return VisitBinop(this, node, kX87Sub, &cont);
1247 VisitBinop(this, node, kX87Sub, &cont);
1251 void InstructionSelector::VisitFloat32Equal(Node* node) {
1252 FlagsContinuation cont(kUnorderedEqual, node);
1253 VisitFloat32Compare(this, node, &cont);
1257 void InstructionSelector::VisitFloat32LessThan(Node* node) {
1258 FlagsContinuation cont(kUnsignedGreaterThan, node);
1259 VisitFloat32Compare(this, node, &cont);
1263 void InstructionSelector::VisitFloat32LessThanOrEqual(Node* node) {
1264 FlagsContinuation cont(kUnsignedGreaterThanOrEqual, node);
1265 VisitFloat32Compare(this, node, &cont);
1269 void InstructionSelector::VisitFloat64Equal(Node* node) {
1270 FlagsContinuation cont(kUnorderedEqual, node);
1271 VisitFloat64Compare(this, node, &cont);
1275 void InstructionSelector::VisitFloat64LessThan(Node* node) {
1276 FlagsContinuation cont(kUnsignedGreaterThan, node);
1277 VisitFloat64Compare(this, node, &cont);
1281 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
1282 FlagsContinuation cont(kUnsignedGreaterThanOrEqual, node);
1283 VisitFloat64Compare(this, node, &cont);
1287 void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) {
1289 Emit(kX87Float64ExtractLowWord32, g.DefineAsRegister(node),
1290 g.Use(node->InputAt(0)));
1294 void InstructionSelector::VisitFloat64ExtractHighWord32(Node* node) {
1296 Emit(kX87Float64ExtractHighWord32, g.DefineAsRegister(node),
1297 g.Use(node->InputAt(0)));
1301 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) {
1303 Node* left = node->InputAt(0);
1304 Node* right = node->InputAt(1);
1305 Emit(kX87Float64InsertLowWord32, g.UseFixed(node, stX_0), g.UseRegister(left),
1310 void InstructionSelector::VisitFloat64InsertHighWord32(Node* node) {
1312 Node* left = node->InputAt(0);
1313 Node* right = node->InputAt(1);
1314 Emit(kX87Float64InsertHighWord32, g.UseFixed(node, stX_0),
