Use new |= operator in object.cc .

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 1448 matching lines @@
 }
 
 
 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 30 matching lines @@
     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 253 matching lines @@
 }
 
 
 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 471 matching lines @@
 RawFunction* Class::LookupFactory(const String& name) const {
   Function& function = Function::Handle(LookupFunction(name));
   if (function.IsNull() || !function.IsFactory()) {
     return Function::null();
   }
   ASSERT(function.is_static());
   return function.raw();
 }
 
 
+// Returns true if 'prefix' and 'accessor_name' match 'name'.
 static bool MatchesAccessorName(const String& name,
                                 const char* prefix,
                                 intptr_t prefix_length,
                                 const String& accessor_name) {
   intptr_t name_len = name.Length();
   intptr_t accessor_name_len = accessor_name.Length();
 
   if (name_len != (accessor_name_len + prefix_length)) {
     return false;
   }
@@ skipping 704 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.
@@ skipping 238 matching lines @@
   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 {
@@ skipping 133 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 314 matching lines @@
   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 513 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 331 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