Share intrinsification framework across architectures, started on instrinsification in the new comp…

runtime/vm/intrinsifier_ia32.cc

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// 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.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
 #include "vm/assembler_macros.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/stub_code.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, intrinsify, true, "Instrinsify when possible");
 DECLARE_FLAG(bool, enable_type_checks);
 
-// List of intrinsics: (class-name, function-name, intrinsification method).
-#define INTRINSIC_LIST(V)                                                      \
-  V(IntegerImplementation, addFromInteger, Integer_addFromInteger)             \
-  V(IntegerImplementation, +, Integer_addFromInteger)                          \
-  V(IntegerImplementation, subFromInteger, Integer_subFromInteger)             \
-  V(IntegerImplementation, -, Integer_sub)                                     \
-  V(IntegerImplementation, mulFromInteger, Integer_mulFromInteger)             \
-  V(IntegerImplementation, *, Integer_mulFromInteger)                          \
-  V(IntegerImplementation, %, Integer_modulo)                                  \
-  V(IntegerImplementation, ~/, Integer_truncDivide)                            \
-  V(IntegerImplementation, negate, Integer_negate)                             \
-  V(IntegerImplementation, bitAndFromInteger, Integer_bitAndFromInteger)       \
-  V(IntegerImplementation, &, Integer_bitAndFromInteger)                       \
-  V(IntegerImplementation, bitOrFromInteger, Integer_bitOrFromInteger)         \
-  V(IntegerImplementation, |, Integer_bitOrFromInteger)                        \
-  V(IntegerImplementation, bitXorFromInteger, Integer_bitXorFromInteger)       \
-  V(IntegerImplementation, ^, Integer_bitXorFromInteger)                       \
-  V(IntegerImplementation, greaterThanFromInteger, Integer_lessThan)           \
-  V(IntegerImplementation, >, Integer_greaterThan)                             \
-  V(IntegerImplementation, ==, Integer_equalToInteger)                         \
-  V(IntegerImplementation, equalToInteger, Integer_equalToInteger)             \
-  V(IntegerImplementation, <, Integer_lessThan)                                \
-  V(IntegerImplementation, <=, Integer_lessEqualThan)                          \
-  V(IntegerImplementation, >=, Integer_greaterEqualThan)                       \
-  V(IntegerImplementation, <<, Integer_shl)                                    \
-  V(IntegerImplementation, >>, Integer_sar)                                    \
-  V(Smi, ~, Smi_bitNegate)                                                     \
-  V(Double, >, Double_greaterThan)                                             \
-  V(Double, >=, Double_greaterEqualThan)                                       \
-  V(Double, <, Double_lessThan)                                                \
-  V(Double, <=, Double_lessEqualThan)                                          \
-  V(Double, ==, Double_equal)                                                  \
-  V(Double, +, Double_add)                                                     \
-  V(Double, -, Double_sub)                                                     \
-  V(Double, *, Double_mul)                                                     \
-  V(Double, /, Double_div)                                                     \
-  V(Double, toDouble, Double_toDouble)                                         \
-  V(Double, mulFromInteger, Double_mulFromInteger)                             \
-  V(Double, Double.fromInteger, Double_fromInteger)                            \
-  V(Double, isNaN, Double_isNaN)                                               \
-  V(Double, isNegative, Double_isNegative)                                     \
-  V(ObjectArray, ObjectArray., ObjectArray_Allocate)                           \
-  V(ObjectArray, get:length, Array_getLength)                                  \
-  V(ObjectArray, [], Array_getIndexed)                                         \
-  V(ObjectArray, []=, Array_setIndexed)                                        \
-  V(GrowableObjectArray, GrowableObjectArray.fromObjectArray, GArray_Allocate) \
-  V(GrowableObjectArray, get:length, GrowableArray_getLength)                  \
-  V(GrowableObjectArray, get:capacity, GrowableArray_getCapacity)              \
-  V(GrowableObjectArray, [], GrowableArray_getIndexed)                         \
-  V(GrowableObjectArray, []=, GrowableArray_setIndexed)                        \
-  V(GrowableObjectArray, _setLength, GrowableArray_setLength)                  \
-  V(GrowableObjectArray, set:data, GrowableArray_setData)                      \
-  V(_ByteArrayBase, get:length, ByteArrayBase_getLength)                       \
-  V(_ByteArrayBase, [], ByteArrayBase_getIndexed)                              \
-  V(ImmutableArray, [], Array_getIndexed)                                      \
-  V(ImmutableArray, get:length, Array_getLength)                               \
-  V(Math, sqrt, Math_sqrt)                                                     \
-  V(Math, sin, Math_sin)                                                       \
-  V(Math, cos, Math_cos)                                                       \
-  V(Object, ==, Object_equal)                                                  \
-  V(FixedSizeArrayIterator, next, FixedSizeArrayIterator_next)                 \
-  V(FixedSizeArrayIterator, hasNext, FixedSizeArrayIterator_hasNext)           \
-  V(StringBase, get:length, String_getLength)                                  \
-  V(StringBase, charCodeAt, String_charCodeAt)                                 \
-  V(StringBase, hashCode, String_hashCode)                                     \
-  V(StringBase, isEmpty, String_isEmpty)                                       \
 
 #define __ assembler->
 
-static bool ObjectArray_Allocate(Assembler* assembler) {
+bool Intrinsifier::ObjectArray_Allocate(Assembler* assembler) {
   // This snippet of inlined code uses the following registers:
   // EAX, EBX, EDI
   // and the newly allocated object is returned in EAX.
   const intptr_t kTypeArgumentsOffset = 2 * kWordSize;
   const intptr_t kArrayLengthOffset = 1 * kWordSize;
   Label fall_through;
 
   // Compute the size to be allocated, it is based on the array length
   // and it computed as:
   // RoundedAllocationSize((array_length * kwordSize) + sizeof(RawArray)).
@@ skipping 78 matching lines @@
   __ addl(EDI, Immediate(kWordSize));
   __ jmp(&init_loop, Assembler::kNearJump);
   __ Bind(&done);
   __ ret();  // returns the newly allocated object in EAX.
 
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Array_getLength(Assembler* assembler) {
+bool Intrinsifier::Array_getLength(Assembler* assembler) {
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
   __ movl(EAX, FieldAddress(EAX, Array::length_offset()));
   __ ret();
   return true;
 }
 
 
-static bool Array_getIndexed(Assembler* assembler) {
+bool Intrinsifier::ImmutableArray_getLength(Assembler* assembler) {
+  return Array_getLength(assembler);
+}
+
+
+bool Intrinsifier::Array_getIndexed(Assembler* assembler) {
   Label fall_through;
   __ movl(EBX, Address(ESP, + 1 * kWordSize));  // Index.
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // Array.
   __ testl(EBX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);  // Non-smi index.
   // Range check.
   __ cmpl(EBX, FieldAddress(EAX, Array::length_offset()));
   // Runtime throws exception.
   __ j(ABOVE_EQUAL, &fall_through, Assembler::kNearJump);
   // Note that EBX is Smi, i.e, times 2.
   ASSERT(kSmiTagShift == 1);
   __ movl(EAX, FieldAddress(EAX, EBX, TIMES_2, sizeof(RawArray)));
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
+bool Intrinsifier::ImmutableArray_getIndexed(Assembler* assembler) {
+  return Array_getIndexed(assembler);
+}
+
+
 static intptr_t ComputeObjectArrayTypeArgumentsOffset() {
   const String& class_name = String::Handle(String::NewSymbol("ObjectArray"));
   const Class& cls = Class::Handle(
       Library::Handle(Library::CoreImplLibrary()).LookupClass(class_name));
   ASSERT(!cls.IsNull());
   ASSERT(cls.HasTypeArguments());
   ASSERT(cls.NumTypeArguments() == 1);
   const intptr_t field_offset = cls.type_arguments_instance_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
   return field_offset;
 }
 
 
 // Intrinsify only for Smi value and index. Non-smi values need a store buffer
 // update. Array length is always a Smi.
-static bool Array_setIndexed(Assembler* assembler) {
+bool Intrinsifier::Array_setIndexed(Assembler* assembler) {
   Label fall_through;
   if (FLAG_enable_type_checks) {
     const intptr_t type_args_field_offset =
         ComputeObjectArrayTypeArgumentsOffset();
     // Inline simple tests (Smi, null), fallthrough if not positive.
     const Immediate raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     Label checked_ok;
     __ movl(EDI, Address(ESP, + 1 * kWordSize));  // Value.
     // Null value is valid for any type.
@@ skipping 54 matching lines @@
       Library::CoreImplLibrary()).LookupClass(class_name));
   ASSERT(!cls.IsNull());
   const Field& field = Field::ZoneHandle(cls.LookupInstanceField(field_name));
   ASSERT(!field.IsNull());
   return field.Offset();
 }
 
 
 // Allocate a GrowableObjectArray using the backing array specified.
 // On stack: type argument (+2), data (+1), return-address (+0).
-static bool GArray_Allocate(Assembler* assembler) {
+bool Intrinsifier::GArray_Allocate(Assembler* assembler) {
   // This snippet of inlined code uses the following registers:
   // EAX, EBX
   // and the newly allocated object is returned in EAX.
   const intptr_t kTypeArgumentsOffset = 2 * kWordSize;
   const intptr_t kArrayOffset = 1 * kWordSize;
   Label fall_through;
 
   // Compute the size to be allocated, it is based on the array length
   // and it computed as:
   // RoundedAllocationSize(sizeof(RawGrowableObjectArray)) +
@@ skipping 47 matching lines @@
           Immediate(0));
   __ ret();  // returns the newly allocated object in EAX.
 
   __ Bind(&fall_through);
   return false;
 }
 
 
 // Get length of growable object array.
 // On stack: growable array (+1), return-address (+0).
-static bool GrowableArray_getLength(Assembler* assembler) {
+bool Intrinsifier::GrowableArray_getLength(Assembler* assembler) {
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
   __ movl(EAX, FieldAddress(EAX, GrowableObjectArray::length_offset()));
   __ ret();
   return true;
 }
 
 
 // Get capacity of growable object array.
 // On stack: growable array (+1), return-address (+0).
-static bool GrowableArray_getCapacity(Assembler* assembler) {
+bool Intrinsifier::GrowableArray_getCapacity(Assembler* assembler) {
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
   __ movl(EAX, FieldAddress(EAX, GrowableObjectArray::data_offset()));
   __ movl(EAX, FieldAddress(EAX, Array::length_offset()));
   __ ret();
   return true;
 }
 
 
 // Access growable object array at specified index.
 // On stack: growable array (+2), index (+1), return-address (+0).
-static bool GrowableArray_getIndexed(Assembler* assembler) {
+bool Intrinsifier::GrowableArray_getIndexed(Assembler* assembler) {
   Label fall_through;
   __ movl(EBX, Address(ESP, + 1 * kWordSize));  // Index.
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // GrowableArray.
   __ testl(EBX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);  // Non-smi index.
   // Range check using _length field.
   __ cmpl(EBX, FieldAddress(EAX, GrowableObjectArray::length_offset()));
   // Runtime throws exception.
   __ j(ABOVE_EQUAL, &fall_through, Assembler::kNearJump);
   __ movl(EAX, FieldAddress(EAX, GrowableObjectArray::data_offset()));  // data.
 
   // Note that EBX is Smi, i.e, times 2.
   ASSERT(kSmiTagShift == 1);
   __ movl(EAX, FieldAddress(EAX, EBX, TIMES_2, sizeof(RawArray)));
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 // Set value into growable object array at specified index.
 // On stack: growable array (+3), index (+2), value (+1), return-address (+0).
-static bool GrowableArray_setIndexed(Assembler* assembler) {
+bool Intrinsifier::GrowableArray_setIndexed(Assembler* assembler) {
   if (FLAG_enable_type_checks) {
     return false;
   }
   Label fall_through;
   __ movl(EBX, Address(ESP, + 2 * kWordSize));  // Index.
   __ movl(EAX, Address(ESP, + 3 * kWordSize));  // GrowableArray.
   __ testl(EBX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);  // Non-smi index.
   // Range check using _length field.
   __ cmpl(EBX, FieldAddress(EAX, GrowableObjectArray::length_offset()));
   // Runtime throws exception.
   __ j(ABOVE_EQUAL, &fall_through, Assembler::kNearJump);
   __ movl(EAX, FieldAddress(EAX, GrowableObjectArray::data_offset()));  // data.
   __ movl(EDI, Address(ESP, + 1 * kWordSize));  // Value.
   // Note that EBX is Smi, i.e, times 2.
   ASSERT(kSmiTagShift == 1);
   __ StoreIntoObject(EAX,
                      FieldAddress(EAX, EBX, TIMES_2, sizeof(RawArray)),
                      EDI);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 // Set length of growable object array.
 // On stack: growable array (+2), length (+1), return-address (+0).
-static bool GrowableArray_setLength(Assembler* assembler) {
+bool Intrinsifier::GrowableArray_setLength(Assembler* assembler) {
   Label fall_through;
   __ movl(EAX, Address(ESP, + 2 * kWordSize));
   __ movl(EBX, Address(ESP, + 1 * kWordSize));
   __ movl(EDI, FieldAddress(EAX, GrowableObjectArray::data_offset()));
   __ cmpl(EBX, FieldAddress(EDI, Array::length_offset()));
   __ j(ABOVE, &fall_through, Assembler::kNearJump);
   __ movl(FieldAddress(EAX, GrowableObjectArray::length_offset()), EBX);
   __ ret();
   __ Bind(&fall_through);
   return true;
 }
 
 
 // Set data of growable object array.
 // On stack: growable array (+2), data (+1), return-address (+0).
-static bool GrowableArray_setData(Assembler* assembler) {
+bool Intrinsifier::GrowableArray_setData(Assembler* assembler) {
   if (FLAG_enable_type_checks) {
     return false;
   }
   __ movl(EAX, Address(ESP, + 2 * kWordSize));
   __ movl(EBX, Address(ESP, + 1 * kWordSize));
   __ movl(FieldAddress(EAX, GrowableObjectArray::data_offset()), EBX);
   __ ret();
   return true;
 }
 
 
 // Handles only class InternalByteArray.
-static bool ByteArrayBase_getLength(Assembler* assembler) {
+bool Intrinsifier::ByteArrayBase_getLength(Assembler* assembler) {
   ObjectStore* object_store = Isolate::Current()->object_store();
   Label fall_through;
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
   __ movl(EBX, FieldAddress(EAX, Object::class_offset()));
   __ CompareObject(EBX,
       Class::ZoneHandle(object_store->internal_byte_array_class()));
   __ j(NOT_EQUAL, &fall_through);
   __ movl(EAX, FieldAddress(EAX, InternalByteArray::length_offset()));
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 // Handles only class InternalByteArray.
-static bool ByteArrayBase_getIndexed(Assembler* assembler) {
+bool Intrinsifier::ByteArrayBase_getIndexed(Assembler* assembler) {
   ObjectStore* object_store = Isolate::Current()->object_store();
   Label fall_through;
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // Array.
   __ movl(EBX, FieldAddress(EAX, Object::class_offset()));
   __ CompareObject(EBX,
       Class::ZoneHandle(object_store->internal_byte_array_class()));
   __ j(NOT_EQUAL, &fall_through);
   __ movl(EBX, Address(ESP, + 1 * kWordSize));  // Index.
   __ testl(EBX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);  // Non-smi index.
@@ skipping 17 matching lines @@
 // Topmost argument is in EAX.
 static void TestBothArgumentsSmis(Assembler* assembler, Label* not_smi) {
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
   __ movl(EBX, Address(ESP, + 2 * kWordSize));
   __ orl(EBX, EAX);
   __ testl(EBX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, not_smi, Assembler::kNearJump);
 }
 
 
-static bool Integer_addFromInteger(Assembler* assembler) {
+bool Intrinsifier::Integer_addFromInteger(Assembler* assembler) {
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);
   __ addl(EAX, Address(ESP, + 2 * kWordSize));
   __ j(OVERFLOW, &fall_through, Assembler::kNearJump);
   // Result is in EAX.
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Integer_subFromInteger(Assembler* assembler) {
+bool Intrinsifier::Integer_add(Assembler* assembler) {
+  return Integer_addFromInteger(assembler);
+}
+
+
+bool Intrinsifier::Integer_subFromInteger(Assembler* assembler) {
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);
   __ subl(EAX, Address(ESP, + 2 * kWordSize));
   __ j(OVERFLOW, &fall_through, Assembler::kNearJump);
   // Result is in EAX.
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Integer_sub(Assembler* assembler) {
+bool Intrinsifier::Integer_sub(Assembler* assembler) {
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);
   __ movl(EBX, EAX);
   __ movl(EAX, Address(ESP, + 2 * kWordSize));
   __ subl(EAX, EBX);
   __ j(OVERFLOW, &fall_through, Assembler::kNearJump);
   // Result is in EAX.
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 
-static bool Integer_mulFromInteger(Assembler* assembler) {
+bool Intrinsifier::Integer_mulFromInteger(Assembler* assembler) {
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);
   ASSERT(kSmiTag == 0);  // Adjust code below if not the case.
   __ SmiUntag(EAX);
   __ imull(EAX, Address(ESP, + 2 * kWordSize));
   __ j(OVERFLOW, &fall_through, Assembler::kNearJump);
   // Result is in EAX.
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
+bool Intrinsifier::Integer_mul(Assembler* assembler) {
+  return Integer_mulFromInteger(assembler);
+}
+
+
 // Simple implementation: for positive dividend values greater than divisor,
 // return dividend.
-static bool Integer_modulo(Assembler* assembler) {
+bool Intrinsifier::Integer_modulo(Assembler* assembler) {
   Label fall_through, return_zero;
   TestBothArgumentsSmis(assembler, &fall_through);
   // EAX: right argument (divisor)
   // Check if modulo by zero -> exception thrown in main function.
   __ cmpl(EAX, Immediate(0));
   __ j(EQUAL, &fall_through,  Assembler::kNearJump);
   __ movl(EBX, Address(ESP, + 2 * kWordSize));  // Left argument (dividend).
   __ cmpl(EBX, Immediate(0));
   __ j(LESS, &fall_through, Assembler::kNearJump);
   __ cmpl(EBX, EAX);
   __ j(EQUAL, &return_zero, Assembler::kNearJump);
   __ j(GREATER, &fall_through, Assembler::kNearJump);
   __ movl(EAX, EBX);  // Return dividend.
   __ ret();
   __ Bind(&return_zero);
   __ xorl(EAX, EAX);  // Return zero.
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Integer_truncDivide(Assembler* assembler) {
+bool Intrinsifier::Integer_truncDivide(Assembler* assembler) {
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);
   // EAX: right argument (divisor)
   __ cmpl(EAX, Immediate(0));
   __ j(EQUAL, &fall_through, Assembler::kNearJump);
   __ movl(EBX, EAX);
   __ SmiUntag(EBX);
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // Left argument (dividend).
   __ SmiUntag(EAX);
   __ pushl(EDX);  // Preserve EDX in case of 'fall_through'.
   __ cdq();
   __ idivl(EBX);
   __ popl(EDX);
   // Check the corner case of dividing the 'MIN_SMI' with -1, in which case we
   // cannot tag the result.
   __ cmpl(EAX, Immediate(0x40000000));
   __ j(EQUAL, &fall_through);
   __ SmiTag(EAX);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Integer_negate(Assembler* assembler) {
+bool Intrinsifier::Integer_negate(Assembler* assembler) {
   Label fall_through;
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);  // Non-smi value.
   __ negl(EAX);
   __ j(OVERFLOW, &fall_through, Assembler::kNearJump);
   // Result is in EAX.
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Integer_bitAndFromInteger(Assembler* assembler) {
+bool Intrinsifier::Integer_bitAndFromInteger(Assembler* assembler) {
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);
   __ movl(EBX, Address(ESP, + 2 * kWordSize));
   __ andl(EAX, EBX);
   // Result is in EAX.
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Integer_bitOrFromInteger(Assembler* assembler) {
+bool Intrinsifier::Integer_bitAnd(Assembler* assembler) {
+  return Integer_bitAndFromInteger(assembler);
+}
+
+
+bool Intrinsifier::Integer_bitOrFromInteger(Assembler* assembler) {
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);
   __ movl(EBX, Address(ESP, + 2 * kWordSize));
   __ orl(EAX, EBX);
   // Result is in EAX.
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Integer_bitXorFromInteger(Assembler* assembler) {
+bool Intrinsifier::Integer_bitOr(Assembler* assembler) {
+  return Integer_bitOrFromInteger(assembler);
+}
+
+
+bool Intrinsifier::Integer_bitXorFromInteger(Assembler* assembler) {
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);
   __ movl(EBX, Address(ESP, + 2 * kWordSize));
   __ xorl(EAX, EBX);
   // Result is in EAX.
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Integer_shl(Assembler* assembler) {
+bool Intrinsifier::Integer_bitXor(Assembler* assembler) {
+  return Integer_bitXorFromInteger(assembler);
+}
+
+
+bool Intrinsifier::Integer_shl(Assembler* assembler) {
   ASSERT(kSmiTagShift == 1);
   ASSERT(kSmiTag == 0);
   Label fall_through, overflow;
   TestBothArgumentsSmis(assembler, &fall_through);
   // Shift value is in EAX. Compare with tagged Smi.
   __ cmpl(EAX, Immediate(Smi::RawValue(Smi::kBits)));
   __ j(ABOVE_EQUAL, &fall_through, Assembler::kNearJump);
 
   __ SmiUntag(EAX);
   __ movl(ECX, EAX);  // Shift amount must be in ECX.
@@ skipping 50 matching lines @@
   __ LoadObject(EAX, bool_false);
   __ ret();
   __ Bind(&true_label);
   __ LoadObject(EAX, bool_true);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Integer_lessThan(Assembler* assembler) {
+bool Intrinsifier::Integer_lessThan(Assembler* assembler) {
   return CompareIntegers(assembler, LESS);
 }
 
 
-static bool Integer_greaterThan(Assembler* assembler) {
+bool Intrinsifier::Integer_greaterThanFromInt(Assembler* assembler) {
+  return CompareIntegers(assembler, LESS);
+}
+
+
+bool Intrinsifier::Integer_greaterThan(Assembler* assembler) {
   return CompareIntegers(assembler, GREATER);
 }
 
 
-static bool Integer_lessEqualThan(Assembler* assembler) {
+bool Intrinsifier::Integer_lessEqualThan(Assembler* assembler) {
   return CompareIntegers(assembler, LESS_EQUAL);
 }
 
 
-static bool Integer_greaterEqualThan(Assembler* assembler) {
+bool Intrinsifier::Integer_greaterEqualThan(Assembler* assembler) {
   return CompareIntegers(assembler, GREATER_EQUAL);
 }
 
 
 // This is called for Smi, Mint and Bigint receivers. Bigints are not handled.
-static bool Integer_equalToInteger(Assembler* assembler) {
+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));
@@ skipping 35 matching lines @@
   __ j(NOT_ZERO, &fall_through);
   __ LoadObject(EAX, bool_false);  // Smi == Mint -> false.
   __ ret();
   // TODO(srdjan): Implement Mint == Mint comparison.
 
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Integer_sar(Assembler* assembler) {
+bool Intrinsifier::Integer_equal(Assembler* assembler) {
+  return Integer_equalToInteger(assembler);
+}
+
+
+bool Intrinsifier::Integer_sar(Assembler* assembler) {
   Label fall_through, shift_count_ok;
   TestBothArgumentsSmis(assembler, &fall_through);
   // Can destroy ECX since we are not falling through.
   Immediate count_limit = Immediate(0x1F);
   // Check that the count is not larger than what the hardware can handle.
   // For shifting right a Smi the result is the same for all numbers
   // >= count_limit.
   __ SmiUntag(EAX);
   // Negative counts throw exception.
   __ cmpl(EAX, Immediate(0));
   __ j(LESS, &fall_through, Assembler::kNearJump);
   __ cmpl(EAX, count_limit);
   __ j(LESS_EQUAL, &shift_count_ok, Assembler::kNearJump);
   __ movl(EAX, count_limit);
   __ Bind(&shift_count_ok);
   __ movl(ECX, EAX);  // Shift amount must be in ECX.
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // Value.
   __ SmiUntag(EAX);  // Value.
   __ sarl(EAX, ECX);
   __ SmiTag(EAX);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Smi_bitNegate(Assembler* assembler) {
+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;
 }
@@ skipping 43 matching lines @@
   __ Bind(&is_smi);
   __ SmiUntag(EAX);
   __ cvtsi2sd(XMM1, EAX);
   __ jmp(&double_op);
   __ Bind(&fall_through);
   return false;
 }
 
 
 // arg0 is Double, arg1 is unknown.
-static bool Double_greaterThan(Assembler* assembler) {
+bool Intrinsifier::Double_greaterThan(Assembler* assembler) {
   return CompareDoubles(assembler, ABOVE);
 }
 
 
 // arg0 is Double, arg1 is unknown.
-static bool Double_greaterEqualThan(Assembler* assembler) {
+bool Intrinsifier::Double_greaterEqualThan(Assembler* assembler) {
   return CompareDoubles(assembler, ABOVE_EQUAL);
 }
 
 
 // arg0 is Double, arg1 is unknown.
-static bool Double_lessThan(Assembler* assembler) {
+bool Intrinsifier::Double_lessThan(Assembler* assembler) {
   return CompareDoubles(assembler, BELOW);
 }
 
 
 // arg0 is Double, arg1 is unknown.
-static bool Double_equal(Assembler* assembler) {
+bool Intrinsifier::Double_equal(Assembler* assembler) {
   return CompareDoubles(assembler, EQUAL);
 }
 
 
 // arg0 is Double, arg1 is unknown.
-static bool Double_lessEqualThan(Assembler* assembler) {
+bool Intrinsifier::Double_lessEqualThan(Assembler* assembler) {
   return CompareDoubles(assembler, BELOW_EQUAL);
 }
 
 
-static bool Double_toDouble(Assembler* assembler) {
+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.
 static bool DoubleArithmeticOperations(Assembler* assembler, Token::Kind kind) {
   Label fall_through;
@@ skipping 17 matching lines @@
                                EBX,  // Class register.
                                &fall_through,
                                EAX);  // Result register.
   __ movsd(FieldAddress(EAX, Double::value_offset()), XMM0);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Double_add(Assembler* assembler) {
+bool Intrinsifier::Double_add(Assembler* assembler) {
   return DoubleArithmeticOperations(assembler, Token::kADD);
 }
 
 
-static bool Double_mul(Assembler* assembler) {
+bool Intrinsifier::Double_mul(Assembler* assembler) {
   return DoubleArithmeticOperations(assembler, Token::kMUL);
 }
 
 
-static bool Double_sub(Assembler* assembler) {
+bool Intrinsifier::Double_sub(Assembler* assembler) {
   return DoubleArithmeticOperations(assembler, Token::kSUB);
 }
 
 
-static bool Double_div(Assembler* assembler) {
+bool Intrinsifier::Double_div(Assembler* assembler) {
   return DoubleArithmeticOperations(assembler, Token::kDIV);
 }
 
 
 // Left is double right is integer (bigint or Smi)
-static bool Double_mulFromInteger(Assembler* assembler) {
+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));
   __ movsd(XMM0, FieldAddress(EAX, Double::value_offset()));
   __ mulsd(XMM0, XMM1);
   const Class& double_class = Class::ZoneHandle(
       Isolate::Current()->object_store()->double_class());
   __ LoadObject(EBX, double_class);
   AssemblerMacros::TryAllocate(assembler,
                                double_class,
                                EBX,  // Class register.
                                &fall_through,
                                EAX);  // Result register.
   __ movsd(FieldAddress(EAX, Double::value_offset()), XMM0);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Double_fromInteger(Assembler* assembler) {
+bool Intrinsifier::Double_fromInteger(Assembler* assembler) {
   Label fall_through;
   __ movl(EAX, Address(ESP, +1 * kWordSize));
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);
   // Is Smi.
   __ SmiUntag(EAX);
   __ cvtsi2sd(XMM0, EAX);
   const Class& double_class = Class::ZoneHandle(
       Isolate::Current()->object_store()->double_class());
   __ LoadObject(EBX, double_class);
   AssemblerMacros::TryAllocate(assembler,
                                double_class,
                                EBX,  // Class register.
                                &fall_through,
                                EAX);  // Result register.
   __ movsd(FieldAddress(EAX, Double::value_offset()), XMM0);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool Double_isNaN(Assembler* assembler) {
+bool Intrinsifier::Double_isNaN(Assembler* assembler) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   Label is_true;
   __ movl(EAX, Address(ESP, +1 * kWordSize));
   __ movsd(XMM0, FieldAddress(EAX, Double::value_offset()));
   __ comisd(XMM0, XMM0);
   __ j(PARITY_EVEN, &is_true, Assembler::kNearJump);  // NaN -> true;
   __ LoadObject(EAX, bool_false);
   __ ret();
   __ Bind(&is_true);
   __ LoadObject(EAX, bool_true);
   __ ret();
   return true;  // Method is complete, no slow case.
 }
 
 
-static bool Double_isNegative(Assembler* assembler) {
+bool Intrinsifier::Double_isNegative(Assembler* assembler) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   Label is_false, is_true, is_zero;
   __ movl(EAX, Address(ESP, +1 * kWordSize));
   __ movsd(XMM0, FieldAddress(EAX, Double::value_offset()));
   __ xorpd(XMM1, XMM1);  // 0.0 -> XMM1.
   __ comisd(XMM0, XMM1);
   __ j(PARITY_EVEN, &is_false, Assembler::kNearJump);  // NaN -> false.
   __ j(EQUAL, &is_zero, Assembler::kNearJump);  // Check for negative zero.
   __ j(ABOVE_EQUAL, &is_false, Assembler::kNearJump);  // >= 0 -> false.
   __ Bind(&is_true);
   __ LoadObject(EAX, bool_true);
   __ ret();
   __ Bind(&is_false);
   __ LoadObject(EAX, bool_false);
   __ ret();
   __ Bind(&is_zero);
   // Check for negative zero (get the sign bit).
   __ movmskpd(EAX, XMM0);
   __ testl(EAX, Immediate(1));
   __ j(NOT_ZERO, &is_true, Assembler::kNearJump);
   __ jmp(&is_false, Assembler::kNearJump);
   return true;  // Method is complete, no slow case.
 }
 
 
 // Argument type is not known
-static bool Math_sqrt(Assembler* assembler) {
+bool Intrinsifier::Math_sqrt(Assembler* assembler) {
   Label fall_through, is_smi, double_op;
   TestLastArgumentIsDouble(assembler, &is_smi, &fall_through);
   // Argument is double and is in EAX, class in EBX.
   __ movsd(XMM1, FieldAddress(EAX, Double::value_offset()));
   __ Bind(&double_op);
   __ sqrtsd(XMM0, XMM1);
   const Class& double_class = Class::ZoneHandle(
       Isolate::Current()->object_store()->double_class());
   __ LoadObject(EBX, double_class);
   AssemblerMacros::TryAllocate(assembler,
@@ skipping 51 matching lines @@
   __ jmp(&double_op);
 
   __ Bind(&alloc_failed);
   __ ffree(0);
   __ fincstp();
 
   __ Bind(&fall_through);
 }
 
 
-static bool Math_sin(Assembler* assembler) {
+bool Intrinsifier::Math_sin(Assembler* assembler) {
   EmitTrigonometric(assembler, kSine);
   return false;  // Compile method for slow case.
 }
 
 
-static bool Math_cos(Assembler* assembler) {
+bool Intrinsifier::Math_cos(Assembler* assembler) {
   EmitTrigonometric(assembler, kCosine);
   return false;  // Compile method for slow case.
 }
 
 
 // Identity comparison.
-static bool Object_equal(Assembler* assembler) {
+bool Intrinsifier::Object_equal(Assembler* assembler) {
   Label is_true;
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
   __ cmpl(EAX, Address(ESP, + 2 * kWordSize));
   __ j(EQUAL, &is_true, Assembler::kNearJump);
   __ LoadObject(EAX, bool_false);
   __ ret();
   __ Bind(&is_true);
   __ LoadObject(EAX, bool_true);
   __ ret();
   return true;
 }
 
 
 static const char* kFixedSizeArrayIteratorClassName = "FixedSizeArrayIterator";
 
 
 // Class 'FixedSizeArrayIterator':
 //   T next() {
 //     return _array[_pos++];
 //   }
 // Intrinsify: return _array[_pos++];
 // TODO(srdjan): Throw a 'NoMoreElementsException' exception if the iterator
 // has no more elements.
-static bool FixedSizeArrayIterator_next(Assembler* assembler) {
+bool Intrinsifier::FixedSizeArrayIterator_next(Assembler* assembler) {
   Label fall_through;
   intptr_t array_offset =
       GetOffsetForField(kFixedSizeArrayIteratorClassName, "_array");
   intptr_t pos_offset =
       GetOffsetForField(kFixedSizeArrayIteratorClassName, "_pos");
   ASSERT(array_offset >= 0 && pos_offset >= 0);
   // Receiver is not NULL.
   __ movl(EAX, Address(ESP, + 1 * kWordSize));  // Receiver.
   __ movl(EBX, FieldAddress(EAX, pos_offset));  // Field _pos.
   // '_pos' cannot be greater than array length and therefore is always Smi.
@@ skipping 21 matching lines @@
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 // Class 'FixedSizeArrayIterator':
 //   bool hasNext() {
 //     return _length > _pos;
 //   }
-static bool FixedSizeArrayIterator_hasNext(Assembler* assembler) {
+bool Intrinsifier::FixedSizeArrayIterator_hasNext(Assembler* assembler) {
   Label fall_through, is_true;
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   intptr_t length_offset =
       GetOffsetForField(kFixedSizeArrayIteratorClassName, "_length");
   intptr_t pos_offset =
       GetOffsetForField(kFixedSizeArrayIteratorClassName, "_pos");
   __ movl(EAX, Address(ESP, + 1 * kWordSize));     // Receiver.
   __ movl(EBX, FieldAddress(EAX, length_offset));  // Field _length.
   __ movl(EAX, FieldAddress(EAX, pos_offset));    // Field _pos.
   __ movl(EDI, EAX);
   __ orl(EDI, EBX);
   __ testl(EDI, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);  // Non-smi _length.
   __ cmpl(EBX, EAX);     // _length > _pos.
   __ j(GREATER, &is_true, Assembler::kNearJump);
   __ LoadObject(EAX, bool_false);
   __ ret();
   __ Bind(&is_true);
   __ LoadObject(EAX, bool_true);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool String_getLength(Assembler* assembler) {
+bool Intrinsifier::String_getLength(Assembler* assembler) {
   __ movl(EAX, Address(ESP, + 1 * kWordSize));  // String object.
   __ movl(EAX, FieldAddress(EAX, String::length_offset()));
   __ ret();
   return true;
 }
 
 
 // TODO(srdjan): Implement for two and four byte strings as well.
-static bool String_charCodeAt(Assembler* assembler) {
+bool Intrinsifier::String_charCodeAt(Assembler* assembler) {
   ObjectStore* object_store = Isolate::Current()->object_store();
   Label fall_through;
   __ movl(EBX, Address(ESP, + 1 * kWordSize));  // Index.
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // String.
   __ testl(EBX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);  // Non-smi index.
   // Range check.
   __ cmpl(EBX, FieldAddress(EAX, String::length_offset()));
   // Runtime throws exception.
   __ j(ABOVE_EQUAL, &fall_through, Assembler::kNearJump);
   __ movl(EDI, FieldAddress(EAX, Instance::class_offset()));
   __ CompareObject(EDI,
       Class::ZoneHandle(object_store->one_byte_string_class()));
   __ j(NOT_EQUAL, &fall_through);
   __ SmiUntag(EBX);
   __ movzxb(EAX, FieldAddress(EAX, EBX, TIMES_1, OneByteString::data_offset()));
   __ SmiTag(EAX);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
-static bool String_hashCode(Assembler* assembler) {
+bool Intrinsifier::String_hashCode(Assembler* assembler) {
   Label fall_through;
   __ movl(EAX, Address(ESP, + 1 * kWordSize));  // String object.
   __ movl(EAX, FieldAddress(EAX, String::hash_offset()));
   __ cmpl(EAX, Immediate(0));
   __ j(EQUAL, &fall_through, Assembler::kNearJump);
   __ ret();
   __ Bind(&fall_through);
   // Hash not yet computed.
   return false;
 }
 
 
-static bool String_isEmpty(Assembler* assembler) {
+bool Intrinsifier::String_isEmpty(Assembler* assembler) {
   Label is_true;
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   // Get length.
   __ movl(EAX, Address(ESP, + 1 * kWordSize));  // String object.
   __ movl(EAX, FieldAddress(EAX, String::length_offset()));
   __ cmpl(EAX, Immediate(Smi::RawValue(0)));
   __ j(EQUAL, &is_true, Assembler::kNearJump);
   __ LoadObject(EAX, bool_false);
   __ ret();
   __ Bind(&is_true);
   __ LoadObject(EAX, bool_true);
   __ ret();
   return true;
 }
 
 #undef __
-
-
-static bool CompareNames(const char* test_name, const char* name) {
-  if (strcmp(test_name, name) == 0) {
-    return true;
-  }
-  if ((name[0] == '_') && (test_name[0] == '_')) {
-    // Check if the private class is member of corelib and matches the
-    // test_class_name.
-    const Library& core_lib = Library::Handle(Library::CoreLibrary());
-    const Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
-    String& test_str = String::Handle(String::New(test_name));
-    String& test_str_with_key = String::Handle();
-    test_str_with_key =
-        String::Concat(test_str, String::Handle(core_lib.private_key()));
-    if (strcmp(test_str_with_key.ToCString(), name) == 0) {
-      return true;
-    }
-    test_str_with_key =
-        String::Concat(test_str, String::Handle(core_impl_lib.private_key()));
-    if (strcmp(test_str_with_key.ToCString(), name) == 0) {
-      return true;
-    }
-  }
-  return false;
-}
-
-
-// Returns true if the function matches function_name and class_name, with
-// special recognition of corelib private classes
-static bool TestFunction(const Function& function,
-                         const char* function_class_name,
-                         const char* function_name,
-                         const char* test_class_name,
-                         const char* test_function_name) {
-  return CompareNames(test_class_name, function_class_name) &&
-         CompareNames(test_function_name, function_name);
-}
-
-
-bool Intrinsifier::Intrinsify(const Function& function, Assembler* assembler) {
-  if (!FLAG_intrinsify) return false;
-  const char* function_name = String::Handle(function.name()).ToCString();
-  const Class& function_class = Class::Handle(function.owner());
-  const char* class_name = String::Handle(function_class.Name()).ToCString();
-  // Only core library methods can be intrinsified.
-  const Library& core_lib = Library::Handle(Library::CoreLibrary());
-  const Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
-  if ((function_class.library() != core_lib.raw()) &&
-      (function_class.library() != core_impl_lib.raw())) {
-    return false;
-  }
-#define FIND_INTRINSICS(test_class_name, test_function_name, destination)      \
-  if (TestFunction(function,                                                   \
-                   class_name, function_name,                                  \
-                   #test_class_name, #test_function_name)) {                   \
-    return destination(assembler);                                             \
-  }                                                                            \
-
-INTRINSIC_LIST(FIND_INTRINSICS);
-#undef FIND_INTRINSICS
-  return false;
-}
-
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32