Fix for running with --throw_on_javascript_int_overflow: recognize pattern (a << b) & mask and test…

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/cpu.h"
@@ skipping 11498 matching lines @@
 }
 
 
 // dart2js represents integers as double precision floats, which can represent
 // anything in the range -2^53 ... 2^53.
 static bool IsJavascriptInt(int64_t value) {
   return ((-0x20000000000000LL <= value) && (value <= 0x20000000000000LL));
 }
 
 
-RawInteger* Integer::New(int64_t value, Heap::Space space) {
+RawInteger* Integer::New(int64_t value, Heap::Space space, const bool silent) {
   if ((value <= Smi::kMaxValue) && (value >= Smi::kMinValue)) {
     return Smi::New(value);
   }
-  if (FLAG_throw_on_javascript_int_overflow && !IsJavascriptInt(value)) {
+  if (!silent &&
+      FLAG_throw_on_javascript_int_overflow &&
+      !IsJavascriptInt(value)) {
     const Integer &i = Integer::Handle(Mint::New(value));
     ThrowJavascriptIntegerOverflow(i);
   }
   return Mint::New(value, space);
 }
 
 
 RawInteger* Integer::NewFromUint64(uint64_t value, Heap::Space space) {
   if (value > static_cast<uint64_t>(Mint::kMaxValue)) {
     if (FLAG_throw_on_javascript_int_overflow) {
@@ skipping 222 matching lines @@
         return BigintOperations::BitXor(op1, op2);
       default:
         UNIMPLEMENTED();
     }
   }
   return Integer::null();
 }
 
 
 // TODO(srdjan): Clarify handling of negative right operand in a shift op.
-RawInteger* Smi::ShiftOp(Token::Kind kind, const Smi& other) const {
+RawInteger* Smi::ShiftOp(Token::Kind kind,
+                         const Smi& other,
+                         const bool silent) const {
   intptr_t result = 0;
   const intptr_t left_value = Value();
   const intptr_t right_value = other.Value();
   ASSERT(right_value >= 0);
   switch (kind) {
     case Token::kSHL: {
       if ((left_value == 0) || (right_value == 0)) {
         return raw();
       }
       { // Check for overflow.
         int cnt = Utils::HighestBit(left_value);
         if ((cnt + right_value) >= Smi::kBits) {
           if ((cnt + right_value) >= Mint::kBits) {
             return BigintOperations::ShiftLeft(
                 Bigint::Handle(BigintOperations::NewFromSmi(*this)),
                                right_value);
           } else {
             int64_t left_64 = left_value;
-            return Integer::New(left_64 << right_value);
+            return Integer::New(left_64 << right_value, Heap::kNew, silent);
           }
         }
       }
       result = left_value << right_value;
       break;
     }
     case Token::kSHR: {
       const intptr_t shift_amount =
           (right_value >= kBitsPerWord) ? (kBitsPerWord - 1) : right_value;
       result = left_value >> shift_amount;
@@ skipping 2823 matching lines @@
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 }  // namespace dart