Fix bit-or and bit-xor for two negative bigints.

runtime/vm/bigint_operations.cc

 // Copyright 2012 Google Inc. All Rights Reserved.
 
 #include "vm/bigint_operations.h"
 
 #include "platform/utils.h"
 
 #include "vm/double_internals.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
 #include "vm/zone.h"
@@ skipping 951 matching lines @@
   }
 
   ASSERT(a.IsNegative());
   ASSERT(b.IsNegative());
   // The result will be negative.
   // We need to convert a and b to two's complement. Do the bit-operation there,
   // and transform the resulting bits from two's complement back to separated
   // magnitude and sign.
   // a & b is therefore computed as ~((~(a - 1)) | (~(b - 1))) + 1 which is
   //   equal to ((a-1) & (b-1)) + 1.
+  ASSERT(a_length >= b_length);
+  ASSERT(min_length == b_length);
   intptr_t result_length = min_length + 1;
   const Bigint& result = Bigint::Handle(Bigint::Allocate(result_length));
   result.ToggleSign();
   Chunk a_borrow = 1;
   Chunk b_borrow = 1;
   Chunk result_carry = 1;
-  ASSERT(a_length >= b_length);
   for (intptr_t i = 0; i < b_length; i++) {
     Chunk a_digit = a.GetChunkAt(i) - a_borrow;
     Chunk b_digit = b.GetChunkAt(i) - b_borrow;
     Chunk result_chunk = ((a_digit & b_digit) & kDigitMask) + result_carry;
     result.SetChunkAt(i, result_chunk & kDigitMask);
     a_borrow = a_digit >> (kChunkBitSize - 1);
     b_borrow = b_digit >> (kChunkBitSize - 1);
     result_carry = result_chunk >> kDigitBitSize;
   }
-  result.SetChunkAt(a_length, result_carry);
+  result.SetChunkAt(b_length, result_carry);
   Clamp(result);
   return result.raw();
 }
 
 
 RawBigint* BigintOperations::BitXor(const Bigint& a, const Bigint& b) {
   ASSERT(IsClamped(a));
   ASSERT(IsClamped(b));
 
   if (a.IsZero()) {
@@ skipping 78 matching lines @@
     Clamp(result);
     return result.raw();
   }
 
   ASSERT(a.IsNegative());
   ASSERT(b.IsNegative());
   // The result will be positive.
   // We need to convert a and b to two's complement, do the bit-operation there,
   // and simply store the result.
   // a ^ b is therefore computed as (~(a - 1)) ^ (~(b - 1)).
+  ASSERT(a_length >= b_length);
+  ASSERT(max_length == a_length);
   intptr_t result_length = max_length;
   const Bigint& result = Bigint::Handle(Bigint::Allocate(result_length));
   Chunk a_borrow = 1;
   Chunk b_borrow = 1;
-  ASSERT(a_length >= b_length);
   for (intptr_t i = 0; i < b_length; i++) {
     Chunk a_digit = a.GetChunkAt(i) - a_borrow;
     Chunk b_digit = b.GetChunkAt(i) - b_borrow;
     Chunk result_chunk = (~a_digit) ^ (~b_digit);
     result.SetChunkAt(i, result_chunk & kDigitMask);
     a_borrow = a_digit >> (kChunkBitSize - 1);
     b_borrow = b_digit >> (kChunkBitSize - 1);
   }
   ASSERT(b_borrow == 0);
   for (intptr_t i = b_length; i < a_length; i++) {
     Chunk a_digit = a.GetChunkAt(i) - a_borrow;
-    result.SetChunkAt(i, (~a_digit) & kDigitMask);
+    // (~a_digit) ^ 0xFFF..FFF == a_digit.
+    result.SetChunkAt(i, a_digit & kDigitMask);
     a_borrow = a_digit >> (kChunkBitSize - 1);
   }
   ASSERT(a_borrow == 0);
   Clamp(result);
   return result.raw();
 }
 
 
 RawBigint* BigintOperations::BitNot(const Bigint& bigint) {
   if (bigint.IsZero()) {
@@ skipping 390 matching lines @@
 int BigintOperations::CountBits(Chunk digit) {
   int result = 0;
   while (digit != 0) {
     digit >>= 1;
     result++;
   }
   return result;
 }
 
 }  // namespace dart