Transition ^= to |=

runtime/vm/bigint_operations.cc

Index: runtime/vm/bigint_operations.cc
===================================================================
--- runtime/vm/bigint_operations.cc	(revision 17302)
+++ runtime/vm/bigint_operations.cc	(working copy)
@@ -184,15 +184,15 @@
       ASSERT(('0' <= c) && (c <= '9'));
       digit = digit * 10 + c - '0';
     }
-    result ^= MultiplyWithDigit(result, kTenMultiplier);
+    result |= MultiplyWithDigit(result, kTenMultiplier);
     if (digit != 0) {
       increment.SetChunkAt(0, digit);
-      result ^= Add(result, increment);
+      result |= Add(result, increment);
     }
   }
   Clamp(result);
   if ((space == Heap::kOld) && !result.IsOld()) {
-    result ^= Object::Clone(result, Heap::kOld);
+    result |= Object::Clone(result, Heap::kOld);
   }
   return result.raw();
 }
@@ -1480,13 +1480,13 @@
 
   int comp = UnsignedCompare(a, b);
   if (comp < 0) {
-    (*quotient) ^= Zero();
-    (*remainder) ^= Copy(a);  // TODO(floitsch): can we reuse the input?
+    (*quotient) |= Zero();
+    (*remainder) |= Copy(a);  // TODO(floitsch): can we reuse the input?
     return;
   } else if (comp == 0) {
-    (*quotient) ^= One();
+    (*quotient) |= One();
     quotient->SetSign(a.IsNegative() != b.IsNegative());
-    (*remainder) ^= Zero();
+    (*remainder) |= Zero();
     return;
   }
 
@@ -1521,7 +1521,7 @@
   ASSERT(divisor_length == divisor.Length());
 
   intptr_t quotient_length = dividend_length - divisor_length + 1;
-  *quotient ^= Bigint::Allocate(quotient_length);
+  *quotient |= Bigint::Allocate(quotient_length);
   quotient->SetSign(a.IsNegative() != b.IsNegative());
 
   intptr_t quotient_pos = dividend_length - divisor_length;
@@ -1536,7 +1536,7 @@
   Chunk first_quotient_digit = 0;
   while (UnsignedCompare(dividend, shifted_divisor) >= 0) {
     first_quotient_digit++;
-    dividend ^= Subtract(dividend, shifted_divisor);
+    dividend |= Subtract(dividend, shifted_divisor);
   }
   quotient->SetChunkAt(quotient_pos--, first_quotient_digit);
 
@@ -1609,7 +1609,7 @@
     target.SetChunkAt(2, dividend_digit);
     do {
       quotient_digit = (quotient_digit - 1) & kDigitMask;
-      estimation_product ^= MultiplyWithDigit(short_divisor, quotient_digit);
+      estimation_product |= MultiplyWithDigit(short_divisor, quotient_digit);
     } while (UnsignedCompareNonClamped(estimation_product, target) > 0);
     // At this point the quotient_digit is fairly accurate.
     // At the worst it is off by one.
@@ -1617,15 +1617,15 @@
     // subtract the divisor another time.
     // Let t = i - divisor_length.
     // dividend -= (quotient_digit * divisor) << (t * kDigitBitSize);
-    shifted_divisor ^= MultiplyWithDigit(divisor, quotient_digit);
-    shifted_divisor ^= DigitsShiftLeft(shifted_divisor, i - divisor_length);
+    shifted_divisor |= MultiplyWithDigit(divisor, quotient_digit);
+    shifted_divisor |= DigitsShiftLeft(shifted_divisor, i - divisor_length);
     dividend = Subtract(dividend, shifted_divisor);
     if (dividend.IsNegative()) {
       // The estimation was still too big.
       quotient_digit--;
       // TODO(floitsch): allocate space for the shifted_divisor once and reuse
       // it at every iteration.
-      shifted_divisor ^= DigitsShiftLeft(divisor, i - divisor_length);
+      shifted_divisor |= DigitsShiftLeft(divisor, i - divisor_length);
       // TODO(floitsch): reuse the space of the previous dividend.
       dividend = Add(dividend, shifted_divisor);
     }
@@ -1633,7 +1633,7 @@
   }
   ASSERT(quotient_pos == -1);
   Clamp(*quotient);
-  *remainder ^= ShiftRight(dividend, normalization_shift);
+  *remainder |= ShiftRight(dividend, normalization_shift);
   remainder->SetSign(a.IsNegative());
 }