Adds javascript overflow checking to arm64.

runtime/vm/intermediate_language_arm64.cc

 // Copyright (c) 2014, 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/globals.h"  // Needed here to get TARGET_ARCH_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 2430 matching lines @@
     __ CompareImmediate(temp, threshold, PP);
     __ b(slow_path->osr_entry_label(), GE);
   }
   if (compiler->ForceSlowPathForStackOverflow()) {
     __ b(slow_path->entry_label());
   }
   __ Bind(slow_path->exit_label());
 }
 
 
+static void EmitJavascriptOverflowCheck(FlowGraphCompiler* compiler,
+                                        Range* range,
+                                        Label* overflow,
+                                        Register result) {
+  if (!range->IsWithin(-0x20000000000000LL, 0x20000000000000LL)) {
+    ASSERT(overflow != NULL);
+    __ CompareImmediate(result, -0x20000000000000LL, PP);
+    __ b(overflow, LT);
+    __ CompareImmediate(result, 0x20000000000000LL, PP);
+    __ b(overflow, GT);
+  }
+}
+
+
 static void EmitSmiShiftLeft(FlowGraphCompiler* compiler,
                              BinarySmiOpInstr* shift_left) {
   const bool is_truncating = shift_left->is_truncating();
   const LocationSummary& locs = *shift_left->locs();
   Register left = locs.in(0).reg();
   Register result = locs.out(0).reg();
   Label* deopt = shift_left->CanDeoptimize() ?
       compiler->AddDeoptStub(shift_left->deopt_id(), ICData::kDeoptBinarySmiOp)
       : NULL;
   if (locs.in(1).IsConstant()) {
@@ skipping 16 matching lines @@
     } else {
       if (!is_truncating) {
         // Check for overflow (preserve left).
         __ Lsl(TMP, left, value);
         __ cmp(left, Operand(TMP, ASR, value));
         __ b(deopt, NE);  // Overflow.
       }
       // Shift for result now we know there is no overflow.
       __ Lsl(result, left, value);
     }
+    if (FLAG_throw_on_javascript_int_overflow) {
+      EmitJavascriptOverflowCheck(compiler, shift_left->range(), deopt, result);
+    }
     return;
   }
 
   // Right (locs.in(1)) is not constant.
   Register right = locs.in(1).reg();
   Range* right_range = shift_left->right()->definition()->range();
   if (shift_left->left()->BindsToConstant() && !is_truncating) {
     // TODO(srdjan): Implement code below for is_truncating().
     // If left is constant, we know the maximal allowed size for right.
     const Object& obj = shift_left->left()->BoundConstant();
@@ skipping 10 matching lines @@
           (right_range == NULL) ||
           !right_range->IsWithin(0, max_right - 1);
       if (right_needs_check) {
         __ CompareImmediate(right,
             reinterpret_cast<int64_t>(Smi::New(max_right)), PP);
         __ b(deopt, CS);
       }
       __ Asr(TMP, right, kSmiTagSize);  // SmiUntag right into TMP.
       __ lslv(result, left, TMP);
     }
+    if (FLAG_throw_on_javascript_int_overflow) {
+      EmitJavascriptOverflowCheck(compiler, shift_left->range(), deopt, result);
+    }
     return;
   }
 
   const bool right_needs_check =
       (right_range == NULL) || !right_range->IsWithin(0, (Smi::kBits - 1));
   if (is_truncating) {
     if (right_needs_check) {
       const bool right_may_be_negative =
           (right_range == NULL) ||
           !right_range->IsWithin(0, RangeBoundary::kPlusInfinity);
@@ skipping 25 matching lines @@
     __ Asr(TMP, right, kSmiTagSize);  // SmiUntag right into IP.
     // Overflow test (preserve left, right, and IP);
     Register temp = locs.temp(0).reg();
     __ lslv(temp, left, TMP);
     __ asrv(TMP2, temp, TMP);
     __ CompareRegisters(left, TMP2);
     __ b(deopt, NE);  // Overflow.
     // Shift for result now we know there is no overflow.
     __ lslv(result, left, TMP);
   }
+  if (FLAG_throw_on_javascript_int_overflow) {
+    EmitJavascriptOverflowCheck(compiler, shift_left->range(), deopt, result);
+  }
 }
 
 
 LocationSummary* BinarySmiOpInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   if (op_kind() == Token::kTRUNCDIV) {
     summary->set_in(0, Location::RequiresRegister());
@@ skipping 154 matching lines @@
         }
 
         __ Asr(result, left, value);
         __ SmiTag(result);
         break;
       }
       default:
         UNREACHABLE();
         break;
     }
+    if (FLAG_throw_on_javascript_int_overflow) {
+      EmitJavascriptOverflowCheck(compiler, range(), deopt, result);
+    }
     return;
   }
 
   Register right = locs()->in(1).reg();
   Range* right_range = this->right()->definition()->range();
   switch (op_kind()) {
     case Token::kADD: {
       if (deopt == NULL) {
         __ add(result, left, Operand(right));
       } else {
@@ skipping 122 matching lines @@
     case Token::kAND: {
       // Flow graph builder has dissected this operation to guarantee correct
       // behavior (short-circuit evaluation).
       UNREACHABLE();
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
+  if (FLAG_throw_on_javascript_int_overflow) {
+    EmitJavascriptOverflowCheck(compiler, range(), deopt, result);
+  }
 }
 
 
 LocationSummary* CheckEitherNonSmiInstr::MakeLocationSummary(bool opt) const {
   intptr_t left_cid = left()->Type()->ToCid();
   intptr_t right_cid = right()->Type()->ToCid();
   ASSERT((left_cid != kDoubleCid) && (right_cid != kDoubleCid));
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
@@ skipping 667 matching lines @@
 
 
 void UnarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   switch (op_kind()) {
     case Token::kNEGATE: {
       Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnaryOp);
       __ subs(result, ZR, Operand(value));
       __ b(deopt, VS);
+      if (FLAG_throw_on_javascript_int_overflow) {
+        EmitJavascriptOverflowCheck(compiler, range(), deopt, value);
+      }
       break;
     }
     case Token::kBIT_NOT:
       __ mvn(result, value);
       // Remove inverted smi-tag.
       __ andi(result, result, ~kSmiTagMask);
       break;
     default:
       UNREACHABLE();
   }
@@ skipping 61 matching lines @@
   __ fcmpd(VTMP, VTMP);
   __ b(&do_call, VS);
 
   __ fcvtzds(result, VTMP);
   // Overflow is signaled with minint.
 
   // Check for overflow and that it fits into Smi.
   __ CompareImmediate(result, 0xC000000000000000, PP);
   __ b(&do_call, MI);
   __ SmiTag(result);
+  if (FLAG_throw_on_javascript_int_overflow) {
+    EmitJavascriptOverflowCheck(compiler, range(), &do_call, result);
+  }
   __ b(&done);
   __ Bind(&do_call);
   __ Push(value_obj);
   ASSERT(instance_call()->HasICData());
   const ICData& ic_data = *instance_call()->ic_data();
   ASSERT((ic_data.NumberOfChecks() == 1));
   const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(0));
 
   const intptr_t kNumberOfArguments = 1;
   compiler->GenerateStaticCall(deopt_id(),
@@ skipping 25 matching lines @@
   // on ARM64 because fcvtzds gives 0 for NaN.
   // TODO(zra): Check spec that this is true.
   __ fcmpd(value, value);
   __ b(deopt, VS);
 
   __ fcvtzds(result, value);
   // Check for overflow and that it fits into Smi.
   __ CompareImmediate(result, 0xC000000000000000, PP);
   __ b(deopt, MI);
   __ SmiTag(result);
+  if (FLAG_throw_on_javascript_int_overflow) {
+    EmitJavascriptOverflowCheck(compiler, range(), deopt, result);
+  }
 }
 
 
 LocationSummary* DoubleToDoubleInstr::MakeLocationSummary(bool opt) const {
   UNIMPLEMENTED();
   return NULL;
 }
 
 
 void DoubleToDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 286 matching lines @@
     //  }
     Label done;
     __ CompareRegisters(result_mod, ZR);;
     __ b(&done, GE);
     // Result is negative, adjust it.
     __ CompareRegisters(right, ZR);
     __ sub(TMP2, result_mod, Operand(right));
     __ add(TMP, result_mod, Operand(right));
     __ csel(result_mod, TMP, TMP2, GE);
     __ Bind(&done);
-
+    // FLAG_throw_on_javascript_int_overflow: not needed.
+    // Note that the result of an integer division/modulo of two
+    // in-range arguments, cannot create out-of-range result.
     return;
   }
   if (kind() == MergedMathInstr::kSinCos) {
     UNIMPLEMENTED();
   }
   UNIMPLEMENTED();
 }
 
 
 LocationSummary* PolymorphicInstanceCallInstr::MakeLocationSummary(
@@ skipping 439 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64