Version 0.8.10.4

dart/runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 462 matching lines @@
     class_class_ = reinterpret_cast<RawClass*>(address + kHeapObjectTag);
     InitializeObject(address, Class::kClassId, size);
 
     Class fake;
     // Initialization from Class::New<Class>.
     // Directly set raw_ to break a circular dependency: SetRaw will attempt
     // to lookup class class in the class table where it is not registered yet.
     cls.raw_ = class_class_;
     cls.set_handle_vtable(fake.vtable());
     cls.set_instance_size(Class::InstanceSize());
-    cls.set_next_field_offset(Class::InstanceSize());
+    cls.set_next_field_offset(Class::NextFieldOffset());
     cls.set_id(Class::kClassId);
     cls.set_state_bits(0);
     cls.set_is_finalized();
     cls.set_is_type_finalized();
     cls.set_type_arguments_field_offset_in_words(Class::kNoTypeArguments);
     cls.set_num_type_arguments(0);
     cls.set_num_own_type_arguments(0);
     cls.set_num_native_fields(0);
     cls.InitEmptyFields();
     isolate->RegisterClass(cls);
@@ skipping 647 matching lines @@
   pending_classes.Add(cls);
 #undef REGISTER_TYPED_DATA_VIEW_CLASS
 #define REGISTER_EXT_TYPED_DATA_CLASS(clazz)                                   \
   cls = Class::NewExternalTypedDataClass(kExternalTypedData##clazz##Cid);      \
   index = kExternalTypedData##clazz##Cid - kTypedDataInt8ArrayCid;             \
   typed_data_classes.SetAt(index, cls);                                        \
   RegisterPrivateClass(cls, Symbols::_External##clazz(), lib);                 \
 
   CLASS_LIST_TYPED_DATA(REGISTER_EXT_TYPED_DATA_CLASS);
 #undef REGISTER_EXT_TYPED_DATA_CLASS
-  // Register Float32x4 and Uint32x4 in the object store.
+  // Register Float32x4 and Int32x4 in the object store.
   cls = Class::New<Float32x4>();
   object_store->set_float32x4_class(cls);
   RegisterPrivateClass(cls, Symbols::_Float32x4(), lib);
-  cls = Class::New<Uint32x4>();
-  object_store->set_uint32x4_class(cls);
-  RegisterPrivateClass(cls, Symbols::_Uint32x4(), lib);
+  cls = Class::New<Int32x4>();
+  object_store->set_int32x4_class(cls);
+  RegisterPrivateClass(cls, Symbols::_Int32x4(), lib);
 
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Float32x4(), lib);
   cls.set_num_type_arguments(0);
   cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_float32x4_type(type);
 
   cls = Class::New<Instance>(kIllegalCid);
-  RegisterClass(cls, Symbols::Uint32x4(), lib);
+  RegisterClass(cls, Symbols::Int32x4(), lib);
   cls.set_num_type_arguments(0);
   cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
-  object_store->set_uint32x4_type(type);
+  object_store->set_int32x4_type(type);
 
   object_store->set_typed_data_classes(typed_data_classes);
 
   // Set the super type of class Stacktrace to Object type so that the
   // 'toString' method is implemented.
   cls = object_store->stacktrace_class();
   type = object_store->object_type();
   cls.set_super_type(type);
 
   // Abstract class that represents the Dart class Function.
@@ skipping 115 matching lines @@
 
   cls = Class::New<Array>(kImmutableArrayCid);
   object_store->set_immutable_array_class(cls);
 
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
 
   cls = Class::New<Float32x4>();
   object_store->set_float32x4_class(cls);
 
-  cls = Class::New<Uint32x4>();
-  object_store->set_uint32x4_class(cls);
+  cls = Class::New<Int32x4>();
+  object_store->set_int32x4_class(cls);
 
 #define REGISTER_TYPED_DATA_CLASS(clazz)                                       \
   cls = Class::NewTypedDataClass(kTypedData##clazz##Cid);
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_CLASS);
 #undef REGISTER_TYPED_DATA_CLASS
 #define REGISTER_TYPED_DATA_VIEW_CLASS(clazz)                                  \
   cls = Class::NewTypedDataViewClass(kTypedData##clazz##ViewCid);
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_VIEW_CLASS);
   cls = Class::NewTypedDataViewClass(kByteDataViewCid);
 #undef REGISTER_TYPED_DATA_VIEW_CLASS
@@ skipping 204 matching lines @@
     case kTwoByteStringCid:
     case kExternalOneByteStringCid:
     case kExternalTwoByteStringCid:
       return Symbols::New("String");
     case kArrayCid:
     case kImmutableArrayCid:
     case kGrowableObjectArrayCid:
       return Symbols::List().raw();
     case kFloat32x4Cid:
       return Symbols::Float32x4().raw();
-    case kUint32x4Cid:
-      return Symbols::Uint32x4().raw();
+    case kInt32x4Cid:
+      return Symbols::Int32x4().raw();
     case kTypedDataInt8ArrayCid:
     case kExternalTypedDataInt8ArrayCid:
       return Symbols::Int8List().raw();
     case kTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ArrayCid:
       return Symbols::Uint8List().raw();
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
       return Symbols::Uint8ClampedList().raw();
     case kTypedDataInt16ArrayCid:
@@ skipping 106 matching lines @@
   {
     RawObject* raw = Object::Allocate(Class::kClassId,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeObject fake;
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeObject::InstanceSize());
-  result.set_next_field_offset(FakeObject::InstanceSize());
+  result.set_next_field_offset(FakeObject::NextFieldOffset());
   ASSERT((FakeObject::kClassId != kInstanceCid));
   result.set_id(FakeObject::kClassId);
   result.set_state_bits(0);
   // VM backed classes are almost ready: run checks and resolve class
   // references, but do not recompute size.
   result.set_is_prefinalized();
   result.set_type_arguments_field_offset_in_words(kNoTypeArguments);
   result.set_num_type_arguments(0);
   result.set_num_own_type_arguments(0);
   result.set_num_native_fields(0);
@@ skipping 349 matching lines @@
   return TypeParameter::null();
 }
 
 
 void Class::CalculateFieldOffsets() const {
   Array& flds = Array::Handle(fields());
   const Class& super = Class::Handle(SuperClass());
   intptr_t offset = 0;
   intptr_t type_args_field_offset = kNoTypeArguments;
   if (super.IsNull()) {
-    offset = sizeof(RawObject);
+    offset = Instance::NextFieldOffset();
+    ASSERT(offset > 0);
   } else {
     ASSERT(super.is_finalized() || super.is_prefinalized());
     type_args_field_offset = super.type_arguments_field_offset();
     offset = super.next_field_offset();
     ASSERT(offset > 0);
     // We should never call CalculateFieldOffsets for native wrapper
     // classes, assert this.
     ASSERT(num_native_fields() == 0);
     set_num_native_fields(super.num_native_fields());
   }
   // If the super class is parameterized, use the same type_arguments field,
   // otherwise, if this class is the first in the super chain to be
   // parameterized, introduce a new type_arguments field.
   if (type_args_field_offset == kNoTypeArguments) {
     const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
     if (!type_params.IsNull()) {
       ASSERT(type_params.Length() > 0);
       // The instance needs a type_arguments field.
       type_args_field_offset = offset;
       offset += kWordSize;
     }
   }
   set_type_arguments_field_offset(type_args_field_offset);
-  ASSERT(offset != 0);
+  ASSERT(offset > 0);
   Field& field = Field::Handle();
   intptr_t len = flds.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= flds.At(i);
     // Offset is computed only for instance fields.
     if (!field.is_static()) {
       ASSERT(field.Offset() == 0);
       field.SetOffset(offset);
       offset += kWordSize;
     }
@@ skipping 317 matching lines @@
     RawObject* raw = Object::Allocate(Class::kClassId,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeInstance fake;
   ASSERT(fake.IsInstance());
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeInstance::InstanceSize());
-  result.set_next_field_offset(FakeInstance::InstanceSize());
+  result.set_next_field_offset(FakeInstance::NextFieldOffset());
   result.set_id(index);
   result.set_state_bits(0);
   result.set_type_arguments_field_offset_in_words(kNoTypeArguments);
   result.set_num_type_arguments(kUnknownNumTypeArguments);
   result.set_num_own_type_arguments(kUnknownNumTypeArguments);
   result.set_num_native_fields(0);
   result.set_token_pos(Scanner::kDummyTokenIndex);
   result.InitEmptyFields();
   Isolate::Current()->RegisterClass(result);
   return result.raw();
@@ skipping 11 matching lines @@
 }
 
 
 RawClass* Class::NewSignatureClass(const String& name,
                                    const Function& signature_function,
                                    const Script& script,
                                    intptr_t token_pos) {
   const Class& result = Class::Handle(New(name, script, token_pos));
   // Instances of a signature class can only be closures.
   result.set_instance_size(Closure::InstanceSize());
-  result.set_next_field_offset(Closure::InstanceSize());
+  result.set_next_field_offset(Closure::NextFieldOffset());
   // Signature classes extend the _FunctionImpl class.
   result.set_super_type(Type::Handle(
       Isolate::Current()->object_store()->function_impl_type()));
   result.set_is_synthesized_class();
   result.set_type_arguments_field_offset(Closure::type_arguments_offset());
   if (!signature_function.IsNull()) {
     result.PatchSignatureFunction(signature_function);
   }
   return result.raw();
 }
@@ skipping 51 matching lines @@
                                   int field_count) {
   Class& cls = Class::Handle(library.LookupClass(name));
   if (cls.IsNull()) {
     cls = New(name, Script::Handle(), Scanner::kDummyTokenIndex);
     cls.SetFields(Object::empty_array());
     cls.SetFunctions(Object::empty_array());
     // Set super class to Object.
     cls.set_super_type(Type::Handle(Type::ObjectType()));
     // Compute instance size. First word contains a pointer to a properly
     // sized typed array once the first native field has been set.
-    intptr_t instance_size = sizeof(RawObject) + kWordSize;
+    intptr_t instance_size = sizeof(RawInstance) + kWordSize;
     cls.set_instance_size(RoundedAllocationSize(instance_size));
     cls.set_next_field_offset(instance_size);
     cls.set_num_native_fields(field_count);
     cls.set_is_finalized();
     cls.set_is_type_finalized();
     library.AddClass(cls);
     return cls.raw();
   } else {
     return Class::null();
   }
 }
 
 
 RawClass* Class::NewStringClass(intptr_t class_id) {
   intptr_t instance_size;
   if (class_id == kOneByteStringCid) {
     instance_size = OneByteString::InstanceSize();
   } else if (class_id == kTwoByteStringCid) {
     instance_size = TwoByteString::InstanceSize();
   } else if (class_id == kExternalOneByteStringCid) {
     instance_size = ExternalOneByteString::InstanceSize();
   } else {
     ASSERT(class_id == kExternalTwoByteStringCid);
     instance_size = ExternalTwoByteString::InstanceSize();
   }
   Class& result = Class::Handle(New<String>(class_id));
   result.set_instance_size(instance_size);
-  result.set_next_field_offset(instance_size);
+  result.set_next_field_offset(String::NextFieldOffset());
   result.set_is_prefinalized();
   return result.raw();
 }
 
 
 RawClass* Class::NewTypedDataClass(intptr_t class_id) {
   ASSERT(RawObject::IsTypedDataClassId(class_id));
   intptr_t instance_size = TypedData::InstanceSize();
   Class& result = Class::Handle(New<TypedData>(class_id));
   result.set_instance_size(instance_size);
-  result.set_next_field_offset(instance_size);
+  result.set_next_field_offset(TypedData::NextFieldOffset());
   result.set_is_prefinalized();
   return result.raw();
 }
 
 
 RawClass* Class::NewTypedDataViewClass(intptr_t class_id) {
   ASSERT(RawObject::IsTypedDataViewClassId(class_id));
   Class& result = Class::Handle(New<Instance>(class_id));
   result.set_instance_size(0);
-  result.set_next_field_offset(0);
+  result.set_next_field_offset(-kWordSize);
   return result.raw();
 }
 
 
 RawClass* Class::NewExternalTypedDataClass(intptr_t class_id) {
   ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
   intptr_t instance_size = ExternalTypedData::InstanceSize();
   Class& result = Class::Handle(New<ExternalTypedData>(class_id));
   result.set_instance_size(instance_size);
-  result.set_next_field_offset(instance_size);
+  result.set_next_field_offset(ExternalTypedData::NextFieldOffset());
   result.set_is_prefinalized();
   return result.raw();
 }
 
 
 void Class::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
@@ skipping 158 matching lines @@
   return (!function.IsNull() && (function.signature_class() == raw()));
 }
 
 
 // If test_kind == kIsSubtypeOf, checks if type S is a subtype of type T.
 // If test_kind == kIsMoreSpecificThan, checks if S is more specific than T.
 // Type S is specified by this class parameterized with 'type_arguments', and
 // type T by class 'other' parameterized with 'other_type_arguments'.
 // This class and class 'other' do not need to be finalized, however, they must
 // be resolved as well as their interfaces.
+bool Class::TypeTestNonRecursive(
+    const Class& cls,
+    Class::TypeTestKind test_kind,
+    const AbstractTypeArguments& type_arguments,
+    const Class& other,
+    const AbstractTypeArguments& other_type_arguments,
+    Error* bound_error) {
+  // Use the thsi object as if it was the receiver of this method, but instead
+  // of recursing reset it to the super class and loop.
+  Class& thsi = Class::Handle(cls.raw());
+  while (true) {
+    ASSERT(!thsi.IsVoidClass());
+    // Check for DynamicType.
+    // Each occurrence of DynamicType in type T is interpreted as the dynamic
+    // type, a supertype of all types.
+    if (other.IsDynamicClass()) {
+      return true;
+    }
+    // In the case of a subtype test, each occurrence of DynamicType in type S
+    // is interpreted as the bottom type, a subtype of all types.
+    // However, DynamicType is not more specific than any type.
+    if (thsi.IsDynamicClass()) {
+      return test_kind == Class::kIsSubtypeOf;
+    }
+    // Check for NullType, which is only a subtype of ObjectType, of
+    // DynamicType, or of itself, and which is more specific than any type.
+    if (thsi.IsNullClass()) {
+      // We already checked for other.IsDynamicClass() above.
+      return (test_kind == Class::kIsMoreSpecificThan) ||
+      other.IsObjectClass() || other.IsNullClass();
+    }
+    // Check for ObjectType. Any type that is not NullType or DynamicType
+    // (already checked above), is more specific than ObjectType.
+    if (other.IsObjectClass()) {
+      return true;
+    }
+    // Check for reflexivity.
+    if (thsi.raw() == other.raw()) {
+      const intptr_t len = thsi.NumTypeArguments();
+      if (len == 0) {
+        return true;
+      }
+      // Since we do not truncate the type argument vector of a subclass (see
+      // below), we only check a prefix of the proper length.
+      // Check for covariance.
+      if (other_type_arguments.IsNull() || other_type_arguments.IsRaw(len)) {
+        return true;
+      }
+      if (type_arguments.IsNull() || type_arguments.IsRaw(len)) {
+        // Other type can't be more specific than this one because for that
+        // it would have to have all dynamic type arguments which is checked
+        // above.
+        return test_kind == Class::kIsSubtypeOf;
+      }
+      return type_arguments.TypeTest(test_kind,
+                                     other_type_arguments,
+                                     len,
+                                     bound_error);
+    }
+    const bool other_is_function_class = other.IsFunctionClass();
+    if (other.IsSignatureClass() || other_is_function_class) {
+      const Function& other_fun = Function::Handle(other.signature_function());
+      if (thsi.IsSignatureClass()) {
+        if (other_is_function_class) {
+          return true;
+        }
+        // Check for two function types.
+        const Function& fun = Function::Handle(thsi.signature_function());
+        return fun.TypeTest(test_kind,
+                            type_arguments,
+                            other_fun,
+                            other_type_arguments,
+                            bound_error);
+      }
+      // Check if type S has a call() method of function type T.
+      Function& function =
+      Function::Handle(thsi.LookupDynamicFunction(Symbols::Call()));
+      if (function.IsNull()) {
+        // Walk up the super_class chain.
+        Class& cls = Class::Handle(thsi.SuperClass());
+        while (!cls.IsNull() && function.IsNull()) {
+          function = cls.LookupDynamicFunction(Symbols::Call());
+          cls = cls.SuperClass();
+        }
+      }
+      if (!function.IsNull()) {
+        if (other_is_function_class ||
+            function.TypeTest(test_kind,
+                              type_arguments,
+                              other_fun,
+                              other_type_arguments,
+                              bound_error)) {
+              return true;
+            }
+      }
+    }
+    // Check for 'direct super type' specified in the implements clause
+    // and check for transitivity at the same time.
+    Array& interfaces = Array::Handle(thsi.interfaces());
+    AbstractType& interface = AbstractType::Handle();
+    Class& interface_class = Class::Handle();
+    AbstractTypeArguments& interface_args = AbstractTypeArguments::Handle();
+    Error& error = Error::Handle();
+    for (intptr_t i = 0; i < interfaces.Length(); i++) {
+      interface ^= interfaces.At(i);
+      if (!interface.IsFinalized()) {
+        // We may be checking bounds at finalization time. Skipping this
+        // unfinalized interface will postpone bound checking to run time.
+        continue;
+      }
+      error = Error::null();
+      if (interface.IsMalboundedWithError(&error)) {
+        // Return the first bound error to the caller if it requests it.
+        if ((bound_error != NULL) && bound_error->IsNull()) {
+          ASSERT(!error.IsNull());
+          *bound_error = error.raw();
+        }
+        continue;  // Another interface may work better.
+      }
+      interface_class = interface.type_class();
+      interface_args = interface.arguments();
+      if (!interface_args.IsNull() && !interface_args.IsInstantiated()) {
+        // This type class implements an interface that is parameterized with
+        // generic type(s), e.g. it implements List<T>.
+        // The uninstantiated type T must be instantiated using the type
+        // parameters of this type before performing the type test.
+        // The type arguments of this type that are referred to by the type
+        // parameters of the interface are at the end of the type vector,
+        // after the type arguments of the super type of this type.
+        // The index of the type parameters is adjusted upon finalization.
+        error = Error::null();
+        interface_args = interface_args.InstantiateFrom(type_arguments, &error);
+        if (!error.IsNull()) {
+          // Return the first bound error to the caller if it requests it.
+          if ((bound_error != NULL) && bound_error->IsNull()) {
+            *bound_error = error.raw();
+          }
+          continue;  // Another interface may work better.
+        }
+      }
+      if (interface_class.TypeTest(test_kind,
+                                   interface_args,
+                                   other,
+                                   other_type_arguments,
+                                   bound_error)) {
+        return true;
+      }
+    }
+    // "Recurse" up the class hierarchy until we have reached the top.
+    thsi = thsi.SuperClass();
+    if (thsi.IsNull()) {
+      return false;
+    }
+  }
+  UNREACHABLE();
+  return false;
+}
+
+
+// If test_kind == kIsSubtypeOf, checks if type S is a subtype of type T.
+// If test_kind == kIsMoreSpecificThan, checks if S is more specific than T.
+// Type S is specified by this class parameterized with 'type_arguments', and
+// type T by class 'other' parameterized with 'other_type_arguments'.
+// This class and class 'other' do not need to be finalized, however, they must
+// be resolved as well as their interfaces.
 bool Class::TypeTest(
-    TypeTestKind test_kind,
-    const AbstractTypeArguments& type_arguments,
-    const Class& other,
-    const AbstractTypeArguments& other_type_arguments,
-    Error* bound_error) const {
-  ASSERT(!IsVoidClass());
-  // Check for DynamicType.
-  // Each occurrence of DynamicType in type T is interpreted as the dynamic
-  // type, a supertype of all types.
-  if (other.IsDynamicClass()) {
-    return true;
-  }
-  // In the case of a subtype test, each occurrence of DynamicType in type S is
-  // interpreted as the bottom type, a subtype of all types.
-  // However, DynamicType is not more specific than any type.
-  if (IsDynamicClass()) {
-    return test_kind == kIsSubtypeOf;
-  }
-  // Check for NullType, which is only a subtype of ObjectType, of DynamicType,
-  // or of itself, and which is more specific than any type.
-  if (IsNullClass()) {
-    // We already checked for other.IsDynamicClass() above.
-    return (test_kind == kIsMoreSpecificThan) ||
-        other.IsObjectClass() || other.IsNullClass();
-  }
-  // Check for ObjectType. Any type that is not NullType or DynamicType (already
-  // checked above), is more specific than ObjectType.
-  if (other.IsObjectClass()) {
-    return true;
-  }
-  // Check for reflexivity.
-  if (raw() == other.raw()) {
-    const intptr_t len = NumTypeArguments();
-    if (len == 0) {
-      return true;
-    }
-    // Since we do not truncate the type argument vector of a subclass (see
-    // below), we only check a prefix of the proper length.
-    // Check for covariance.
-    if (other_type_arguments.IsNull() || other_type_arguments.IsRaw(len)) {
-      return true;
-    }
-    if (type_arguments.IsNull() || type_arguments.IsRaw(len)) {
-      // Other type can't be more specific than this one because for that
-      // it would have to have all dynamic type arguments which is checked
-      // above.
-      return test_kind == kIsSubtypeOf;
-    }
-    return type_arguments.TypeTest(test_kind,
-                                   other_type_arguments,
-                                   len,
-                                   bound_error);
-  }
-  const bool other_is_function_class = other.IsFunctionClass();
-  if (other.IsSignatureClass() || other_is_function_class) {
-    const Function& other_fun = Function::Handle(other.signature_function());
-    if (IsSignatureClass()) {
-      if (other_is_function_class) {
-        return true;
-      }
-      // Check for two function types.
-      const Function& fun = Function::Handle(signature_function());
-      return fun.TypeTest(test_kind,
-                          type_arguments,
-                          other_fun,
-                          other_type_arguments,
-                          bound_error);
-    }
-    // Check if type S has a call() method of function type T.
-    Function& function =
-        Function::Handle(LookupDynamicFunction(Symbols::Call()));
-    if (function.IsNull()) {
-      // Walk up the super_class chain.
-      Class& cls = Class::Handle(SuperClass());
-      while (!cls.IsNull() && function.IsNull()) {
-        function = cls.LookupDynamicFunction(Symbols::Call());
-        cls = cls.SuperClass();
-      }
-    }
-    if (!function.IsNull()) {
-      if (other_is_function_class ||
-          function.TypeTest(test_kind,
-                            type_arguments,
-                            other_fun,
-                            other_type_arguments,
-                            bound_error)) {
-        return true;
-      }
-    }
-  }
-  // Check for 'direct super type' specified in the implements clause
-  // and check for transitivity at the same time.
-  Array& interfaces = Array::Handle(this->interfaces());
-  AbstractType& interface = AbstractType::Handle();
-  Class& interface_class = Class::Handle();
-  AbstractTypeArguments& interface_args = AbstractTypeArguments::Handle();
-  Error& error = Error::Handle();
-  for (intptr_t i = 0; i < interfaces.Length(); i++) {
-    interface ^= interfaces.At(i);
-    if (!interface.IsFinalized()) {
-      // We may be checking bounds at finalization time. Skipping this
-      // unfinalized interface will postpone bound checking to run time.
-      continue;
-    }
-    error = Error::null();
-    if (interface.IsMalboundedWithError(&error)) {
-      // Return the first bound error to the caller if it requests it.
-      if ((bound_error != NULL) && bound_error->IsNull()) {
-        ASSERT(!error.IsNull());
-        *bound_error = error.raw();
-      }
-      continue;  // Another interface may work better.
-    }
-    interface_class = interface.type_class();
-    interface_args = interface.arguments();
-    if (!interface_args.IsNull() && !interface_args.IsInstantiated()) {
-      // This type class implements an interface that is parameterized with
-      // generic type(s), e.g. it implements List<T>.
-      // The uninstantiated type T must be instantiated using the type
-      // parameters of this type before performing the type test.
-      // The type arguments of this type that are referred to by the type
-      // parameters of the interface are at the end of the type vector,
-      // after the type arguments of the super type of this type.
-      // The index of the type parameters is adjusted upon finalization.
-      error = Error::null();
-      interface_args = interface_args.InstantiateFrom(type_arguments, &error);
-      if (!error.IsNull()) {
-        // Return the first bound error to the caller if it requests it.
-        if ((bound_error != NULL) && bound_error->IsNull()) {
-          *bound_error = error.raw();
-        }
-        continue;  // Another interface may work better.
-      }
-    }
-    if (interface_class.TypeTest(test_kind,
-                                 interface_args,
-                                 other,
-                                 other_type_arguments,
-                                 bound_error)) {
-      return true;
-    }
-  }
-  const Class& super_class = Class::Handle(SuperClass());
-  if (super_class.IsNull()) {
-    return false;
-  }
-  // Instead of truncating the type argument vector to the length of the super
-  // type argument vector, we make sure that the code works with a vector that
-  // is longer than necessary.
-  return super_class.TypeTest(test_kind,
+                     TypeTestKind test_kind,
+                     const AbstractTypeArguments& type_arguments,
+                     const Class& other,
+                     const AbstractTypeArguments& other_type_arguments,
+                     Error* bound_error) const {
+  return TypeTestNonRecursive(*this,
+                              test_kind,
                               type_arguments,
                               other,
                               other_type_arguments,
                               bound_error);
 }
 
 
 bool Class::IsTopLevel() const {
   return Name() == Symbols::TopLevel().raw();
 }
@@ skipping 7922 matching lines @@
     return false;
   }
 
   {
     NoGCScope no_gc;
     // Raw bits compare.
     const intptr_t instance_size = Class::Handle(this->clazz()).instance_size();
     ASSERT(instance_size != 0);
     uword this_addr = reinterpret_cast<uword>(this->raw_ptr());
     uword other_addr = reinterpret_cast<uword>(other.raw_ptr());
-    for (intptr_t offset = sizeof(RawObject);
+    for (intptr_t offset = Instance::NextFieldOffset();
          offset < instance_size;
          offset += kWordSize) {
       if ((*reinterpret_cast<RawObject**>(this_addr + offset)) !=
           (*reinterpret_cast<RawObject**>(other_addr + offset))) {
         return false;
       }
     }
   }
   return true;
 }
@@ skipping 559 matching lines @@
       (type_class() == Type::Handle(Type::Double()).type_class());
 }
 
 
 bool AbstractType::IsFloat32x4Type() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::Float32x4()).type_class());
 }
 
 
-bool AbstractType::IsUint32x4Type() const {
+bool AbstractType::IsInt32x4Type() const {
   return HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::Uint32x4()).type_class());
+      (type_class() == Type::Handle(Type::Int32x4()).type_class());
 }
 
 
 bool AbstractType::IsNumberType() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::Number()).type_class());
 }
 
 
 bool AbstractType::IsStringType() const {
@@ skipping 142 matching lines @@
 RawType* Type::Double() {
   return Isolate::Current()->object_store()->double_type();
 }
 
 
 RawType* Type::Float32x4() {
   return Isolate::Current()->object_store()->float32x4_type();
 }
 
 
-RawType* Type::Uint32x4() {
-  return Isolate::Current()->object_store()->uint32x4_type();
+RawType* Type::Int32x4() {
+  return Isolate::Current()->object_store()->int32x4_type();
 }
 
 
 RawType* Type::Number() {
   return Isolate::Current()->object_store()->number_type();
 }
 
 
 RawType* Type::StringType() {
   return Isolate::Current()->object_store()->string_type();
@@ skipping 3456 matching lines @@
   OS::SNPrint(chars, len, kFormat, _x, _y, _z, _w);
   return chars;
 }
 
 
 void Float32x4::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
-RawUint32x4* Uint32x4::New(uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3,
-                           Heap::Space space) {
-  ASSERT(Isolate::Current()->object_store()->uint32x4_class() !=
+RawInt32x4* Int32x4::New(int32_t v0, int32_t v1, int32_t v2, int32_t v3,
+                         Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->int32x4_class() !=
          Class::null());
-  Uint32x4& result = Uint32x4::Handle();
+  Int32x4& result = Int32x4::Handle();
   {
-    RawObject* raw = Object::Allocate(Uint32x4::kClassId,
-                                      Uint32x4::InstanceSize(),
+    RawObject* raw = Object::Allocate(Int32x4::kClassId,
+                                      Int32x4::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_x(v0);
   result.set_y(v1);
   result.set_z(v2);
   result.set_w(v3);
   return result.raw();
 }
 
 
-RawUint32x4* Uint32x4::New(simd128_value_t value, Heap::Space space) {
-  ASSERT(Isolate::Current()->object_store()->float32x4_class() !=
+RawInt32x4* Int32x4::New(simd128_value_t value, Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->int32x4_class() !=
          Class::null());
-  Uint32x4& result = Uint32x4::Handle();
+  Int32x4& result = Int32x4::Handle();
   {
-    RawObject* raw = Object::Allocate(Uint32x4::kClassId,
-                                      Uint32x4::InstanceSize(),
+    RawObject* raw = Object::Allocate(Int32x4::kClassId,
+                                      Int32x4::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_value(value);
   return result.raw();
 }
 
 
-void Uint32x4::set_x(uint32_t value) const {
+void Int32x4::set_x(int32_t value) const {
   raw_ptr()->value_[0] = value;
 }
 
 
-void Uint32x4::set_y(uint32_t value) const {
+void Int32x4::set_y(int32_t value) const {
   raw_ptr()->value_[1] = value;
 }
 
 
-void Uint32x4::set_z(uint32_t value) const {
+void Int32x4::set_z(int32_t value) const {
   raw_ptr()->value_[2] = value;
 }
 
 
-void Uint32x4::set_w(uint32_t value) const {
+void Int32x4::set_w(int32_t value) const {
   raw_ptr()->value_[3] = value;
 }
 
 
-uint32_t Uint32x4::x() const {
+int32_t Int32x4::x() const {
   return raw_ptr()->value_[0];
 }
 
 
-uint32_t Uint32x4::y() const {
+int32_t Int32x4::y() const {
   return raw_ptr()->value_[1];
 }
 
 
-uint32_t Uint32x4::z() const {
+int32_t Int32x4::z() const {
   return raw_ptr()->value_[2];
 }
 
 
-uint32_t Uint32x4::w() const {
+int32_t Int32x4::w() const {
   return raw_ptr()->value_[3];
 }
 
 
-simd128_value_t Uint32x4::value() const {
+simd128_value_t Int32x4::value() const {
   return simd128_value_t().readFrom(&raw_ptr()->value_[0]);
 }
 
 
-void Uint32x4::set_value(simd128_value_t value) const {
+void Int32x4::set_value(simd128_value_t value) const {
   value.writeTo(&raw_ptr()->value_[0]);
 }
 
 
-const char* Uint32x4::ToCString() const {
+const char* Int32x4::ToCString() const {
   const char* kFormat = "[%08x, %08x, %08x, %08x]";
-  uint32_t _x = x();
-  uint32_t _y = y();
-  uint32_t _z = z();
-  uint32_t _w = w();
+  int32_t _x = x();
+  int32_t _y = y();
+  int32_t _z = z();
+  int32_t _w = w();
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, _x, _y, _z, _w) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, _x, _y, _z, _w);
   return chars;
 }
 
 
-void Uint32x4::PrintToJSONStream(JSONStream* stream, bool ref) const {
+void Int32x4::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 const intptr_t TypedData::element_size[] = {
   1,   // kTypedDataInt8ArrayCid.
   1,   // kTypedDataUint8ArrayCid.
   1,   // kTypedDataUint8ClampedArrayCid.
   2,   // kTypedDataInt16ArrayCid.
   2,   // kTypedDataUint16ArrayCid.
   4,   // kTypedDataInt32ArrayCid.
   4,   // kTypedDataUint32ArrayCid.
   8,   // kTypedDataInt64ArrayCid.
   8,   // kTypedDataUint64ArrayCid.
   4,   // kTypedDataFloat32ArrayCid.
   8,   // kTypedDataFloat64ArrayCid.
   16,  // kTypedDataFloat32x4ArrayCid.
-  16,  // kTypedDataUint32x4ArrayCid.
+  16,  // kTypedDataInt32x4ArrayCid.
 };
 
 
 RawTypedData* TypedData::New(intptr_t class_id,
                              intptr_t len,
                              Heap::Space space) {
   if (len < 0 || len > TypedData::MaxElements(class_id)) {
     FATAL1("Fatal error in TypedData::New: invalid len %" Pd "\n", len);
   }
   TypedData& result = TypedData::Handle();
@@ skipping 532 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart