More cleanup based on profile information.

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 303 matching lines @@
     Object fake_object;
     Smi fake_smi;
     Object::handle_vtable_ = fake_object.vtable();
     Smi::handle_vtable_ = fake_smi.vtable();
   }
 
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
 
   // Allocate the read only object handles here.
-  empty_array_ = Array::ReadOnlyHandle(isolate);
-  sentinel_ = Instance::ReadOnlyHandle(isolate);
-  transition_sentinel_ = Instance::ReadOnlyHandle(isolate);
-  unknown_constant_ =  Instance::ReadOnlyHandle(isolate);
-  non_constant_ =  Instance::ReadOnlyHandle(isolate);
-  bool_true_ = Bool::ReadOnlyHandle(isolate);
-  bool_false_ = Bool::ReadOnlyHandle(isolate);
-  snapshot_writer_error_ = LanguageError::ReadOnlyHandle(isolate);
+  empty_array_ = Array::ReadOnlyHandle();
+  sentinel_ = Instance::ReadOnlyHandle();
+  transition_sentinel_ = Instance::ReadOnlyHandle();
+  unknown_constant_ =  Instance::ReadOnlyHandle();
+  non_constant_ =  Instance::ReadOnlyHandle();
+  bool_true_ = Bool::ReadOnlyHandle();
+  bool_false_ = Bool::ReadOnlyHandle();
+  snapshot_writer_error_ = LanguageError::ReadOnlyHandle();
 
   // Allocate and initialize the null instance.
   // 'null_' must be the first object allocated as it is used in allocation to
   // clear the object.
   {
     uword address = heap->Allocate(Instance::InstanceSize(), Heap::kOld);
     null_ = reinterpret_cast<RawInstance*>(address + kHeapObjectTag);
     // The call below is using 'null_' to initialize itself.
     InitializeObject(address, kNullCid, Instance::InstanceSize());
   }
@@ skipping 1228 matching lines @@
   }
   const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
   return type_params.Length();
 }
 
 
 intptr_t Class::NumTypeArguments() const {
   // To work properly, this call requires the super class of this class to be
   // resolved, which is checked by the SuperClass() call.
   Class& cls = Class::Handle(raw());
-  if (IsSignatureClass()) {
-    const Function& signature_fun = Function::Handle(signature_function());
-    if (!signature_fun.is_static() &&
-        !signature_fun.HasInstantiatedSignature()) {
-      cls = signature_fun.Owner();
+  intptr_t num_type_args = 0;
+
+  do {
+    if (cls.IsSignatureClass()) {
+      const Function& signature_fun =
+          Function::Handle(cls.signature_function());
+      if (!signature_fun.is_static() &&
+          !signature_fun.HasInstantiatedSignature()) {
+        cls = signature_fun.Owner();
+      }
     }
-  }
-  intptr_t num_type_args = NumTypeParameters();
-  cls = cls.SuperClass();
-  // Object is its own super class during bootstrap.
-  if (!cls.IsNull() && (cls.raw() != raw())) {
-    num_type_args += cls.NumTypeArguments();
-  }
+    num_type_args += cls.NumTypeParameters();
+    // Object is its own super class during bootstrap.
+    if (cls.SuperClass() == Class::null() || cls.SuperClass() == cls.raw()) {
+      break;
+    }
+    cls = cls.SuperClass();
+  } while (true);
   return num_type_args;
 }
 
 
 bool Class::HasTypeArguments() const {
   if (!IsSignatureClass() && (is_type_finalized() || is_prefinalized())) {
     // More efficient than calling NumTypeArguments().
     return type_arguments_field_offset() != kNoTypeArguments;
   } else {
     // No need to check NumTypeArguments() if class has type parameters.
@@ skipping 3680 matching lines @@
     iterator.Advance();
     kind = iterator.CurrentTokenKind();
     index += 1;
   }
   return iterator.CurrentPosition();
 }
 
 
 RawTokenStream* TokenStream::New() {
   ASSERT(Object::token_stream_class() != Class::null());
-  TokenStream& result = TokenStream::Handle();
-  {
-    RawObject* raw = Object::Allocate(TokenStream::kClassId,
-                                      TokenStream::InstanceSize(),
-                                      Heap::kOld);
-    NoGCScope no_gc;
-    result ^= raw;
-  }
-  return result.raw();
+  RawObject* raw = Object::Allocate(TokenStream::kClassId,
+                                    TokenStream::InstanceSize(),
+                                    Heap::kOld);
+  return reinterpret_cast<RawTokenStream*>(raw);
 }
 
 
 RawTokenStream* TokenStream::New(intptr_t len) {
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in TokenStream::New: invalid len %"Pd"\n", len);
   }
   uint8_t* data = reinterpret_cast<uint8_t*>(::malloc(len));
   ASSERT(data != NULL);
@@ skipping 3910 matching lines @@
   } while (!cls.IsNull());
   return false;
 }
 
 
 RawInstance* Instance::New(const Class& cls, Heap::Space space) {
   Isolate* isolate = Isolate::Current();
   if (cls.EnsureIsFinalized(isolate) != Error::null()) {
     return Instance::null();
   }
-  Instance& result = Instance::Handle(isolate);
-  {
-    intptr_t instance_size = cls.instance_size();
-    ASSERT(instance_size > 0);
-    RawObject* raw = Object::Allocate(cls.id(), instance_size, space);
-    NoGCScope no_gc;
-    result ^= raw;
-  }
-  return result.raw();
+  intptr_t instance_size = cls.instance_size();
+  ASSERT(instance_size > 0);
+  RawObject* raw = Object::Allocate(cls.id(), instance_size, space);
+  return reinterpret_cast<RawInstance*>(raw);
 }
 
 
 bool Instance::IsValidFieldOffset(int offset) const {
   const Class& cls = Class::Handle(clazz());
   return (offset >= 0 && offset <= (cls.instance_size() - kWordSize));
 }
 
 
 const char* Instance::ToCString() const {
@@ skipping 4057 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 
 RawWeakProperty* WeakProperty::New(Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->weak_property_class()
          != Class::null());
-  WeakProperty& result = WeakProperty::Handle();
-  {
-    RawObject* raw = Object::Allocate(WeakProperty::kClassId,
-                                      WeakProperty::InstanceSize(),
-                                      space);
-    NoGCScope no_gc;
-    result ^= raw;
-  }
-  return result.raw();
+  RawObject* raw = Object::Allocate(WeakProperty::kClassId,
+                                    WeakProperty::InstanceSize(),
+                                    space);
+  return reinterpret_cast<RawWeakProperty*>(raw);
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart