More cleanup to avoid creation of redundant handles

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 52 matching lines @@
 cpp_vtable Object::handle_vtable_ = 0;
 cpp_vtable Object::builtin_vtables_[kNumPredefinedCids] = { 0 };
 cpp_vtable Smi::handle_vtable_ = 0;
 
 // These are initialized to a value that will force a illegal memory access if
 // they are being used.
 #if defined(RAW_NULL)
 #error RAW_NULL should not be defined.
 #endif
 #define RAW_NULL kHeapObjectTag
+Object* Object::null_object_ = NULL;
 Array* Object::empty_array_ = NULL;
 Instance* Object::sentinel_ = NULL;
 Instance* Object::transition_sentinel_ = NULL;
 Instance* Object::unknown_constant_ = NULL;
 Instance* Object::non_constant_ = NULL;
 Bool* Object::bool_true_ = NULL;
 Bool* Object::bool_false_ = NULL;
+Smi* Object::smi_illegal_cid_ = NULL;
 LanguageError* Object::snapshot_writer_error_ = NULL;
 
 RawObject* Object::null_ = reinterpret_cast<RawObject*>(RAW_NULL);
 RawClass* Object::class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::null_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::dynamic_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::void_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unresolved_class_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ skipping 225 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.
+  null_object_ = Array::ReadOnlyHandle();
   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();
+  smi_illegal_cid_ = Smi::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());
   }
 
+  *null_object_ = null_;
+
   // Initialize the empty array handle to null_ in order to be able to check
   // if the empty array was allocated (RAW_NULL is not available).
   *empty_array_ = Array::null();
 
   Class& cls = Class::Handle();
 
   // Allocate and initialize the class class.
   {
     intptr_t size = Class::InstanceSize();
     uword address = heap->Allocate(size, Heap::kOld);
@@ skipping 173 matching lines @@
         reinterpret_cast<RawArray*>(address + kHeapObjectTag));
     empty_array_->raw()->ptr()->length_ = Smi::New(0);
   }
 
   // Allocate and initialize singleton true and false boolean objects.
   cls = Class::New<Bool>();
   isolate->object_store()->set_bool_class(cls);
   *bool_true_ = Bool::New(true);
   *bool_false_ = Bool::New(false);
 
+  *smi_illegal_cid_ = Smi::New(kIllegalCid);
   *snapshot_writer_error_ =
       LanguageError::New(String::Handle(String::New("SnapshotWriter Error")));
 
+  ASSERT(!null_object_->IsSmi());
   ASSERT(!empty_array_->IsSmi());
   ASSERT(empty_array_->IsArray());
   ASSERT(!sentinel_->IsSmi());
   ASSERT(sentinel_->IsInstance());
   ASSERT(!transition_sentinel_->IsSmi());
   ASSERT(transition_sentinel_->IsInstance());
   ASSERT(!unknown_constant_->IsSmi());
   ASSERT(unknown_constant_->IsInstance());
   ASSERT(!non_constant_->IsSmi());
   ASSERT(non_constant_->IsInstance());
   ASSERT(!bool_true_->IsSmi());
   ASSERT(bool_true_->IsBool());
   ASSERT(!bool_false_->IsSmi());
   ASSERT(bool_false_->IsBool());
+  ASSERT(smi_illegal_cid_->IsSmi());
   ASSERT(!snapshot_writer_error_->IsSmi());
   ASSERT(snapshot_writer_error_->IsLanguageError());
 }
 
 
 #define SET_CLASS_NAME(class_name, name)                                       \
   cls = class_name##_class();                                                  \
   cls.set_name(Symbols::name());                                               \
 
 void Object::RegisterSingletonClassNames() {
@@ skipping 483 matching lines @@
   // Finish the initialization by compiling the bootstrap scripts containing the
   // base interfaces and the implementation of the internal classes.
   const Error& error = Error::Handle(Bootstrap::LoadandCompileScripts());
   if (!error.IsNull()) {
     return error.raw();
   }
 
   // Remove the Object superclass cycle by setting the super type to null (not
   // to the type of null).
   cls = object_store->object_class();
-  cls.set_super_type(Type::Handle());
+  cls.set_super_type(Type::null_object());

[Ivan Posva, 2013/06/01 00:34:40]

There is a big difference here: On the left set_super_type is called with a
handle that has the vtable set to Type, while on the right the vtable is from
Object even though it masquerades as Type here.

 
   ClassFinalizer::VerifyBootstrapClasses();
   MarkInvisibleFunctions();
 
   // Set up the intrinsic state of all functions (core, math and scalar list).
   Intrinsifier::InitializeState();
 
   return Error::null();
 }
 
@@ skipping 1505 matching lines @@
   // No field found.
   return Field::null();
 }
 
 
 RawLibraryPrefix* Class::LookupLibraryPrefix(const String& name) const {
   Isolate* isolate = Isolate::Current();
   const Library& lib = Library::Handle(isolate, library());
   const Object& obj = Object::Handle(isolate, lib.LookupLocalObject(name));
   if (!obj.IsNull() && obj.IsLibraryPrefix()) {
-    const LibraryPrefix& lib_prefix = LibraryPrefix::Cast(obj);
-    return lib_prefix.raw();
+    return LibraryPrefix::Cast(obj).raw();
   }
   return LibraryPrefix::null();
 }
 
 
 const char* Class::ToCString() const {
   const char* format = "%s Class: %s";
   const Library& lib = Library::Handle(library());
   const char* library_name = lib.IsNull() ? "" : lib.ToCString();
   const char* class_name = String::Handle(Name()).ToCString();
@@ skipping 561 matching lines @@
 
 static void InsertIntoCanonicalTypeArguments(Isolate* isolate,
                                              const Array& table,
                                              const TypeArguments& arguments,
                                              intptr_t index) {
   arguments.SetCanonical();  // Mark object as being canonical.
   table.SetAt(index, arguments);  // Remember the new element.
   // Update used count.
   // Last element of the array is the number of used elements.
   intptr_t table_size = table.Length() - 1;
-  Smi& used = Smi::Handle(isolate);
-  used ^= table.At(table_size);
-  intptr_t used_elements = used.Value() + 1;
-  used = Smi::New(used_elements);
+  intptr_t used_elements = Smi::Value(Smi::RawCast(table.At(table_size))) + 1;
+  const Smi& used = Smi::Handle(isolate, Smi::New(used_elements));
   table.SetAt(table_size, used);
 
   // Rehash if table is 75% full.
   if (used_elements > ((table_size / 4) * 3)) {
     GrowCanonicalTypeArguments(isolate, table);
   }
 }
 
 
 static intptr_t FindIndexInCanonicalTypeArguments(
@@ skipping 1684 matching lines @@
                      bool is_static,
                      bool is_final,
                      bool is_const,
                      const Class& owner,
                      intptr_t token_pos) {
   ASSERT(!owner.IsNull());
   const Field& result = Field::Handle(Field::New());
   result.set_name(name);
   result.set_is_static(is_static);
   if (is_static) {
-    result.set_value(Instance::Handle());
+    result.set_value(Instance::null_object());

[Ivan Posva, 2013/06/01 00:34:40]

ditto, here and below.

   } else {
     result.SetOffset(0);
   }
   result.set_is_final(is_final);
   result.set_is_const(is_const);
   result.set_owner(owner);
   result.set_token_pos(token_pos);
   result.set_has_initializer(false);
   result.set_guarded_cid(kIllegalCid);
   result.set_is_nullable(false);
-  result.set_dependent_code(Array::Handle());
+  result.set_dependent_code(Array::null_object());
   return result.raw();
 }
 
 
 
 RawField* Field::Clone(const Class& new_owner) const {
   Field& clone = Field::Handle();
   clone ^= Object::Clone(*this, Heap::kOld);
   const Class& owner = Class::Handle(this->owner());
   const PatchClass& clone_owner =
       PatchClass::Handle(PatchClass::New(new_owner, owner));
   clone.set_owner(clone_owner);
-  clone.set_dependent_code(Array::Handle());
+  clone.set_dependent_code(Array::null_object());
   if (!clone.is_static()) {
     clone.SetOffset(0);
   }
   return clone.raw();
 }
 
 
 RawString* Field::UserVisibleName() const {
   const String& str = String::Handle(name());
   return IdentifierPrettyName(str);
@@ skipping 73 matching lines @@
   return false;
 }
 
 
 void Field::DeoptimizeDependentCode() const {
   const Array& code_objects = Array::Handle(dependent_code());
 
   if (code_objects.IsNull()) {
     return;
   }
-  set_dependent_code(Array::Handle());
+  set_dependent_code(Array::null_object());
 
   // Deoptimize all dependent code on the stack.
   Code& code = Code::Handle();
   {
     DartFrameIterator iterator;
     StackFrame* frame = iterator.NextFrame();
     while (frame != NULL) {
       code = frame->LookupDartCode();
       if (IsDependentCode(code_objects, code)) {
         DeoptimizeAt(code, frame->pc());
@@ skipping 621 matching lines @@
 RawString* TokenStream::Iterator::MakeLiteralToken(const Object& obj) const {
   if (obj.IsString()) {
     return reinterpret_cast<RawString*>(obj.raw());
   } else if (obj.IsSmi()) {
     Token::Kind kind = static_cast<Token::Kind>(
         Smi::Value(reinterpret_cast<RawSmi*>(obj.raw())));
     ASSERT(kind < Token::kNumTokens);
     if (Token::IsPseudoKeyword(kind) || Token::IsKeyword(kind)) {
       Isolate* isolate = Isolate::Current();
       ObjectStore* object_store = isolate->object_store();
-      String& str = String::Handle(isolate, String::null());
       const Array& symbols = Array::Handle(isolate,
                                            object_store->keyword_symbols());
       ASSERT(!symbols.IsNull());
-      str ^= symbols.At(kind - Token::kFirstKeyword);
-      ASSERT(!str.IsNull());
-      return str.raw();
+      ASSERT(symbols.At(kind - Token::kFirstKeyword) != String::null());
+      return String::RawCast(symbols.At(kind - Token::kFirstKeyword));
     }
     return Symbols::New(Token::Str(kind));
   } else {
     ASSERT(obj.IsLiteralToken());  // Must be a literal token.
     const LiteralToken& literal_token = LiteralToken::Cast(obj);
     return literal_token.literal();
   }
 }
 
 
@@ skipping 363 matching lines @@
   Object& entry = Object::Handle();
   entry = dict.At(index);
   // An empty spot will be found because we keep the hash set at most 75% full.
   while (!entry.IsNull()) {
     index = (index + 1) % dict_size;
     entry = dict.At(index);
   }
 
   // Insert the object at the empty slot.
   dict.SetAt(index, obj);
-  Smi& used = Smi::Handle();
-  used ^= dict.At(dict_size);
-  intptr_t used_elements = used.Value() + 1;  // One more element added.
-  used = Smi::New(used_elements);
+  // One more element added.
+  intptr_t used_elements = Smi::Value(Smi::RawCast(dict.At(dict_size))) + 1;
+  const Smi& used = Smi::Handle(Smi::New(used_elements));
   dict.SetAt(dict_size, used);  // Update used count.
 
   // Rehash if symbol_table is 75% full.
   if (used_elements > ((dict_size / 4) * 3)) {
     GrowDictionary(dict, dict_size);
   }
 
   // Invalidate the cache of loaded scripts.
   if (loaded_scripts() != Array::null()) {
     StorePointer(&raw_ptr()->loaded_scripts_, Array::null());
@@ skipping 174 matching lines @@
        (name.CharAt(4) == '_' &&
         (name.CharAt(0) == 'g' || name.CharAt(0) == 's') &&
         name.CharAt(1) == 'e' &&
         name.CharAt(2) == 't' &&
         name.CharAt(3) == ':'));
 }
 
 
 RawField* Library::LookupFieldAllowPrivate(const String& name) const {
   // First check if name is found in the local scope of the library.
-  Field& field = Field::Handle(LookupLocalField(name));
-  if (!field.IsNull()) {
-    return field.raw();
+  Object& obj = Object::Handle(LookupLocalField(name));
+  if (!obj.IsNull()) {
+    return Field::Cast(obj).raw();
   }
 
   // Do not look up private names in imported libraries.
   if (ShouldBePrivate(name)) {
     return Field::null();
   }
 
   // Now check if name is found in any imported libs.
   const Array& imports = Array::Handle(this->imports());
   Namespace& import = Namespace::Handle();
-  Object& obj = Object::Handle();
   for (intptr_t j = 0; j < this->num_imports(); j++) {
     import ^= imports.At(j);
     obj = import.Lookup(name);
     if (!obj.IsNull() && obj.IsField()) {
-      field ^= obj.raw();
-      return field.raw();
+      return Field::Cast(obj).raw();
     }
   }
   return Field::null();
 }
 
 
 RawField* Library::LookupLocalField(const String& name) const {
   Isolate* isolate = Isolate::Current();
   Field& field = Field::Handle(isolate, Field::null());
   Object& obj = Object::Handle(isolate, Object::null());
@@ skipping 150 matching lines @@
   }
   return import.library();
 }
 
 
 RawNamespace* Library::ImportAt(intptr_t index) const {
   if ((index < 0) || index >= num_imports()) {
     return Namespace::null();
   }
   const Array& import_list = Array::Handle(imports());
-  Namespace& import = Namespace::Handle();
-  import ^= import_list.At(index);
-  return import.raw();
+  return Namespace::RawCast(import_list.At(index));
 }
 
 
 bool Library::ImportsCorelib() const {
   Isolate* isolate = Isolate::Current();
   Library& imported = Library::Handle(isolate);
   intptr_t count = num_imports();
   for (int i = 0; i < count; i++) {
     imported = ImportLibraryAt(i);
     if (imported.IsCoreLibrary()) {
@@ skipping 94 matching lines @@
   result.raw_ptr()->corelib_imported_ = true;
   result.set_debuggable(false);
   result.raw_ptr()->load_state_ = RawLibrary::kAllocated;
   result.raw_ptr()->index_ = -1;
   result.InitClassDictionary();
   result.InitImportList();
   if (import_core_lib) {
     const Library& core_lib = Library::Handle(Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
     const Namespace& ns = Namespace::Handle(
-        Namespace::New(core_lib, Array::Handle(), Array::Handle()));
+        Namespace::New(core_lib, Array::null_object(), Array::null_object()));
     result.AddImport(ns);
   }
   return result.raw();
 }
 
 
 RawLibrary* Library::New(const String& url) {
   return NewLibraryHelper(url, false);
 }
 
 
 void Library::InitCoreLibrary(Isolate* isolate) {
   const String& core_lib_url = Symbols::DartCore();
   const Library& core_lib =
       Library::Handle(Library::NewLibraryHelper(core_lib_url, false));
   core_lib.Register();
   isolate->object_store()->set_bootstrap_library(ObjectStore::kCore, core_lib);
-  isolate->object_store()->set_root_library(Library::Handle());
+  isolate->object_store()->set_root_library(Library::null_object());
 
   // Hook up predefined classes without setting their library pointers. These
   // classes are coming from the VM isolate, and are shared between multiple
   // isolates so setting their library pointers would be wrong.
   const Class& cls = Class::Handle(Object::dynamic_class());
   core_lib.AddObject(cls, String::Handle(cls.Name()));
 }
 
 
 void Library::InitNativeWrappersLibrary(Isolate* isolate) {
@@ skipping 1172 matching lines @@
 
 intptr_t Code::Comments::Length() const {
   if (comments_.IsNull()) {
     return 0;
   }
   return comments_.Length() / kNumberOfEntries;
 }
 
 
 intptr_t Code::Comments::PCOffsetAt(intptr_t idx) const {
-  Smi& result = Smi::Handle();
-  result ^= comments_.At(idx * kNumberOfEntries + kPCOffsetEntry);
-  return result.Value();
+  return Smi::Value(Smi::RawCast(
+      comments_.At(idx * kNumberOfEntries + kPCOffsetEntry)));
 }
 
 
 void Code::Comments::SetPCOffsetAt(intptr_t idx, intptr_t pc)  {
   comments_.SetAt(idx * kNumberOfEntries + kPCOffsetEntry,
                   Smi::Handle(Smi::New(pc)));
 }
 
 
 RawString* Code::Comments::CommentAt(intptr_t idx) const {
-  String& result = String::Handle();
-  result ^= comments_.At(idx * kNumberOfEntries + kCommentEntry);
-  return result.raw();
+  return String::RawCast(comments_.At(idx * kNumberOfEntries + kCommentEntry));
 }
 
 
 void Code::Comments::SetCommentAt(intptr_t idx, const String& comment) {
   comments_.SetAt(idx * kNumberOfEntries + kCommentEntry, comment);
 }
 
 
 Code::Comments::Comments(const Array& comments)
     : comments_(comments) {
@@ skipping 546 matching lines @@
   return TestEntryLengthFor(num_args_tested());
 }
 
 
 intptr_t ICData::NumberOfChecks() const {
   // Do not count the sentinel;
   return (Array::Handle(ic_data()).Length() / TestEntryLength()) - 1;
 }
 
 
-void ICData::WriteSentinel() const {
-  const Smi& sentinel_value = Smi::Handle(Smi::New(kIllegalCid));
-  const Array& data = Array::Handle(ic_data());
+void ICData::WriteSentinel(const Array& data) const {
   for (intptr_t i = 1; i <= TestEntryLength(); i++) {
-    data.SetAt(data.Length() - i, sentinel_value);
+    data.SetAt(data.Length() - i, smi_illegal_cid());
   }
 }
 
 
 #if defined(DEBUG)
 // Used in asserts to verify that a check is not added twice.
 bool ICData::HasCheck(const GrowableArray<intptr_t>& cids) const {
   const intptr_t len = NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
     GrowableArray<intptr_t> class_ids;
@@ skipping 18 matching lines @@
 void ICData::AddCheck(const GrowableArray<intptr_t>& class_ids,
                       const Function& target) const {
   DEBUG_ASSERT(!HasCheck(class_ids));
   ASSERT(num_args_tested() > 1);  // Otherwise use 'AddReceiverCheck'.
   ASSERT(class_ids.length() == num_args_tested());
   const intptr_t old_num = NumberOfChecks();
   Array& data = Array::Handle(ic_data());
   const intptr_t new_len = data.Length() + TestEntryLength();
   data = Array::Grow(data, new_len, Heap::kOld);
   set_ic_data(data);
-  WriteSentinel();
+  WriteSentinel(data);
   intptr_t data_pos = old_num * TestEntryLength();
+  Smi& value = Smi::Handle();
   for (intptr_t i = 0; i < class_ids.length(); i++) {
     // kIllegalCid is used as terminating value, do not add it.
     ASSERT(class_ids[i] != kIllegalCid);
-    data.SetAt(data_pos++, Smi::Handle(Smi::New(class_ids[i])));
+    value = Smi::New(class_ids[i]);
+    data.SetAt(data_pos++, value);
   }
   ASSERT(!target.IsNull());
   data.SetAt(data_pos++, target);
-  data.SetAt(data_pos, Smi::Handle(Smi::New(1)));
+  value = Smi::New(1);
+  data.SetAt(data_pos, value);
 }
 
 
 void ICData::AddReceiverCheck(intptr_t receiver_class_id,
                               const Function& target,
                               intptr_t count) const {
 #if defined(DEBUG)
   GrowableArray<intptr_t> class_ids(1);
   class_ids.Add(receiver_class_id);
   ASSERT(!HasCheck(class_ids));
 #endif  // DEBUG
   ASSERT(num_args_tested() == 1);  // Otherwise use 'AddCheck'.
   ASSERT(receiver_class_id != kIllegalCid);
 
   const intptr_t old_num = NumberOfChecks();
   Array& data = Array::Handle(ic_data());
   const intptr_t new_len = data.Length() + TestEntryLength();
   data = Array::Grow(data, new_len, Heap::kOld);
   set_ic_data(data);
-  WriteSentinel();
+  WriteSentinel(data);
   intptr_t data_pos = old_num * TestEntryLength();
   if ((receiver_class_id == kSmiCid) && (data_pos > 0)) {
     ASSERT(GetReceiverClassIdAt(0) != kSmiCid);
     // Move class occupying position 0 to the data_pos.
     for (intptr_t i = 0; i < TestEntryLength(); i++) {
       data.SetAt(data_pos + i, Object::Handle(data.At(i)));
     }
     // Insert kSmiCid in position 0.
     data_pos = 0;
   }
   data.SetAt(data_pos, Smi::Handle(Smi::New(receiver_class_id)));
   data.SetAt(data_pos + 1, target);
   data.SetAt(data_pos + 2, Smi::Handle(Smi::New(count)));
 }
 
 
 void ICData::GetCheckAt(intptr_t index,
                         GrowableArray<intptr_t>* class_ids,
                         Function* target) const {
   ASSERT(index < NumberOfChecks());
   ASSERT(class_ids != NULL);
   ASSERT(target != NULL);
   class_ids->Clear();
   const Array& data = Array::Handle(ic_data());
   intptr_t data_pos = index * TestEntryLength();
-  Smi& smi = Smi::Handle();
   for (intptr_t i = 0; i < num_args_tested(); i++) {
-    smi ^= data.At(data_pos++);
-    class_ids->Add(smi.Value());
+    class_ids->Add(Smi::Value(Smi::RawCast(data.At(data_pos++))));
   }
   (*target) ^= data.At(data_pos++);
 }
 
 
 void ICData::GetOneClassCheckAt(intptr_t index,
                                 intptr_t* class_id,
                                 Function* target) const {
   ASSERT(class_id != NULL);
   ASSERT(target != NULL);
   ASSERT(num_args_tested() == 1);
   const Array& data = Array::Handle(ic_data());
   intptr_t data_pos = index * TestEntryLength();
-  Smi& smi = Smi::Handle();
-  smi ^= data.At(data_pos);
-  *class_id = smi.Value();
+  *class_id = Smi::Value(Smi::RawCast(data.At(data_pos)));
   *target ^= data.At(data_pos + 1);
 }
 
 
 intptr_t ICData::GetClassIdAt(intptr_t index, intptr_t arg_nr) const {
   GrowableArray<intptr_t> class_ids;
   Function& target = Function::Handle();
   GetCheckAt(index, &class_ids, &target);
   return class_ids[arg_nr];
 }
 
 
 intptr_t ICData::GetReceiverClassIdAt(intptr_t index) const {
   ASSERT(index < NumberOfChecks());
   const Array& data = Array::Handle(ic_data());
   const intptr_t data_pos = index * TestEntryLength();
-  Smi& smi = Smi::Handle();
-  smi ^= data.At(data_pos);
-  return smi.Value();
+  return Smi::Value(Smi::RawCast(data.At(data_pos)));
 }
 
 
 RawFunction* ICData::GetTargetAt(intptr_t index) const {
   const Array& data = Array::Handle(ic_data());
   const intptr_t data_pos = index * TestEntryLength() + num_args_tested();
   ASSERT(Object::Handle(data.At(data_pos)).IsFunction());
   return reinterpret_cast<RawFunction*>(data.At(data_pos));
 }
 
@@ skipping 13 matching lines @@
   const intptr_t data_pos = index * TestEntryLength() +
       CountIndexFor(num_args_tested());
   data.SetAt(data_pos, Smi::Handle(Smi::New(value)));
 }
 
 
 intptr_t ICData::GetCountAt(intptr_t index) const {
   const Array& data = Array::Handle(ic_data());
   const intptr_t data_pos = index * TestEntryLength() +
       CountIndexFor(num_args_tested());
-  Smi& smi = Smi::Handle();
-  smi ^= data.At(data_pos);
-  return smi.Value();
+  return Smi::Value(Smi::RawCast(data.At(data_pos)));
 }
 
 
 intptr_t ICData::AggregateCount() const {
   const intptr_t len = NumberOfChecks();
   intptr_t count = 0;
   for (intptr_t i = 0; i < len; i++) {
     count += GetCountAt(i);
   }
   return count;
@@ skipping 134 matching lines @@
   result.set_target_name(target_name);
   result.set_deopt_id(deopt_id);
   result.set_num_args_tested(num_args_tested);
   result.set_deopt_reason(kDeoptUnknown);
   result.set_is_closure_call(false);
   // Number of array elements in one test entry.
   intptr_t len = result.TestEntryLength();
   // IC data array must be null terminated (sentinel entry).
   const Array& ic_data = Array::Handle(Array::New(len, Heap::kOld));
   result.set_ic_data(ic_data);
-  result.WriteSentinel();
+  result.WriteSentinel(ic_data);
   return result.raw();
 }
 
 
 RawArray* MegamorphicCache::buckets() const {
   return raw_ptr()->buckets_;
 }
 
 
 void MegamorphicCache::set_buckets(const Array& buckets) const {
@@ skipping 27 matching lines @@
 RawMegamorphicCache* MegamorphicCache::New() {
   MegamorphicCache& result = MegamorphicCache::Handle();
   { RawObject* raw = Object::Allocate(MegamorphicCache::kClassId,
                                       MegamorphicCache::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   const intptr_t capacity = kInitialCapacity;
   const Array& buckets = Array::Handle(Array::New(kEntryLength * capacity));
-  const Smi& illegal = Smi::Handle(Smi::New(kIllegalCid));
   const Function& handler = Function::Handle(
       Isolate::Current()->megamorphic_cache_table()->miss_handler());
   for (intptr_t i = 0; i < capacity; ++i) {
-    SetEntry(buckets, i, illegal, handler);
+    SetEntry(buckets, i, smi_illegal_cid(), handler);
   }
   result.set_buckets(buckets);
   result.set_mask(capacity - 1);
   result.set_filled_entry_count(0);
   return result.raw();
 }
 
 
 void MegamorphicCache::EnsureCapacity() const {
   intptr_t old_capacity = mask() + 1;
   double load_limit = kLoadFactor * static_cast<double>(old_capacity);
   if (static_cast<double>(filled_entry_count() + 1) > load_limit) {
     const Array& old_buckets = Array::Handle(buckets());
     intptr_t new_capacity = old_capacity * 2;
     const Array& new_buckets =
         Array::Handle(Array::New(kEntryLength * new_capacity));
 
-    Smi& class_id = Smi::Handle(Smi::New(kIllegalCid));
     Function& target = Function::Handle(
         Isolate::Current()->megamorphic_cache_table()->miss_handler());
     for (intptr_t i = 0; i < new_capacity; ++i) {
-      SetEntry(new_buckets, i, class_id, target);
+      SetEntry(new_buckets, i, smi_illegal_cid(), target);
     }
     set_buckets(new_buckets);
     set_mask(new_capacity - 1);
     set_filled_entry_count(0);
 
     // Rehash the valid entries.
+    Smi& class_id = Smi::Handle();
     for (intptr_t i = 0; i < old_capacity; ++i) {
       class_id ^= GetClassId(old_buckets, i);
       if (class_id.Value() != kIllegalCid) {
         target ^= GetTargetFunction(old_buckets, i);
         Insert(class_id, target);
       }
     }
   }
 }
 
 
 void MegamorphicCache::Insert(const Smi& class_id,
                               const Function& target) const {
   ASSERT(static_cast<double>(filled_entry_count() + 1) <=
          (kLoadFactor * static_cast<double>(mask() + 1)));
   const Array& backing_array = Array::Handle(buckets());
   intptr_t id_mask = mask();
   intptr_t index = class_id.Value() & id_mask;
-  Smi& probe = Smi::Handle();
   intptr_t i = index;
   do {
-    probe ^= GetClassId(backing_array, i);
-    if (probe.Value() == kIllegalCid) {
+    if (Smi::Value(Smi::RawCast(GetClassId(backing_array, i))) == kIllegalCid) {
       SetEntry(backing_array, i, class_id, target);
       set_filled_entry_count(filled_entry_count() + 1);
       return;
     }
     i = (i + 1) & id_mask;
   } while (i != index);
   UNREACHABLE();
 }
 
 
@@ skipping 52 matching lines @@
 
 
 void SubtypeTestCache::GetCheck(
     intptr_t ix,
     intptr_t* instance_class_id,
     AbstractTypeArguments* instance_type_arguments,
     AbstractTypeArguments* instantiator_type_arguments,
     Bool* test_result) const {
   Array& data = Array::Handle(cache());
   intptr_t data_pos = ix * kTestEntryLength;
-  Smi& instance_class_id_handle = Smi::Handle();
-  instance_class_id_handle ^= data.At(data_pos + kInstanceClassId);
-  *instance_class_id = instance_class_id_handle.Value();
+  *instance_class_id =
+      Smi::Value(Smi::RawCast(data.At(data_pos + kInstanceClassId)));
   *instance_type_arguments ^= data.At(data_pos + kInstanceTypeArguments);
   *instantiator_type_arguments ^=
       data.At(data_pos + kInstantiatorTypeArguments);
   *test_result ^= data.At(data_pos + kTestResult);
 }
 
 
 const char* SubtypeTestCache::ToCString() const {
   return "SubtypeTestCache";
 }
@@ skipping 1649 matching lines @@
 
 
 RawInteger* Integer::ArithmeticOp(Token::Kind operation,
                                   const Integer& other) const {
   // In 32-bit mode, the result of any operation between two Smis will fit in a
   // 32-bit signed result, except the product of two Smis, which will be 64-bit.
   // In 64-bit mode, the result of any operation between two Smis will fit in a
   // 64-bit signed result, except the product of two Smis (unless the Smis are
   // 32-bit or less).
   if (IsSmi() && other.IsSmi()) {
-    Smi& left_smi = Smi::Handle();
-    Smi& right_smi = Smi::Handle();
-    left_smi ^= raw();
-    right_smi ^= other.raw();
-    const intptr_t left_value = left_smi.Value();
-    const intptr_t right_value = right_smi.Value();
+    const intptr_t left_value = Smi::Value(Smi::RawCast(raw()));
+    const intptr_t right_value = Smi::Value(Smi::RawCast(other.raw()));
     switch (operation) {
       case Token::kADD:
         return Integer::New(left_value + right_value);
       case Token::kSUB:
         return Integer::New(left_value - right_value);
       case Token::kMUL: {
         if (Smi::kBits < 32) {
           // In 32-bit mode, the product of two Smis fits in a 64-bit result.
           return Integer::New(static_cast<int64_t>(left_value) *
                               static_cast<int64_t>(right_value));
@@ skipping 72 matching lines @@
 }
 
 
 static bool Are64bitOperands(const Integer& op1, const Integer& op2) {
   return !op1.IsBigint() && !op2.IsBigint();
 }
 
 
 RawInteger* Integer::BitOp(Token::Kind kind, const Integer& other) const {
   if (IsSmi() && other.IsSmi()) {
-    Smi& op1 = Smi::Handle();
-    Smi& op2 = Smi::Handle();
-    op1 ^= raw();
-    op2 ^= other.raw();
+    intptr_t op1_value = Smi::Value(Smi::RawCast(raw()));
+    intptr_t op2_value = Smi::Value(Smi::RawCast(other.raw()));
     intptr_t result = 0;
     switch (kind) {
       case Token::kBIT_AND:
-        result = op1.Value() & op2.Value();
+        result = op1_value & op2_value;
         break;
       case Token::kBIT_OR:
-        result = op1.Value() | op2.Value();
+        result = op1_value | op2_value;
         break;
       case Token::kBIT_XOR:
-        result = op1.Value() ^ op2.Value();
+        result = op1_value ^ op2_value;
         break;
       default:
         UNIMPLEMENTED();
     }
     ASSERT(Smi::IsValid(result));
     return Smi::New(result);
   } else if (Are64bitOperands(*this, other)) {
     int64_t a = AsInt64Value();
     int64_t b = other.AsInt64Value();
     switch (kind) {
@@ skipping 1961 matching lines @@
   StorePointer(&(raw_ptr()->data_), new_contents.raw());
 }
 
 
 RawObject* GrowableObjectArray::RemoveLast() const {
   ASSERT(!IsNull());
   ASSERT(Length() > 0);
   intptr_t index = Length() - 1;
   const Array& contents = Array::Handle(data());
   const Object& obj = Object::Handle(contents.At(index));
-  contents.SetAt(index, Object::Handle());
+  contents.SetAt(index, null_object());
   SetLength(index);
   return obj.raw();
 }
 
 
 bool GrowableObjectArray::Equals(const Instance& other) const {
   // If both handles point to the same raw instance they are equal.
   if (this->raw() == other.raw()) {
     return true;
   }
@@ skipping 721 matching lines @@
                                     space);
   return reinterpret_cast<RawWeakProperty*>(raw);
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart