Add a new operator |= which does a simple assignment of the raw pointer into

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/bigint_operations.h"
@@ skipping 1169 matching lines @@
     cur += kWordSize;
   }
   uword tags = 0;
   ASSERT(class_id != kIllegalCid);
   tags = RawObject::ClassIdTag::update(class_id, tags);
   tags = RawObject::SizeTag::update(size, tags);
   reinterpret_cast<RawObject*>(address)->tags_ = tags;
 }
 
 
+void Object::CheckHandle() const {
+#if defined(DEBUG)
+  if (raw_ != Object::null()) {
+    if ((reinterpret_cast<uword>(raw_) & kSmiTagMask) == kSmiTag) {
+      ASSERT(vtable() == Smi::handle_vtable_);
+      return;
+    }
+    intptr_t cid = raw_->GetClassId();
+    if (cid >= kNumPredefinedCids) {
+      cid = kInstanceCid;
+    }
+    ASSERT(vtable() == builtin_vtables_[cid]);
+    Isolate* isolate = Isolate::Current();
+    if (FLAG_verify_handles) {
+      Heap* isolate_heap = isolate->heap();
+      Heap* vm_isolate_heap = Dart::vm_isolate()->heap();
+      ASSERT(isolate_heap->Contains(RawObject::ToAddr(raw_)) ||
+             vm_isolate_heap->Contains(RawObject::ToAddr(raw_)));
+    }
+    ASSERT(builtin_vtables_[cid] ==
+           isolate->class_table()->At(cid)->ptr()->handle_vtable_);

[Ivan Posva, 2013/01/17 23:24:23]

Do we really need to check this one-time assertion for every handle assignment?

[siva, 2013/01/18 00:08:38]

True, this assertion can be pulled out into a one time assertion which is done
in dart::InitializeIsolate().

Will make this change in another CL.

On 2013/01/17 23:24:23, Ivan Posva wrote:

+  }
+#endif
+}
+
+
 RawObject* Object::Allocate(intptr_t cls_id,
                             intptr_t size,
                             Heap::Space space) {
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
 
   uword address = heap->Allocate(size, space);
   if (address == 0) {
     // Use the preallocated out of memory exception to avoid calling
@@ skipping 208 matching lines @@
   StorePointer(&raw_ptr()->canonical_types_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->functions_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->fields_, Object::empty_array().raw());
 }
 
 
 bool Class::HasInstanceFields() const {
   const Array& field_array = Array::Handle(fields());
   Field& field = Field::Handle();
   for (intptr_t i = 0; i < field_array.Length(); ++i) {
-    field ^= field_array.At(i);
+    field |= field_array.At(i);
     if (!field.is_static()) {
       return true;
     }
   }
   return false;
 }
 
 void Class::SetFunctions(const Array& value) const {
   ASSERT(!value.IsNull());
 #if defined(DEBUG)
@@ skipping 26 matching lines @@
   if (raw_ptr()->closure_functions_ == GrowableObjectArray::null()) {
     return Function::null();
   }
   const GrowableObjectArray& closures =
       GrowableObjectArray::Handle(raw_ptr()->closure_functions_);
   Function& closure = Function::Handle();
   intptr_t num_closures = closures.Length();
   intptr_t best_fit_token_pos = -1;
   intptr_t best_fit_index = -1;
   for (intptr_t i = 0; i < num_closures; i++) {
-    closure ^= closures.At(i);
+    closure |= closures.At(i);
     ASSERT(!closure.IsNull());
     if ((closure.token_pos() <= token_pos) &&
         (token_pos < closure.end_token_pos()) &&
         (best_fit_token_pos < closure.token_pos())) {
       best_fit_index = i;
       best_fit_token_pos = closure.token_pos();
     }
   }
   closure = Function::null();
   if (best_fit_index >= 0) {
@@ skipping 147 matching lines @@
       // 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);
   Field& field = Field::Handle();
   intptr_t len = flds.Length();
   for (intptr_t i = 0; i < len; i++) {
-    field ^= flds.At(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;
     }
   }
   set_instance_size(RoundedAllocationSize(offset));
   set_next_field_offset(offset);
 }
@@ skipping 35 matching lines @@
   Array& patch_list = Array::Handle(patch.functions());
   intptr_t patch_len = patch_list.Length();
 
   // TODO(iposva): Verify that only patching existing methods and adding only
   // new private methods.
   Function& func = Function::Handle();
   Function& orig_func = Function::Handle();
   const GrowableObjectArray& new_functions = GrowableObjectArray::Handle(
       GrowableObjectArray::New(orig_len));
   for (intptr_t i = 0; i < orig_len; i++) {
-    orig_func ^= orig_list.At(i);
+    orig_func |= orig_list.At(i);
     member_name = orig_func.name();
     func = patch.LookupFunction(member_name);
     if (func.IsNull()) {
       // Non-patched function is preserved, all patched functions are added in
       // the loop below.
       new_functions.Add(orig_func);
     } else if (!func.HasCompatibleParametersWith(orig_func) &&
                !(func.IsFactory() && orig_func.IsConstructor() &&
                  (func.num_fixed_parameters() + 1 ==
                   orig_func.num_fixed_parameters()))) {
       return FormatPatchError("mismatched parameters: %s", member_name);
     }
   }
   for (intptr_t i = 0; i < patch_len; i++) {
-    func ^= patch_list.At(i);
+    func |= patch_list.At(i);
     func.set_owner(patch_class);
     new_functions.Add(func);
   }
   Array& new_list = Array::Handle(Array::MakeArray(new_functions));
   SetFunctions(new_list);
 
   // Merge the two list of fields. Raise an error when duplicates are found or
   // when a public field is being added.
   orig_list = fields();
   orig_len = orig_list.Length();
   patch_list = patch.fields();
   patch_len = patch_list.Length();
 
   Field& field = Field::Handle();
   Field& orig_field = Field::Handle();
   new_list = Array::New(patch_len + orig_len);
   for (intptr_t i = 0; i < patch_len; i++) {
-    field ^= patch_list.At(i);
+    field |= patch_list.At(i);
     field.set_owner(*this);
     member_name = field.name();
     // TODO(iposva): Verify non-public fields only.
 
     // Verify no duplicate additions.
     orig_field = LookupField(member_name);
     if (!orig_field.IsNull()) {
       return FormatPatchError("duplicate field: %s", member_name);
     }
     new_list.SetAt(i, field);
   }
   for (intptr_t i = 0; i < orig_len; i++) {
-    field ^= orig_list.At(i);
+    field |= orig_list.At(i);
     new_list.SetAt(patch_len + i, field);
   }
   SetFields(new_list);
   return NULL;
 }
 
 
 void Class::SetFields(const Array& value) const {
   ASSERT(!value.IsNull());
 #if defined(DEBUG)
@@ skipping 518 matching lines @@
 
 
 RawFunction* Class::LookupFunction(const String& name) const {
   Isolate* isolate = Isolate::Current();
   ASSERT(name.IsOneByteString());
   Array& funcs = Array::Handle(isolate, functions());
   if (funcs.IsNull()) {
     // This can occur, e.g., for Null classes.
     return Function::null();
   }
+  Function& function = Function::Handle(isolate, Function::null());
   const intptr_t len = funcs.Length();
   if (name.IsSymbol()) {
     // Quick Symbol compare.
     NoGCScope no_gc;
     for (intptr_t i = 0; i < len; i++) {
-      RawFunction* raw_func = reinterpret_cast<RawFunction*>(funcs.At(i));
-      if (raw_func->ptr()->name_ == name.raw()) {
-        return raw_func;
+      function |= funcs.At(i);
+      if (function.name() == name.raw()) {
+        return function.raw();
       }
     }
   } else {
-    Function& function = Function::Handle(isolate, Function::null());
     String& function_name = String::Handle(isolate, String::null());
     for (intptr_t i = 0; i < len; i++) {
-      function ^= funcs.At(i);
-      function_name ^= function.name();
+      function |= funcs.At(i);
+      function_name |= function.name();
       if (function_name.Equals(name)) {
         return function.raw();
       }
     }
   }
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupFunctionAllowPrivate(const String& name) const {
   Isolate* isolate = Isolate::Current();
   ASSERT(name.IsOneByteString());
   Array& funcs = Array::Handle(isolate, functions());
   if (funcs.IsNull()) {
     // This can occur, e.g., for Null classes.
     return Function::null();
   }
   Function& function = Function::Handle(isolate, Function::null());
   String& function_name = String::Handle(isolate, String::null());
   intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
-    function ^= funcs.At(i);
-    function_name ^= function.name();
+    function |= funcs.At(i);
+    function_name |= function.name();
     if (OneByteString::EqualsIgnoringPrivateKey(function_name, name)) {
       return function.raw();
     }
   }
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupGetterFunction(const String& name) const {
   return LookupAccessorFunction(kGetterPrefix, kGetterPrefixLength, name);
 }
 
 
 RawFunction* Class::LookupSetterFunction(const String& name) const {
   return LookupAccessorFunction(kSetterPrefix, kSetterPrefixLength, name);
 }
 
 
 RawFunction* Class::LookupAccessorFunction(const char* prefix,
                                            intptr_t prefix_length,
                                            const String& name) const {
   Isolate* isolate = Isolate::Current();
   Array& funcs = Array::Handle(isolate, functions());
   Function& function = Function::Handle(isolate, Function::null());
   String& function_name = String::Handle(isolate, String::null());
   intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
-    function ^= funcs.At(i);
-    function_name ^= function.name();
+    function |= funcs.At(i);
+    function_name |= function.name();
     if (MatchesAccessorName(function_name, prefix, prefix_length, name)) {
       return function.raw();
     }
   }
 
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupFunctionAtToken(intptr_t token_pos) const {
   // TODO(hausner): we can shortcut the negative case if we knew the
   // beginning and end token position of the class.
   Function& func = Function::Handle();
   func = LookupClosureFunction(token_pos);
   if (!func.IsNull()) {
     return func.raw();
   }
   Array& funcs = Array::Handle(functions());
   intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
-    func ^= funcs.At(i);
+    func |= funcs.At(i);
     if ((func.token_pos() <= token_pos) &&
         (token_pos <= func.end_token_pos())) {
       return func.raw();
     }
   }
   // No function found.
   return Function::null();
 }
 
 
@@ skipping 28 matching lines @@
 
 
 RawField* Class::LookupField(const String& name) const {
   Isolate* isolate = Isolate::Current();
   ASSERT(name.IsOneByteString());
   const Array& flds = Array::Handle(isolate, fields());
   Field& field = Field::Handle(isolate, Field::null());
   String& field_name = String::Handle(isolate, String::null());
   intptr_t len = flds.Length();
   for (intptr_t i = 0; i < len; i++) {
-    field ^= flds.At(i);
-    field_name ^= field.name();
+    field |= flds.At(i);
+    field_name |= field.name();
     if (OneByteString::EqualsIgnoringPrivateKey(field_name, name)) {
       return field.raw();
     }
   }
   // No field found.
   return Field::null();
 }
 
 
 RawLibraryPrefix* Class::LookupLibraryPrefix(const String& name) const {
@@ skipping 3123 matching lines @@
 }
 
 
 // Lookup a name in the library's export namespace.
 RawObject* Library::LookupExport(const String& name) const {
   if (HasExports()) {
     const Array& exports = Array::Handle(this->exports());
     Namespace& ns = Namespace::Handle();
     Object& obj = Object::Handle();
     for (int i = 0; i < exports.Length(); i++) {
-      ns ^= exports.At(i);
+      ns |= exports.At(i);
       obj = ns.Lookup(name);
       if (!obj.IsNull()) {
         return obj.raw();
       }
     }
   }
   return Object::null();
 }
 
 
@@ skipping 61 matching lines @@
         cls = Field::Cast(entry).owner();
         owner_script = cls.script();
       } else {
         continue;
       }
       if (owner_script.IsNull()) {
         continue;
       }
       bool is_unique = true;
       for (int i = 0; i < scripts.Length(); i++) {
-        script_obj ^= scripts.At(i);
+        script_obj |= scripts.At(i);
         if (script_obj.raw() == owner_script.raw()) {
           // We already have a reference to this script.
           is_unique = false;
           break;
         }
       }
       if (is_unique) {
         // Add script to the list of scripts.
         scripts.Add(owner_script);
       }
     }
 
     // Create the array of scripts and cache it in loaded_scripts_.
     StorePointer(&raw_ptr()->loaded_scripts_, Array::MakeArray(scripts));
   }
   return loaded_scripts();
 }
 
 
 // TODO(hausner): we might want to add a script dictionary to the
 // library class to make this lookup faster.
 RawScript* Library::LookupScript(const String& url) const {
   const Array& scripts = Array::Handle(LoadedScripts());
   Script& script = Script::Handle();
   String& script_url = String::Handle();
   intptr_t num_scripts = scripts.Length();
   for (int i = 0; i < num_scripts; i++) {
-    script ^= scripts.At(i);
+    script |= scripts.At(i);
     script_url = script.url();
     if (script_url.Equals(url)) {
       return script.raw();
     }
   }
   return Script::null();
 }
 
 
 RawFunction* Library::LookupFunctionInSource(const String& script_url,
@@ skipping 33 matching lines @@
       func = cls.LookupFunctionAtToken(token_pos);
       if (!func.IsNull()) {
         return func.raw();
       }
     }
   }
   // Look in anonymous classes for toplevel functions.
   Array& anon_classes = Array::Handle(this->raw_ptr()->anonymous_classes_);
   intptr_t num_anonymous = raw_ptr()->num_anonymous_;
   for (int i = 0; i < num_anonymous; i++) {
-    cls ^= anon_classes.At(i);
+    cls |= anon_classes.At(i);
     ASSERT(!cls.IsNull());
     if (script.raw() == cls.script()) {
       func = cls.LookupFunctionAtToken(token_pos);
       if (!func.IsNull()) {
         return func.raw();
       }
     }
   }
   return Function::null();
 }
@@ skipping 28 matching lines @@
   // 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);
+    import |= imports.At(j);
     obj = import.Lookup(name);
     if (!obj.IsNull() && obj.IsField()) {
-      field ^= obj.raw();
+      field |= obj.raw();
       return field.raw();
     }
   }
   return Field::null();
 }
 
 
 RawField* Library::LookupLocalField(const String& name) const {
   Isolate* isolate = Isolate::Current();
   Field& field = Field::Handle(isolate, Field::null());
@@ skipping 25 matching lines @@
   // Do not look up private names in imported libraries.
   if (ShouldBePrivate(name)) {
     return Function::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);
+    import |= imports.At(j);
     obj = import.Lookup(name);
     if (!obj.IsNull() && obj.IsFunction()) {
-      function ^= obj.raw();
+      function |= obj.raw();
       return function.raw();
     }
   }
   return Function::null();
 }
 
 
 RawFunction* Library::LookupLocalFunction(const String& name) const {
   Isolate* isolate = Isolate::Current();
   Object& obj = Object::Handle(isolate, Object::null());
@@ skipping 14 matching lines @@
 RawObject* Library::LookupObject(const String& name) const {
   // First check if name is found in the local scope of the library.
   Object& obj = Object::Handle(LookupLocalObject(name));
   if (!obj.IsNull()) {
     return obj.raw();
   }
   // Now check if name is found in any imported libs.
   const Array& imports = Array::Handle(this->imports());
   Namespace& import = Namespace::Handle();
   for (intptr_t j = 0; j < this->num_imports(); j++) {
-    import ^= imports.At(j);
+    import |= imports.At(j);
     obj = import.Lookup(name);
     if (!obj.IsNull()) {
       return obj.raw();
     }
   }
   return Object::null();
 }
 
 
 RawClass* Library::LookupClass(const String& name) const {
@@ skipping 330 matching lines @@
 }
 
 
 RawLibrary* Library::LookupLibrary(const String &url) {
   Isolate* isolate = Isolate::Current();
   Library& lib = Library::Handle(isolate, Library::null());
   String& lib_url = String::Handle(isolate, String::null());
   GrowableObjectArray& libs = GrowableObjectArray::Handle(
       isolate, isolate->object_store()->libraries());
   for (int i = 0; i < libs.Length(); i++) {
-    lib ^= libs.At(i);
+    lib |= libs.At(i);
     lib_url = lib.url();
     if (lib_url.Equals(url)) {
       return lib.raw();
     }
   }
   return Library::null();
 }
 
 
 RawError* Library::Patch(const Script& script) const {
   ASSERT(script.kind() == RawScript::kPatchTag);
   return Compiler::Compile(*this, script);
 }
 
 
 bool Library::IsKeyUsed(intptr_t key) {
   intptr_t lib_key;
   const GrowableObjectArray& libs = GrowableObjectArray::Handle(
       Isolate::Current()->object_store()->libraries());
   Library& lib = Library::Handle();
   String& lib_url = String::Handle();
   for (int i = 0; i < libs.Length(); i++) {
-    lib ^= libs.At(i);
-    lib_url ^= lib.url();
+    lib |= libs.At(i);
+    lib_url |= lib.url();
     lib_key = lib_url.Hash();
     if (lib_key == key) {
       return true;
     }
   }
   return false;
 }
 
 
 static bool IsPrivate(const String& name) {
@@ skipping 143 matching lines @@
   imports.SetAt(num_current_imports, import);
   set_num_imports(num_current_imports + 1);
 }
 
 
 RawClass* LibraryPrefix::LookupLocalClass(const String& class_name) const {
   Array& imports = Array::Handle(this->imports());
   Object& obj = Object::Handle();
   Namespace& import = Namespace::Handle();
   for (intptr_t i = 0; i < num_imports(); i++) {
-    import ^= imports.At(i);
+    import |= imports.At(i);
     obj = import.Lookup(class_name);
     if (!obj.IsNull() && obj.IsClass()) {
       // TODO(hausner):
       return Class::Cast(obj).raw();
     }
   }
   return Class::null();
 }
 
 
@@ skipping 53 matching lines @@
 }
 
 
 bool Namespace::HidesName(const String& name) const {
   // Check whether the name is in the list of explicitly hidden names.
   if (hide_names() != Array::null()) {
     const Array& names = Array::Handle(hide_names());
     String& hidden = String::Handle();
     intptr_t num_names = names.Length();
     for (intptr_t i = 0; i < num_names; i++) {
-      hidden ^= names.At(i);
+      hidden |= names.At(i);
       if (name.Equals(hidden)) {
         return true;
       }
     }
   }
   // The name is not explicitly hidden. Now check whether it is in the
   // list of explicitly visible names, if there is one.
   if (show_names() != Array::null()) {
     const Array& names = Array::Handle(show_names());
     String& shown = String::Handle();
     intptr_t num_names = names.Length();
     for (intptr_t i = 0; i < num_names; i++) {
-      shown ^= names.At(i);
+      shown |= names.At(i);
       if (name.Equals(shown)) {
         return false;
       }
     }
     // There is a list of visible names. The name we're looking for is not
     // contained in the list, so it is hidden.
     return true;
   }
   // The name is not filtered out.
   return false;
@@ skipping 38 matching lines @@
 }
 
 
 RawError* Library::CompileAll() {
   Error& error = Error::Handle();
   const GrowableObjectArray& libs = GrowableObjectArray::Handle(
       Isolate::Current()->object_store()->libraries());
   Library& lib = Library::Handle();
   Class& cls = Class::Handle();
   for (int i = 0; i < libs.Length(); i++) {
-    lib ^= libs.At(i);
+    lib |= libs.At(i);
     ClassDictionaryIterator it(lib);
     while (it.HasNext()) {
-      cls ^= it.GetNextClass();
+      cls |= it.GetNextClass();
       error = Compiler::CompileAllFunctions(cls);
       if (!error.IsNull()) {
         return error.raw();
       }
     }
     Array& anon_classes = Array::Handle(lib.raw_ptr()->anonymous_classes_);
     for (int i = 0; i < lib.raw_ptr()->num_anonymous_; i++) {
-      cls ^= anon_classes.At(i);
+      cls |= anon_classes.At(i);
       error = Compiler::CompileAllFunctions(cls);
       if (!error.IsNull()) {
         return error.raw();
       }
     }
   }
   return error.raw();
 }
 
 
@@ skipping 721 matching lines @@
 
 
 RawFunction* Code::GetStaticCallTargetFunctionAt(uword pc) const {
   RawObject* raw_code_offset =
       reinterpret_cast<RawObject*>(Smi::New(pc - EntryPoint()));
   const Array& array =
       Array::Handle(raw_ptr()->static_calls_target_table_);
   for (intptr_t i = 0; i < array.Length(); i += kSCallTableEntryLength) {
     if (array.At(i) == raw_code_offset) {
       Function& function = Function::Handle();
-      function ^= array.At(i + kSCallTableFunctionEntry);
+      function |= array.At(i + kSCallTableFunctionEntry);
       return function.raw();
     }
   }
   return Function::null();
 }
 
 
 void Code::SetStaticCallTargetCodeAt(uword pc, const Code& code) const {
   RawObject* raw_code_offset =
       reinterpret_cast<RawObject*>(Smi::New(pc - EntryPoint()));
@@ skipping 5287 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart