Added macros OBJECT_IMPLEMENTATION and FINAL_OBJECT_IMPLEMENTATION

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 226 matching lines @@
   // TODO(iposva): NoGCScope needs to be added here.
   ASSERT(class_class() == null_);
   // Initialize the static vtable values.
   {
     Object fake_object;
     Smi fake_smi;
     Object::handle_vtable_ = fake_object.vtable();
     Smi::handle_vtable_ = fake_smi.vtable();
   }
 
-  // Allocate the read only object handles here.
-  empty_array_ = reinterpret_cast<Array*>(Dart::AllocateReadOnlyHandle());
-  sentinel_ = reinterpret_cast<Instance*>(Dart::AllocateReadOnlyHandle());
-  transition_sentinel_ =
-      reinterpret_cast<Instance*>(Dart::AllocateReadOnlyHandle());
-  bool_true_ = reinterpret_cast<Bool*>(Dart::AllocateReadOnlyHandle());
-  bool_false_ = reinterpret_cast<Bool*>(Dart::AllocateReadOnlyHandle());
-
   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);
+  bool_true_ = Bool::ReadOnlyHandle(isolate);
+  bool_false_ = Bool::ReadOnlyHandle(isolate);
+
   // 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 1176 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)
   // Verify that all the functions in the array have this class as owner.
   Function& func = Function::Handle();
   intptr_t len = value.Length();
   for (intptr_t i = 0; i < len; i++) {
-    func |= value.At(i);
+    func ^= value.At(i);
     ASSERT(func.Owner() == raw());
   }
 #endif
   StorePointer(&raw_ptr()->functions_, value.raw());
 }
 
 
 void Class::AddFunction(const Function& function) const {
   const Array& arr = Array::Handle(functions());
   const Array& new_arr = Array::Handle(Array::Grow(arr, arr.Length() + 1));
@@ skipping 19 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) {
-    closure |= closures.At(best_fit_index);
+    closure ^= closures.At(best_fit_index);
   }
   return closure.raw();
 }
 
 
 void Class::set_signature_function(const Function& value) const {
   ASSERT(value.IsClosureFunction() || value.IsSignatureFunction());
   StorePointer(&raw_ptr()->signature_function_, value.raw());
 }
 
@@ skipping 136 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);
-    member_name = orig_func.name();
+    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);
+    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)
   // Verify that all the fields in the array have this class as owner.
   Field& field = Field::Handle();
   intptr_t len = value.Length();
   for (intptr_t i = 0; i < len; i++) {
-    field |= value.At(i);
+    field ^= value.At(i);
     ASSERT(field.owner() == raw());
   }
 #endif
   // The value of static fields is already initialized to null.
   StorePointer(&raw_ptr()->fields_, value.raw());
 }
 
 
 template <class FakeInstance>
 RawClass* Class::New(intptr_t index) {
@@ skipping 510 matching lines @@
   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++) {
-      function |= funcs.At(i);
+      function ^= funcs.At(i);
       if (function.name() == name.raw()) {
         return function.raw();
       }
     }
   } else {
     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 530 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);
+  used ^= table.At(table_size);
   intptr_t used_elements = used.Value() + 1;
   used = 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);
   }
 }
 
@@ skipping 482 matching lines @@
 
 
 void Function::set_parameter_types(const Array& value) const {
   StorePointer(&raw_ptr()->parameter_types_, value.raw());
 }
 
 
 RawString* Function::ParameterNameAt(intptr_t index) const {
   const Array& parameter_names = Array::Handle(raw_ptr()->parameter_names_);
   String& parameter_name = String::Handle();
-  parameter_name |= parameter_names.At(index);
+  parameter_name ^= parameter_names.At(index);
   return parameter_name.raw();
 }
 
 
 void Function::SetParameterNameAt(intptr_t index, const String& value) const {
   ASSERT(!value.IsNull() && value.IsSymbol());
   const Array& parameter_names = Array::Handle(raw_ptr()->parameter_names_);
   parameter_names.SetAt(index, value);
 }
 
@@ skipping 198 matching lines @@
       argument_names.IsNull() ? 0 : argument_names.Length();
   if (!AreValidArgumentCounts(num_arguments,
                               num_named_arguments,
                               error_message)) {
     return false;
   }
   // Verify that all argument names are valid parameter names.
   String& argument_name = String::Handle();
   String& parameter_name = String::Handle();
   for (int i = 0; i < num_named_arguments; i++) {
-    argument_name |= argument_names.At(i);
+    argument_name ^= argument_names.At(i);
     ASSERT(argument_name.IsSymbol());
     bool found = false;
     const int num_positional_args = num_arguments - num_named_arguments;
     const int num_parameters = NumParameters();
     for (int j = num_positional_args; !found && (j < num_parameters); j++) {
-      parameter_name |= ParameterNameAt(j);
+      parameter_name = ParameterNameAt(j);
       ASSERT(argument_name.IsSymbol());
       if (argument_name.Equals(parameter_name)) {
         found = true;
       }
     }
     if (!found) {
       if (error_message != NULL) {
         const intptr_t kMessageBufferSize = 64;
         char message_buffer[kMessageBufferSize];
         OS::SNPrint(message_buffer,
@@ skipping 339 matching lines @@
   }
   ASSERT(!IsSignatureFunction() && !IsClosureFunction());
   // Create closure function.
   const String& closure_name = String::Handle(name());
   const Function& closure_function = Function::Handle(
       NewClosureFunction(closure_name, *this, token_pos()));
 
   // Set closure function's context scope.
   ContextScope& context_scope = ContextScope::Handle();
   if (is_static()) {
-    context_scope |= ContextScope::New(0);
+    context_scope = ContextScope::New(0);
   } else {
-    context_scope |= LocalScope::CreateImplicitClosureScope(*this);
+    context_scope = LocalScope::CreateImplicitClosureScope(*this);
   }
   closure_function.set_context_scope(context_scope);
 
   // Set closure function's result type to this result type.
   closure_function.set_result_type(AbstractType::Handle(result_type()));
 
   // Set closure function's formal parameters to this formal parameters,
   // removing the receiver if this is an instance method and adding the closure
   // object as first parameter.
   const int kClosure = 1;
@@ skipping 1093 matching lines @@
     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);
+      str ^= symbols.At(kind - Token::kFirstKeyword);
       ASSERT(!str.IsNull());
       return str.raw();
     }
     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 362 matching lines @@
   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);
+  used ^= dict.At(dict_size);
   intptr_t used_elements = used.Value() + 1;  // One more element added.
   used = 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());
   }
 }
 
 
 // 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());
   Object& obj = Object::Handle(isolate, Object::null());
   obj = LookupLocalObject(name);
   if (obj.IsNull() && ShouldBePrivate(name)) {
     String& private_name = String::Handle(isolate, PrivateName(name));
     obj = LookupLocalObject(private_name);
   }
   if (!obj.IsNull()) {
     if (obj.IsField()) {
-      field |= obj.raw();
+      field ^= obj.raw();
       return field.raw();
     }
   }
 
   // No field found.
   return Field::null();
 }
 
 
 RawFunction* Library::LookupFunctionAllowPrivate(const String& name) const {
   // First check if name is found in the local scope of the library.
   Function& function = Function::Handle(LookupLocalFunction(name));
   if (!function.IsNull()) {
     return function.raw();
   }
 
   // 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 68 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);
+  import ^= import_list.At(index);
   return import.raw();
 }
 
 
 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);
@@ skipping 260 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_url = lib.url();
+    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) {
   if (ShouldBePrivate(name)) return true;
   // Factory names: List._fromLiteral.
   for (intptr_t i = 1; i < name.Length() - 1; i++) {
     if (name.CharAt(i) == '.') {
       if (name.CharAt(i + 1) == '_') {
         return true;
       }
     }
   }
   return false;
 }
 
 
 // Cannot handle qualified names properly as it only appends private key to
 // the end (e.g. _Alfa.foo -> _Alfa.foo@...).
 RawString* Library::PrivateName(const String& name) const {
   ASSERT(IsPrivate(name));
   // ASSERT(strchr(name, '@') == NULL);
   String& str = String::Handle();
-  str |= name.raw();
+  str = name.raw();
   str = String::Concat(str, String::Handle(this->private_key()));
   str = Symbols::New(str);
   return str.raw();
 }
 
 
 RawLibrary* Library::GetLibrary(intptr_t index) {
   Isolate* isolate = Isolate::Current();
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate->object_store()->libraries());
   ASSERT(!libs.IsNull());
   if ((0 <= index) && (index < libs.Length())) {
     Library& lib = Library::Handle();
-    lib |= libs.At(index);
+    lib ^= libs.At(index);
     return lib.raw();
   }
   return Library::null();
 }
 
 
 void Library::Register() const {
   ASSERT(Library::LookupLibrary(String::Handle(url())) == Library::null());
   ObjectStore* object_store = Isolate::Current()->object_store();
   GrowableObjectArray& libs =
@@ skipping 56 matching lines @@
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, name.ToCString());
   return chars;
 }
 
 
 RawLibrary* LibraryPrefix::GetLibrary(int index) const {
   if ((index >= 0) || (index < num_imports())) {
     const Array& imports = Array::Handle(this->imports());
     Namespace& import = Namespace::Handle();
-    import |= imports.At(index);
+    import ^= imports.At(index);
     return import.library();
   }
   return Library::null();
 }
 
 
 bool LibraryPrefix::ContainsLibrary(const Library& library) const {
   intptr_t num_current_imports = num_imports();
   if (num_current_imports > 0) {
     Library& lib = Library::Handle();
@@ skipping 27 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 308 matching lines @@
     return chars;
   }
 }
 
 
 RawString* LocalVarDescriptors::GetName(intptr_t var_index) const {
   ASSERT(var_index < Length());
   const Array& names = Array::Handle(raw_ptr()->names_);
   ASSERT(Length() == names.Length());
   String& name = String::Handle();
-  name |= names.At(var_index);
+  name ^= names.At(var_index);
   return name.raw();
 }
 
 
 void LocalVarDescriptors::SetVar(intptr_t var_index,
                                  const String& name,
                                  RawLocalVarDescriptors::VarInfo* info) const {
   ASSERT(var_index < Length());
   const Array& names = Array::Handle(raw_ptr()->names_);
   ASSERT(Length() == names.Length());
@@ skipping 312 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);
+  result ^= comments_.At(idx * kNumberOfEntries + kPCOffsetEntry);
   return result.Value();
 }
 
 
 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);
+  result ^= comments_.At(idx * kNumberOfEntries + kCommentEntry);
   return result.raw();
 }
 
 
 void Code::Comments::SetCommentAt(intptr_t idx, const String& comment) {
   comments_.SetAt(idx * kNumberOfEntries + kCommentEntry, comment);
 }
 
 
 Code::Comments::Comments(const Array& comments)
@@ skipping 46 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 264 matching lines @@
   if (stackmaps() == Array::null()) {
     // No stack maps are present in the code object which means this
     // frame relies on tagged pointers.
     return Stackmap::null();
   }
   // A stack map is present in the code object, use the stack map to visit
   // frame slots which are marked as having objects.
   *maps = stackmaps();
   *map = Stackmap::null();
   for (intptr_t i = 0; i < maps->Length(); i++) {
-    *map |= maps->At(i);
+    *map ^= maps->At(i);
     ASSERT(!map->IsNull());
     if (map->PC() == pc) {
       return map->raw();  // We found a stack map for this frame.
     }
   }
   // If the code has stackmaps, it must have them for all safepoints.
   UNREACHABLE();
   return Stackmap::null();
 }
 
@@ skipping 294 matching lines @@
                         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++);
+    smi ^= data.At(data_pos++);
     class_ids->Add(smi.Value());
   }
-  (*target) |= 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);
+  smi ^= data.At(data_pos);
   *class_id = smi.Value();
-  *target |= data.At(data_pos + 1);
+  *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);
+  smi ^= data.At(data_pos);
   return smi.Value();
 }
 
 
 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));
 }
 
 
 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);
+  smi ^= data.At(data_pos);
   return smi.Value();
 }
 
 
 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);
   }
@@ skipping 211 matching lines @@
         Isolate::Current()->megamorphic_cache_table()->miss_handler());
     for (intptr_t i = 0; i < new_capacity; ++i) {
       SetEntry(new_buckets, i, class_id, target);
     }
     set_buckets(new_buckets);
     set_mask(new_capacity - 1);
     set_filled_entry_count(0);
 
     // Rehash the valid entries.
     for (intptr_t i = 0; i < old_capacity; ++i) {
-      class_id |= GetClassId(old_buckets, i);
+      class_id ^= GetClassId(old_buckets, i);
       if (class_id.Value() != kIllegalCid) {
-        target |= GetTargetFunction(old_buckets, i);
+        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);
+    probe ^= GetClassId(backing_array, i);
     if (probe.Value() == 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 54 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_handle ^= data.At(data_pos + kInstanceClassId);
   *instance_class_id = instance_class_id_handle.Value();
   *instance_type_arguments ^= data.At(data_pos + kInstanceTypeArguments);
   *instantiator_type_arguments ^=
       data.At(data_pos + kInstantiatorTypeArguments);
-  *test_result |= data.At(data_pos + kTestResult);
+  *test_result ^= data.At(data_pos + kTestResult);
 }
 
 
 const char* SubtypeTestCache::ToCString() const {
   return "SubtypeTestCache";
 }
 
 
 const char* Error::ToErrorCString() const {
   UNREACHABLE();
@@ skipping 1295 matching lines @@
 int Integer::CompareWith(const Integer& other) const {
   UNIMPLEMENTED();
   return 0;
 }
 
 
 RawInteger* Integer::AsValidInteger() const {
   if (IsSmi()) return raw();
   if (IsMint()) {
     Mint& mint = Mint::Handle();
-    mint |= raw();
+    mint ^= raw();
     if (Smi::IsValid64(mint.value())) {
       return Smi::New(mint.value());
     } else {
       return raw();
     }
   }
   ASSERT(IsBigint());
   Bigint& big_value = Bigint::Handle();
-  big_value |= raw();
+  big_value ^= raw();
   if (BigintOperations::FitsIntoSmi(big_value)) {
     return BigintOperations::ToSmi(big_value);
   } else if (BigintOperations::FitsIntoMint(big_value)) {
     return Mint::New(BigintOperations::ToMint(big_value));
   } else {
     return big_value.raw();
   }
 }
 
 
 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();
+    left_smi ^= raw();
+    right_smi ^= other.raw();
     const intptr_t left_value = left_smi.Value();
     const intptr_t right_value = right_smi.Value();
     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.
@@ skipping 76 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();
+    op1 ^= raw();
+    op2 ^= other.raw();
     intptr_t result = 0;
     switch (kind) {
       case Token::kBIT_AND:
         result = op1.Value() & op2.Value();
         break;
       case Token::kBIT_OR:
         result = op1.Value() | op2.Value();
         break;
       case Token::kBIT_XOR:
         result = op1.Value() ^ op2.Value();
@@ skipping 173 matching lines @@
   ASSERT(!Smi::IsValid64(value));
   const Class& cls =
       Class::Handle(Isolate::Current()->object_store()->mint_class());
   const Array& constants = Array::Handle(cls.constants());
   const intptr_t constants_len = constants.Length();
   // Linear search to see whether this value is already present in the
   // list of canonicalized constants.
   Mint& canonical_value = Mint::Handle();
   intptr_t index = 0;
   while (index < constants_len) {
-    canonical_value |= constants.At(index);
+    canonical_value ^= constants.At(index);
     if (canonical_value.IsNull()) {
       break;
     }
     if (canonical_value.value() == value) {
       return canonical_value.raw();
     }
     index++;
   }
   // The value needs to be added to the constants list. Grow the list if
   // it is full.
@@ skipping 133 matching lines @@
 RawDouble* Double::NewCanonical(double value) {
   const Class& cls =
       Class::Handle(Isolate::Current()->object_store()->double_class());
   const Array& constants = Array::Handle(cls.constants());
   const intptr_t constants_len = constants.Length();
   // Linear search to see whether this value is already present in the
   // list of canonicalized constants.
   Double& canonical_value = Double::Handle();
   intptr_t index = 0;
   while (index < constants_len) {
-    canonical_value |= constants.At(index);
+    canonical_value ^= constants.At(index);
     if (canonical_value.IsNull()) {
       break;
     }
     if (canonical_value.EqualsToDouble(value)) {
       return canonical_value.raw();
     }
     index++;
   }
   // The value needs to be added to the constants list. Grow the list if
   // it is full.
@@ skipping 25 matching lines @@
   buffer[kBufferSize - 1] = '\0';
   DoubleToCString(value(), buffer, kBufferSize);
   return buffer;
 }
 
 
 RawBigint* Integer::AsBigint() const {
   ASSERT(!IsNull());
   if (IsSmi()) {
     Smi& smi = Smi::Handle();
-    smi |= raw();
+    smi ^= raw();
     return BigintOperations::NewFromSmi(smi);
   } else if (IsMint()) {
     Mint& mint = Mint::Handle();
-    mint |= raw();
+    mint ^= raw();
     return BigintOperations::NewFromInt64(mint.value());
   } else {
     ASSERT(IsBigint());
     Bigint& big = Bigint::Handle();
-    big |= raw();
+    big ^= raw();
     ASSERT(!BigintOperations::FitsIntoSmi(big));
     return big.raw();
   }
 }
 
 
 RawBigint* Bigint::ArithmeticOp(Token::Kind operation,
                                 const Bigint& other) const {
   switch (operation) {
     case Token::kADD:
@@ skipping 57 matching lines @@
   ASSERT(!BigintOperations::FitsIntoMint(value));
   const Class& cls =
       Class::Handle(Isolate::Current()->object_store()->bigint_class());
   const Array& constants = Array::Handle(cls.constants());
   const intptr_t constants_len = constants.Length();
   // Linear search to see whether this value is already present in the
   // list of canonicalized constants.
   Bigint& canonical_value = Bigint::Handle();
   intptr_t index = 0;
   while (index < constants_len) {
-    canonical_value |= constants.At(index);
+    canonical_value ^= constants.At(index);
     if (canonical_value.IsNull()) {
       break;
     }
     if (canonical_value.Equals(value)) {
       return canonical_value.raw();
     }
     index++;
   }
   // The value needs to be added to the constants list. Grow the list if
   // it is full.
@@ skipping 375 matching lines @@
 
 RawString* String::New(const String& str, Heap::Space space) {
   // Currently this just creates a copy of the string in the correct space.
   // Once we have external string support, this will also create a heap copy of
   // the string if necessary. Some optimizations are possible, such as not
   // copying internal strings into the same space.
   intptr_t len = str.Length();
   String& result = String::Handle();
   intptr_t char_size = str.CharSize();
   if (char_size == kOneByteChar) {
-    result |= OneByteString::New(len, space);
+    result = OneByteString::New(len, space);
   } else {
     ASSERT(char_size == kTwoByteChar);
-    result |= TwoByteString::New(len, space);
+    result = TwoByteString::New(len, space);
   }
   String::Copy(result, 0, str, 0, len);
   return result.raw();
 }
 
 
 RawString* String::NewExternal(const uint8_t* characters,
                                intptr_t len,
                                void* peer,
                                Dart_PeerFinalizer callback,
@@ skipping 148 matching lines @@
 
 
 RawString* String::ConcatAll(const Array& strings,
                              Heap::Space space) {
   ASSERT(!strings.IsNull());
   intptr_t result_len = 0;
   intptr_t strings_len = strings.Length();
   String& str = String::Handle();
   intptr_t char_size = kOneByteChar;
   for (intptr_t i = 0; i < strings_len; i++) {
-    str |= strings.At(i);
+    str ^= strings.At(i);
     result_len += str.Length();
     char_size = Utils::Maximum(char_size, str.CharSize());
   }
   if (char_size == kOneByteChar) {
     return OneByteString::ConcatAll(strings, result_len, space);
   }
   ASSERT(char_size == kTwoByteChar);
   return TwoByteString::ConcatAll(strings, result_len, space);
 }
 
@@ skipping 27 matching lines @@
   intptr_t char_size = str.CharSize();
   if (char_size == kTwoByteChar) {
     for (intptr_t i = begin_index; i < begin_index + length; ++i) {
       if (!Utf::IsLatin1(str.CharAt(i))) {
         is_one_byte_string = false;
         break;
       }
     }
   }
   if (is_one_byte_string) {
-    result |= OneByteString::New(length, space);
+    result = OneByteString::New(length, space);
   } else {
-    result |= TwoByteString::New(length, space);
+    result = TwoByteString::New(length, space);
   }
   String::Copy(result, 0, str, begin_index, length);
   return result.raw();
 }
 
 
 const char* String::ToCString() const {
   intptr_t len = Utf8::Length(*this);
   Zone* zone = Isolate::Current()->current_zone();
   uint8_t* result = zone->Alloc<uint8_t>(len + 1);
@@ skipping 341 matching lines @@
 
 
 RawOneByteString* OneByteString::ConcatAll(const Array& strings,
                                            intptr_t len,
                                            Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(len, space));
   String& str = String::Handle();
   intptr_t strings_len = strings.Length();
   intptr_t pos = 0;
   for (intptr_t i = 0; i < strings_len; i++) {
-    str |= strings.At(i);
+    str ^= strings.At(i);
     intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     pos += str_len;
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
@@ skipping 148 matching lines @@
 
 
 RawTwoByteString* TwoByteString::ConcatAll(const Array& strings,
                                            intptr_t len,
                                            Heap::Space space) {
   const String& result = String::Handle(TwoByteString::New(len, space));
   String& str = String::Handle();
   intptr_t strings_len = strings.Length();
   intptr_t pos = 0;
   for (intptr_t i = 0; i < strings_len; i++) {
-    str |= strings.At(i);
+    str ^= strings.At(i);
     intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     pos += str_len;
   }
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
@@ skipping 1163 matching lines @@
 
 void* JSRegExp::GetDataStartAddress() const {
   intptr_t addr = reinterpret_cast<intptr_t>(raw_ptr());
   return reinterpret_cast<void*>(addr + sizeof(RawJSRegExp));
 }
 
 
 RawJSRegExp* JSRegExp::FromDataStartAddress(void* data) {
   JSRegExp& regexp = JSRegExp::Handle();
   intptr_t addr = reinterpret_cast<intptr_t>(data) - sizeof(RawJSRegExp);
-  regexp |= RawObject::FromAddr(addr);
+  regexp ^= RawObject::FromAddr(addr);
   return regexp.raw();
 }
 
 
 const char* JSRegExp::Flags() const {
   switch (raw_ptr()->flags_) {
     case kGlobal | kIgnoreCase | kMultiLine :
     case kIgnoreCase | kMultiLine :
       return "im";
     case kGlobal | kIgnoreCase :
@@ skipping 56 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart