Implement the remaining methods in intrinsifier_x64.cc

runtime/vm/intrinsifier_ia32.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // The intrinsic code below is executed before a method has built its frame.
 // The return address is on the stack and the arguments below it.
 // Registers EDX (arguments descriptor) and ECX (function) must be preserved.
 // Each intrinsification method returns true if the corresponding
 // Dart method was intrinsified.
 
@@ skipping 786 matching lines @@
 bool Intrinsifier::Integer_lessEqualThan(Assembler* assembler) {
   return CompareIntegers(assembler, LESS_EQUAL);
 }
 
 
 bool Intrinsifier::Integer_greaterEqualThan(Assembler* assembler) {
   return CompareIntegers(assembler, GREATER_EQUAL);
 }
 
 
-// This is called for Smi, Mint and Bigint receivers. Bigints are not handled.
+// This is called for Smi, Mint and Bigint receivers. The right argument
+// can be Smi, Mint, Bigint or double.
 bool Intrinsifier::Integer_equalToInteger(Assembler* assembler) {
   Label fall_through, true_label, check_for_mint;
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   // For integer receiver '===' check first.
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
   __ cmpl(EAX, Address(ESP, + 2 * kWordSize));
   __ j(EQUAL, &true_label, Assembler::kNearJump);
   __ movl(EBX, Address(ESP, + 2 * kWordSize));
   __ orl(EAX, EBX);
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &check_for_mint, Assembler::kNearJump);
   // Both arguments are smi, '===' is good enough.
   __ LoadObject(EAX, bool_false);
   __ ret();
   __ Bind(&true_label);
   __ LoadObject(EAX, bool_true);
   __ ret();
 
-  // At least one of the arguments was not Smi, inline code for Smi/Mint
-  // equality comparison.
+  // At least one of the arguments was not Smi.
   Label receiver_not_smi;
   __ Bind(&check_for_mint);
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // Receiver.
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &receiver_not_smi);
 
-  // Note that an instance of Mint never contains a value that can be
+  // Left (receiver) is Smi, return false if right is not Double.
+  // Note that an instance of Mint or Bigint never contains a value that can be
   // represented by Smi.
-  // Left is Smi, return false if right is Mint, otherwise fall through.
   __ movl(EAX, Address(ESP, + 1 * kWordSize));  // Right argument.
-  __ CompareClassId(EAX, kMint, EDI);
-  __ j(NOT_EQUAL, &fall_through);
+  __ CompareClassId(EAX, kDouble, EDI);
+  __ j(EQUAL, &fall_through);
   __ LoadObject(EAX, bool_false);  // Smi == Mint -> false.
   __ ret();
 
   __ Bind(&receiver_not_smi);
   // EAX:: receiver.
   __ CompareClassId(EAX, kMint, EDI);
   __ j(NOT_EQUAL, &fall_through);
   // Receiver is Mint, return false if right is Smi.
   __ movl(EAX, Address(ESP, + 1 * kWordSize));  // Right argument.
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through);
-  __ LoadObject(EAX, bool_false);  // Smi == Mint -> false.
+  __ LoadObject(EAX, bool_false);
   __ ret();
   // TODO(srdjan): Implement Mint == Mint comparison.
 
   __ Bind(&fall_through);
   return false;
 }
 
 
 bool Intrinsifier::Integer_equal(Assembler* assembler) {
   return Integer_equalToInteger(assembler);
@@ skipping 20 matching lines @@
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // Value.
   __ SmiUntag(EAX);  // Value.
   __ sarl(EAX, ECX);
   __ SmiTag(EAX);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
+// Argument is Smi (receiver).
 bool Intrinsifier::Smi_bitNegate(Assembler* assembler) {
-  Label fall_through;
   __ movl(EAX, Address(ESP, + 1 * kWordSize));  // Index.
-  __ testl(EAX, Immediate(kSmiTagMask));
-  __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);  // Non-smi.
   __ notl(EAX);
   __ andl(EAX, Immediate(~kSmiTagMask));  // Remove inverted smi-tag.
   __ ret();
-  __ Bind(&fall_through);
-  return false;
+  return true;
 }
 
 
 // Check if the last argument is a double, jump to label 'is_smi' if smi
 // (easy to convert to double), otherwise jump to label 'not_double_smi',
 // Returns the last argument in EAX.
 static void TestLastArgumentIsDouble(Assembler* assembler,
                                      Label* is_smi,
                                      Label* not_double_smi) {
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
@@ skipping 68 matching lines @@
 }
 
 
 bool Intrinsifier::Double_toDouble(Assembler* assembler) {
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
   __ ret();
   return true;
 }
 
 
-// Expects EAX to contain right argument, left argument is on stack. Left
-// argument is double, right argument is of unknown type.
+// Expects left argument to be double (receiver). Right argument is unknown.
+// Both arguments are on stack.
 static bool DoubleArithmeticOperations(Assembler* assembler, Token::Kind kind) {
   Label fall_through;
   TestLastArgumentIsDouble(assembler, &fall_through, &fall_through);
-  // Both arguments are double, right operand is in EAX, class in EBX.
+  // Both arguments are double, right operand is in EAX.
   __ movsd(XMM1, FieldAddress(EAX, Double::value_offset()));
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // Left argument.
   __ movsd(XMM0, FieldAddress(EAX, Double::value_offset()));
   switch (kind) {
     case Token::kADD: __ addsd(XMM0, XMM1); break;
     case Token::kSUB: __ subsd(XMM0, XMM1); break;
     case Token::kMUL: __ mulsd(XMM0, XMM1); break;
     case Token::kDIV: __ divsd(XMM0, XMM1); break;
     default: UNREACHABLE();
   }
@@ skipping 23 matching lines @@
 bool Intrinsifier::Double_sub(Assembler* assembler) {
   return DoubleArithmeticOperations(assembler, Token::kSUB);
 }
 
 
 bool Intrinsifier::Double_div(Assembler* assembler) {
   return DoubleArithmeticOperations(assembler, Token::kDIV);
 }
 
 
-// Left is double right is integer (bigint or Smi)
+// Left is double right is integer (Bigint, Mint or Smi)
 bool Intrinsifier::Double_mulFromInteger(Assembler* assembler) {
   Label fall_through;
   // Only Smi-s allowed.
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);
   // Is Smi.
   __ SmiUntag(EAX);
   __ cvtsi2sd(XMM1, EAX);
   __ movl(EAX, Address(ESP, + 2 * kWordSize));
@@ skipping 313 matching lines @@
   __ Bind(&is_true);
   __ LoadObject(EAX, bool_true);
   __ ret();
   return true;
 }
 
 #undef __
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32