Implement proposed new identity spec.

runtime/vm/stub_code_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.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/assembler.h"
 #include "vm/assembler_macros.h"
 #include "vm/compiler.h"
@@ skipping 2112 matching lines @@
   AssemblerMacros::EnterStubFrame(assembler);
   __ pushl(EAX);
   __ pushl(EDX);
   __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry);
   __ popl(EDX);
   __ popl(EAX);
   __ LeaveFrame();
   __ ret();
 }
 
+
+DECLARE_LEAF_RUNTIME_ENTRY(intptr_t,
+                           BigintCompare,
+                           RawBigint* left,
+                           RawBigint* right);
+
+
+// Does identical check (object references are equal or not equal) with special
+// checks for boxed numbers.
+// Left and right are pushed on stack.
+// Return ZF set.
+void StubCode::GenerateIdenticalWithNumberCheckStub(Assembler* assembler) {
+  const Register left = EAX;
+  const Register right = EDX;
+  const Register temp = ECX;
+  // Preserve left, right and temp.
+  __ pushl(left);
+  __ pushl(right);
+  __ pushl(temp);
+  // TOS + 0: saved temp
+  // TOS + 1: saved right
+  // TOS + 2: saved left
+  // TOS + 3: return address
+  // TOS + 4: right argument.
+  // TOS + 5: left argument.
+  __ movl(left, Address(ESP, 5 * kWordSize));
+  __ movl(right, Address(ESP, 4 * kWordSize));
+  Label reference_compare, done, check_mint, check_bigint;
+  // If any of the arguments is Smi do reference compare.
+  __ testl(left, Immediate(kSmiTagMask));
+  __ j(ZERO, &reference_compare, Assembler::kNearJump);
+  __ testl(right, Immediate(kSmiTagMask));
+  __ j(ZERO, &reference_compare, Assembler::kNearJump);
+
+  // Value compare for two doubles.
+  __ CompareClassId(left, kDoubleCid, temp);
+  __ j(NOT_EQUAL, &check_mint, Assembler::kNearJump);
+  __ CompareClassId(right, kDoubleCid, temp);
+  __ j(NOT_EQUAL, &done, Assembler::kNearJump);
+
+  // Double values bitwise compare.
+  __ movl(temp, FieldAddress(left, Double::value_offset() + 0 * kWordSize));
+  __ cmpl(temp, FieldAddress(right, Double::value_offset() + 0 * kWordSize));
+  __ j(NOT_EQUAL, &done, Assembler::kNearJump);
+  __ movl(temp, FieldAddress(left, Double::value_offset() + 1 * kWordSize));
+  __ cmpl(temp, FieldAddress(right, Double::value_offset() + 1 * kWordSize));
+  __ jmp(&done, Assembler::kNearJump);
+
+  __ Bind(&check_mint);
+  __ CompareClassId(left, kMintCid, temp);
+  __ j(NOT_EQUAL, &check_bigint, Assembler::kNearJump);
+  __ movl(temp, FieldAddress(left, Mint::value_offset() + 0 * kWordSize));
+  __ cmpl(temp, FieldAddress(right, Mint::value_offset() + 0 * kWordSize));

[Florian Schneider, 2012/11/23 10:33:40]

right has yet not been checked for kMintCid here.

[srdjan, 2012/11/23 19:45:39]

Done.

+  __ j(NOT_EQUAL, &done, Assembler::kNearJump);
+  __ movl(temp, FieldAddress(left, Mint::value_offset() + 1 * kWordSize));
+  __ cmpl(temp, FieldAddress(right, Mint::value_offset() + 1 * kWordSize));
+  __ jmp(&done, Assembler::kNearJump);
+
+  __ Bind(&check_bigint);
+  __ CompareClassId(left, kBigintCid, temp);
+  __ j(NOT_EQUAL, &reference_compare, Assembler::kNearJump);
+  __ CompareClassId(right, kBigintCid, temp);
+  __ j(NOT_EQUAL, &reference_compare, Assembler::kNearJump);
+  __ EnterFrame(0);
+  __ ReserveAlignedFrameSpace(2 * kWordSize);
+  __ movl(Address(ESP, 1 * kWordSize), left);
+  __ movl(Address(ESP, 0 * kWordSize), right);
+  __ CallRuntime(kBigintCompareRuntimeEntry);
+  // Result in EAX, 0 means equal.
+  __ LeaveFrame();
+  __ cmpl(EAX, Immediate(0));
+  __ jmp(&done);
+
+  __ Bind(&reference_compare);

[Florian Schneider, 2012/11/23 10:33:40]

Please add a comment that the code relies on the assumption that there is never
a bigint containing an integer in mint- or smi-range and that a mint never
contains an integer in smi-range.

Also I'm not sure if we assert this property in all places where we allocate
Mints and Bigints.

[srdjan, 2012/11/23 19:45:39]

Added comment at the beginning of method:
// Note: A Mint cannot contain a value that would fit in Smi, a Bigint
// cannot contain a value that fits in Mint or Smi.

If that is violated somewhere in the VM we will have crashes. I will verify that
assumption.

+  __ cmpl(left, right);
+  __ Bind(&done);
+  __ popl(temp);
+  __ popl(right);
+  __ popl(left);
+  __ ret();
+}
+
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32