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 CanBeMemoryOperand(InstructionCode opcode, Node* node, Node* input,
33 !selector()->CanCover(node, input)) {
58 bool CanBeImmediate(Node* node) {
59 switch (node->opcode()) {
69 // information on the HeapConstant node already.
73 Handle<HeapObject> value = OpParameter<Handle<HeapObject>>(node);
83 AddressingMode GenerateMemoryOperandInputs(Node* index, int scale, Node* base,
84 Node* displacement_node,
142 AddressingMode GetEffectiveAddressMemoryOperand(Node* node,
145 BaseWithIndexAndDisplacement32Matcher m(node, true);
151 inputs[(*input_count)++] = UseRegister(node->InputAt(0));
152 inputs[(*input_count)++] = UseRegister(node->InputAt(1));
157 bool CanBeBetterLeftOperand(Node* node) const {
158 return !selector()->IsLive(node);
165 void VisitRO(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
167 selector->Emit(opcode, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
171 void VisitRR(InstructionSelector* selector, Node* node,
174 selector->Emit(opcode, g.DefineAsRegister(node),
175 g.UseRegister(node->InputAt(0)));
179 void VisitRROFloat(InstructionSelector* selector, Node* node,
182 InstructionOperand operand0 = g.UseRegister(node->InputAt(0));
183 InstructionOperand operand1 = g.Use(node->InputAt(1));
185 selector->Emit(avx_opcode, g.DefineAsRegister(node), operand0, operand1);
187 selector->Emit(sse_opcode, g.DefineSameAsFirst(node), operand0, operand1);
192 void VisitFloatUnop(InstructionSelector* selector, Node* node, Node* input,
196 selector->Emit(avx_opcode, g.DefineAsRegister(node), g.Use(input));
198 selector->Emit(sse_opcode, g.DefineSameAsFirst(node), g.UseRegister(input));
206 void InstructionSelector::VisitLoad(Node* node) {
207 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
237 outputs[0] = g.DefineAsRegister(node);
241 g.GetEffectiveAddressMemoryOperand(node, inputs, &input_count);
247 void InstructionSelector::VisitStore(Node* node) {
249 Node* base = node->InputAt(0);
250 Node* index = node->InputAt(1);
251 Node* value = node->InputAt(2);
253 StoreRepresentation store_rep = StoreRepresentationOf(node->op());
332 g.GetEffectiveAddressMemoryOperand(node, inputs, &input_count);
342 void InstructionSelector::VisitCheckedLoad(Node* node) {
343 CheckedLoadRepresentation load_rep = CheckedLoadRepresentationOf(node->op());
345 Node* const buffer = node->InputAt(0);
346 Node* const offset = node->InputAt(1);
347 Node* const length = node->InputAt(2);
378 g.DefineAsRegister(node), offset_operand, length_operand,
382 g.DefineAsRegister(node), offset_operand, length_operand,
388 void InstructionSelector::VisitCheckedStore(Node* node) {
389 MachineRepresentation rep = CheckedStoreRepresentationOf(node->op());
391 Node* const buffer = node->InputAt(0);
392 Node* const offset = node->InputAt(1);
393 Node* const length = node->InputAt(2);
394 Node* const value = node->InputAt(3);
443 void VisitBinop(InstructionSelector* selector, Node* node,
446 Int32BinopMatcher m(node);
447 Node* left = m.left().node();
448 Node* right = m.right().node();
470 if (node->op()->HasProperty(Operator::kCommutative) &&
483 outputs[output_count++] = g.DefineSameAsFirst(node);
504 void VisitBinop(InstructionSelector* selector, Node* node,
507 VisitBinop(selector, node, opcode, &cont);
512 void InstructionSelector::VisitWord32And(Node* node) {
513 VisitBinop(this, node, kIA32And);
517 void InstructionSelector::VisitWord32Or(Node* node) {
518 VisitBinop(this, node, kIA32Or);
522 void InstructionSelector::VisitWord32Xor(Node* node) {
524 Int32BinopMatcher m(node);
526 Emit(kIA32Not, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()));
528 VisitBinop(this, node, kIA32Xor);
534 static inline void VisitShift(InstructionSelector* selector, Node* node,
537 Node* left = node->InputAt(0);
538 Node* right = node->InputAt(1);
541 selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
544 selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
552 void VisitMulHigh(InstructionSelector* selector, Node* node,
557 opcode, g.DefineAsFixed(node, edx), g.UseFixed(node->InputAt(0), eax),
558 g.UseUniqueRegister(node->InputAt(1)), arraysize(temps), temps);
562 void VisitDiv(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
565 selector->Emit(opcode, g.DefineAsFixed(node, eax),
566 g.UseFixed(node->InputAt(0), eax),
567 g.UseUnique(node->InputAt(1)), arraysize(temps), temps);
571 void VisitMod(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
574 selector->Emit(opcode, g.DefineAsFixed(node, edx),
575 g.UseFixed(node->InputAt(0), eax),
576 g.UseUnique(node->InputAt(1)), arraysize(temps), temps);
579 void EmitLea(InstructionSelector* selector, Node* result, Node* index,
580 int scale, Node* base, Node* displacement) {
601 void InstructionSelector::VisitWord32Shl(Node* node) {
602 Int32ScaleMatcher m(node, true);
604 Node* index = node->InputAt(0);
605 Node* base = m.power_of_two_plus_one() ? index : nullptr;
606 EmitLea(this, node, index, m.scale(), base, nullptr);
609 VisitShift(this, node, kIA32Shl);
613 void InstructionSelector::VisitWord32Shr(Node* node) {
614 VisitShift(this, node, kIA32Shr);
618 void InstructionSelector::VisitWord32Sar(Node* node) {
619 VisitShift(this, node, kIA32Sar);
622 void InstructionSelector::VisitInt32PairAdd(Node* node) {
628 g.UseRegister(node->InputAt(0)), g.UseUniqueRegister(node->InputAt(1)),
629 g.UseRegister(node->InputAt(2)), g.UseUniqueRegister(node->InputAt(3))};
632 g.DefineSameAsFirst(node),
633 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
640 void InstructionSelector::VisitInt32PairSub(Node* node) {
646 g.UseRegister(node->InputAt(0)), g.UseUniqueRegister(node->InputAt(1)),
647 g.UseRegister(node->InputAt(2)), g.UseUniqueRegister(node->InputAt(3))};
650 g.DefineSameAsFirst(node),
651 g.DefineAsRegister(NodeProperties::FindProjection(node, 1))};
658 void InstructionSelector::VisitInt32PairMul(Node* node) {
664 g.UseUnique(node->InputAt(0)), g.UseUnique(node->InputAt(1)),
665 g.UseUniqueRegister(node->InputAt(2)), g.UseFixed(node->InputAt(3), ecx)};
668 g.DefineAsFixed(node, eax),
669 g.DefineAsFixed(NodeProperties::FindProjection(node, 1), ecx)};
677 Node* node) {
680 Node* shift = node->InputAt(2);
687 InstructionOperand inputs[] = {g.UseFixed(node->InputAt(0), eax),
688 g.UseFixed(node->InputAt(1), edx),
692 g.DefineAsFixed(node, eax),
693 g.DefineAsFixed(NodeProperties::FindProjection(node, 1), edx)};
698 void InstructionSelector::VisitWord32PairShl(Node* node) {
699 VisitWord32PairShift(this, kIA32ShlPair, node);
702 void InstructionSelector::VisitWord32PairShr(Node* node) {
703 VisitWord32PairShift(this, kIA32ShrPair, node);
706 void InstructionSelector::VisitWord32PairSar(Node* node) {
707 VisitWord32PairShift(this, kIA32SarPair, node);
710 void InstructionSelector::VisitWord32Ror(Node* node) {
711 VisitShift(this, node, kIA32Ror);
715 void InstructionSelector::VisitWord32Clz(Node* node) {
717 Emit(kIA32Lzcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
721 void InstructionSelector::VisitWord32Ctz(Node* node) {
723 Emit(kIA32Tzcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
727 void InstructionSelector::VisitWord32ReverseBits(Node* node) { UNREACHABLE(); }
730 void InstructionSelector::VisitWord32Popcnt(Node* node) {
732 Emit(kIA32Popcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
736 void InstructionSelector::VisitInt32Add(Node* node) {
740 BaseWithIndexAndDisplacement32Matcher m(node);
752 outputs[0] = g.DefineAsRegister(node);
760 VisitBinop(this, node, kIA32Add);
764 void InstructionSelector::VisitInt32Sub(Node* node) {
766 Int32BinopMatcher m(node);
768 Emit(kIA32Neg, g.DefineSameAsFirst(node), g.Use(m.right().node()));
770 VisitBinop(this, node, kIA32Sub);
775 void InstructionSelector::VisitInt32Mul(Node* node) {
776 Int32ScaleMatcher m(node, true);
778 Node* index = node->InputAt(0);
779 Node* base = m.power_of_two_plus_one() ? index : nullptr;
780 EmitLea(this, node, index, m.scale(), base, nullptr);
784 Node* left = node->InputAt(0);
785 Node* right = node->InputAt(1);
787 Emit(kIA32Imul, g.DefineAsRegister(node), g.Use(left),
793 Emit(kIA32Imul, g.DefineSameAsFirst(node), g.UseRegister(left),
799 void InstructionSelector::VisitInt32MulHigh(Node* node) {
800 VisitMulHigh(this, node, kIA32ImulHigh);
804 void InstructionSelector::VisitUint32MulHigh(Node* node) {
805 VisitMulHigh(this, node, kIA32UmulHigh);
809 void InstructionSelector::VisitInt32Div(Node* node) {
810 VisitDiv(this, node, kIA32Idiv);
814 void InstructionSelector::VisitUint32Div(Node* node) {
815 VisitDiv(this, node, kIA32Udiv);
819 void InstructionSelector::VisitInt32Mod(Node* node) {
820 VisitMod(this, node, kIA32Idiv);
824 void InstructionSelector::VisitUint32Mod(Node* node) {
825 VisitMod(this, node, kIA32Udiv);
829 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
830 VisitRO(this, node, kSSEFloat32ToFloat64);
834 void InstructionSelector::VisitRoundInt32ToFloat32(Node* node) {
835 VisitRO(this, node, kSSEInt32ToFloat32);
839 void InstructionSelector::VisitRoundUint32ToFloat32(Node* node) {
842 Emit(kSSEUint32ToFloat32, g.DefineAsRegister(node), g.Use(node->InputAt(0)),
847 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) {
848 VisitRO(this, node, kSSEInt32ToFloat64);
852 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
853 VisitRO(this, node, kSSEUint32ToFloat64);
857 void InstructionSelector::VisitTruncateFloat32ToInt32(Node* node) {
858 VisitRO(this, node, kSSEFloat32ToInt32);
862 void InstructionSelector::VisitTruncateFloat32ToUint32(Node* node) {
863 VisitRO(this, node, kSSEFloat32ToUint32);
867 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) {
868 VisitRO(this, node, kSSEFloat64ToInt32);
872 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) {
873 VisitRO(this, node, kSSEFloat64ToUint32);
876 void InstructionSelector::VisitTruncateFloat64ToUint32(Node* node) {
877 VisitRO(this, node, kSSEFloat64ToUint32);
880 void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
881 VisitRO(this, node, kSSEFloat64ToFloat32);
884 void InstructionSelector::VisitTruncateFloat64ToWord32(Node* node) {
885 VisitRR(this, node, kArchTruncateDoubleToI);
888 void InstructionSelector::VisitRoundFloat64ToInt32(Node* node) {
889 VisitRO(this, node, kSSEFloat64ToInt32);
893 void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) {
895 Emit(kIA32BitcastFI, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
899 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) {
901 Emit(kIA32BitcastIF, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
905 void InstructionSelector::VisitFloat32Add(Node* node) {
906 VisitRROFloat(this, node, kAVXFloat32Add, kSSEFloat32Add);
910 void InstructionSelector::VisitFloat64Add(Node* node) {
911 VisitRROFloat(this, node, kAVXFloat64Add, kSSEFloat64Add);
915 void InstructionSelector::VisitFloat32Sub(Node* node) {
917 Float32BinopMatcher m(node);
919 VisitFloatUnop(this, node, m.right().node(), kAVXFloat32Neg,
923 VisitRROFloat(this, node, kAVXFloat32Sub, kSSEFloat32Sub);
926 void InstructionSelector::VisitFloat32SubPreserveNan(Node* node) {
927 VisitRROFloat(this, node, kAVXFloat32Sub, kSSEFloat32Sub);
930 void InstructionSelector::VisitFloat64Sub(Node* node) {
932 Float64BinopMatcher m(node);
935 CanCover(m.node(), m.right().node())) {
937 CanCover(m.right().node(), m.right().InputAt(0))) {
941 g.DefineAsRegister(node), g.UseRegister(mright0.right().node()));
946 VisitFloatUnop(this, node, m.right().node(), kAVXFloat64Neg,
950 VisitRROFloat(this, node, kAVXFloat64Sub, kSSEFloat64Sub);
953 void InstructionSelector::VisitFloat64SubPreserveNan(Node* node) {
954 VisitRROFloat(this, node, kAVXFloat64Sub, kSSEFloat64Sub);
957 void InstructionSelector::VisitFloat32Mul(Node* node) {
958 VisitRROFloat(this, node, kAVXFloat32Mul, kSSEFloat32Mul);
962 void InstructionSelector::VisitFloat64Mul(Node* node) {
963 VisitRROFloat(this, node, kAVXFloat64Mul, kSSEFloat64Mul);
967 void InstructionSelector::VisitFloat32Div(Node* node) {
968 VisitRROFloat(this, node, kAVXFloat32Div, kSSEFloat32Div);
972 void InstructionSelector::VisitFloat64Div(Node* node) {
973 VisitRROFloat(this, node, kAVXFloat64Div, kSSEFloat64Div);
977 void InstructionSelector::VisitFloat64Mod(Node* node) {
980 Emit(kSSEFloat64Mod, g.DefineSameAsFirst(node),
981 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)), 1,
986 void InstructionSelector::VisitFloat32Max(Node* node) {
987 VisitRROFloat(this, node, kAVXFloat32Max, kSSEFloat32Max);
991 void InstructionSelector::VisitFloat64Max(Node* node) {
992 VisitRROFloat(this, node, kAVXFloat64Max, kSSEFloat64Max);
996 void InstructionSelector::VisitFloat32Min(Node* node) {
997 VisitRROFloat(this, node, kAVXFloat32Min, kSSEFloat32Min);
1001 void InstructionSelector::VisitFloat64Min(Node* node) {
1002 VisitRROFloat(this, node, kAVXFloat64Min, kSSEFloat64Min);
1006 void InstructionSelector::VisitFloat32Abs(Node* node) {
1008 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat32Abs, kSSEFloat32Abs);
1012 void InstructionSelector::VisitFloat64Abs(Node* node) {
1014 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat64Abs, kSSEFloat64Abs);
1017 void InstructionSelector::VisitFloat32Sqrt(Node* node) {
1018 VisitRO(this, node, kSSEFloat32Sqrt);
1022 void InstructionSelector::VisitFloat64Sqrt(Nodenode) {
1023 VisitRO(this, node, kSSEFloat64Sqrt);
1027 void InstructionSelector::VisitFloat32RoundDown(Node* node) {
1028 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundDown));
1032 void InstructionSelector::VisitFloat64RoundDown(Node* node) {
1033 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundDown));
1037 void InstructionSelector::VisitFloat32RoundUp(Node* node) {
1038 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundUp));
1042 void InstructionSelector::VisitFloat64RoundUp(Node* node) {
1043 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundUp));
1047 void InstructionSelector::VisitFloat32RoundTruncate(Node* node) {
1048 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundToZero));
1052 void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
1053 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundToZero));
1057 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
1062 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) {
1063 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundToNearest));
1067 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) {
1068 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundToNearest));
1071 void InstructionSelector::VisitFloat32Neg(Node* node) { UNREACHABLE(); }
1073 void InstructionSelector::VisitFloat64Neg(Node* node) { UNREACHABLE(); }
1075 void InstructionSelector::VisitFloat64Ieee754Binop(Node* node,
1078 Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(node->InputAt(0)),
1079 g.UseRegister(node->InputAt(1)))
1083 void InstructionSelector::VisitFloat64Ieee754Unop(Node* node,
1086 Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(node->InputAt(0)))
1092 Node* node) {
1106 if (input.node()) {
1108 InstructionOperand value = g.CanBeImmediate(node)
1109 ? g.UseImmediate(input.node())
1110 : g.UseRegister(input.node());
1118 if (input.node() == nullptr) continue;
1120 g.CanBeImmediate(input.node())
1121 ? g.UseImmediate(input.node())
1123 sequence()->IsFP(GetVirtualRegister(input.node()))
1124 ? g.UseRegister(input.node())
1125 : g.Use(input.node());
1145 InstructionCode opcode, Node* left,
1193 Node* left, Node* right, FlagsContinuation* cont,
1204 InstructionCode TryNarrowOpcodeSize(InstructionCode opcode, Node* left,
1205 Node* right) {
1234 void VisitFloat32Compare(InstructionSelector* selector, Node* node,
1236 Node* const left = node->InputAt(0);
1237 Node* const right = node->InputAt(1);
1243 void VisitFloat64Compare(InstructionSelector* selector, Node* node,
1245 Node* const left = node->InputAt(0);
1246 Node* const right = node->InputAt(1);
1251 void VisitWordCompare(InstructionSelector* selector, Node* node,
1254 Node* left = node->InputAt(0);
1255 Node* right = node->InputAt(1);
1259 int effect_level = selector->GetEffectLevel(node);
1268 (g.CanBeMemoryOperand(narrowed_opcode, node, right, effect_level) &&
1269 !g.CanBeMemoryOperand(narrowed_opcode, node, left, effect_level))) {
1270 if (!node->op()->HasProperty(Operator::kCommutative)) cont->Commute();
1276 if (g.CanBeMemoryOperand(opcode, node, left, effect_level)) {
1287 if (g.CanBeMemoryOperand(narrowed_opcode, node, left, effect_level)) {
1297 if (!node->op()->HasProperty(Operator::kCommutative)) cont->Commute();
1302 node->op()->HasProperty(Operator::kCommutative));
1305 void VisitWordCompare(InstructionSelector* selector, Node* node,
1308 Int32BinopMatcher m(node);
1310 LoadMatcher<ExternalReferenceMatcher> mleft(m.left().node());
1315 if (!node->op()->HasProperty(Operator::kCommutative)) cont->Commute();
1330 VisitWordCompare(selector, node, kIA32Cmp, cont);
1335 void VisitWordCompareZero(InstructionSelector* selector, Node* user,
1336 Node* value, FlagsContinuation* cont) {
1346 value = m.left().node();
1385 // <Operation>WithOverflow node.
1392 Node* const node = value->InputAt(0);
1393 Node* const result = NodeProperties::FindProjection(node, 0);
1395 switch (node->opcode()) {
1398 return VisitBinop(selector, node, kIA32Add, cont);
1401 return VisitBinop(selector, node, kIA32Sub, cont);
1425 void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
1431 void InstructionSelector::VisitDeoptimizeIf(Node* node) {
1433 FlagsContinuation::ForDeoptimize(kNotEqual, node->InputAt(1));
1434 VisitWordCompareZero(this, node, node->InputAt(0), &cont);
1437 void InstructionSelector::VisitDeoptimizeUnless(Node* node) {
1439 FlagsContinuation::ForDeoptimize(kEqual, node->InputAt(1));
1440 node, node->InputAt(0), &cont);
1443 void InstructionSelector::VisitSwitch(Node* node, const SwitchInfo& sw) {
1445 InstructionOperand value_operand = g.UseRegister(node->InputAt(0));
1471 void InstructionSelector::VisitWord32Equal(Node* const node) {
1472 FlagsContinuation cont = FlagsContinuation::ForSet(kEqual, node);
1473 Int32BinopMatcher m(node);
1475 return VisitWordCompareZero(this, m.node(), m.left().node(), &cont);
1477 VisitWordCompare(this, node, &cont);
1481 void InstructionSelector::VisitInt32LessThan(Node* node) {
1482 FlagsContinuation cont = FlagsContinuation::ForSet(kSignedLessThan, node);
1483 VisitWordCompare(this, node, &cont);
1487 void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
1489 FlagsContinuation::ForSet(kSignedLessThanOrEqual, node);
1490 VisitWordCompare(this, node, &cont);
1494 void InstructionSelector::VisitUint32LessThan(Node* node) {
1495 FlagsContinuation cont = FlagsContinuation::ForSet(kUnsignedLessThan, node);
1496 VisitWordCompare(this, node, &cont);
1500 void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
1502 FlagsContinuation::ForSet(kUnsignedLessThanOrEqual, node);
1503 VisitWordCompare(this, node, &cont);
1507 void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
1508 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1510 return VisitBinop(this, node, kIA32Add, &cont);
1513 VisitBinop(this, node, kIA32Add, &cont);
1517 void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
1518 if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
1520 return VisitBinop(this, node, kIA32Sub, &cont);
1523 VisitBinop(this, node, kIA32Sub, &cont);
1527 void InstructionSelector::VisitFloat32Equal(Node* node) {
1528 FlagsContinuation cont = FlagsContinuation::ForSet(kUnorderedEqual, node);
1529 VisitFloat32Compare(this, node, &cont);
1533 void InstructionSelector::VisitFloat32LessThan(Node* node) {
1535 FlagsContinuation::ForSet(kUnsignedGreaterThan, node);
1536 VisitFloat32Compare(this, node, &cont);
1540 void InstructionSelector::VisitFloat32LessThanOrEqual(Node* node) {
1542 FlagsContinuation::ForSet(kUnsignedGreaterThanOrEqual, node);
1543 VisitFloat32Compare(this, node, &cont);
1547 void InstructionSelector::VisitFloat64Equal(Node* node) {
1548 FlagsContinuation cont = FlagsContinuation::ForSet(kUnorderedEqual, node);
1549 VisitFloat64Compare(this, node, &cont);
1553 void InstructionSelector::VisitFloat64LessThan(Node* node) {
1555 FlagsContinuation::ForSet(kUnsignedGreaterThan, node);
1556 VisitFloat64Compare(this, node, &cont);
1560 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
1562 FlagsContinuation::ForSet(kUnsignedGreaterThanOrEqual, node);
1563 VisitFloat64Compare(this, node, &cont);
1567 void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) {
1569 Emit(kSSEFloat64ExtractLowWord32, g.DefineAsRegister(node),
1570 g.Use(node->InputAt(0)));
1574 void InstructionSelector::VisitFloat64ExtractHighWord32(Node* node) {
1576 Emit(kSSEFloat64ExtractHighWord32, g.DefineAsRegister(node),
1577 g.Use(node->InputAt(0)));
1581 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) {
1583 Node* left = node->InputAt(0);
1584 Node* right = node->InputAt(1);
1587 Emit(kSSEFloat64LoadLowWord32, g.DefineAsRegister(node), g.Use(right));
1590 Emit(kSSEFloat64InsertLowWord32, g.DefineSameAsFirst(node),
1595 void InstructionSelector::VisitFloat64InsertHighWord32(Node* node) {
1597 Node* left = node->InputAt(0);
1598 Node* right = node->InputAt(1);
1599 Emit(kSSEFloat64InsertHighWord32, g.DefineSameAsFirst(node),
1603 void InstructionSelector::VisitFloat64SilenceNaN(Node* node) {
1605 Emit(kSSEFloat64SilenceNaN, g.DefineSameAsFirst(node),
1606 g.UseRegister(node->InputAt(0)));
1609 void InstructionSelector::VisitAtomicLoad(Node* node) {
1610 LoadRepresentation load_rep = LoadRepresentationOf(node->op());
1615 VisitLoad(node);
1618 void InstructionSelector::VisitAtomicStore(Node* node) {
1620 Node* base = node->InputAt(0);
1621 Node* index = node->InputAt(1);
1622 Node* value = node->InputAt(2);
1624 MachineRepresentation rep = AtomicStoreRepresentationOf(node->op());
