Enables unboxed mints in ia32 javascript int compatability mode.

runtime/vm/intermediate_language_ia32.cc

 // Copyright (c) 2013, 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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 #define __ compiler->assembler()->
 
 namespace dart {
 
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, propagate_ic_data);
 DECLARE_FLAG(bool, use_osr);
+DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
 
 // Generic summary for call instructions that have all arguments pushed
 // on the stack and return the result in a fixed register EAX.
 LocationSummary* Instruction::MakeCallSummary() {
   LocationSummary* result = new LocationSummary(0, 0, LocationSummary::kCall);
   result->set_out(Location::RegisterLocation(EAX));
   return result;
 }
 
 
@@ skipping 604 matching lines @@
     __ j(true_condition, &is_true);
     __ LoadObject(result, Bool::False());
     __ jmp(&done);
     __ Bind(&is_true);
     __ LoadObject(result, Bool::True());
     __ Bind(&done);
   }
 }
 
 
+static void EmitJavascriptIntOverflowCheck(FlowGraphCompiler* compiler,
+                                           Label* overflow,
+                                           XmmRegister result,
+                                           Register tmp) {
+  if (FLAG_throw_on_javascript_int_overflow) {

[srdjan, 2013/08/02 18:07:22]

I would move this test at call sites, think it is mode readable.
if (FLAG_throw_on_javascript_int_overflow) {
  EmitJavascriptIntOverflowCheck(..)
}

[zra, 2013/08/02 18:30:27]

Done.

+    // Compare upper half.
+    Label check_lower, done;
+    __ pextrd(tmp, result, Immediate(1));
+    __ cmpl(tmp, Immediate(0x00200000));
+    __ j(GREATER, overflow);
+    __ j(NOT_EQUAL, &check_lower);
+
+    __ pextrd(tmp, result, Immediate(0));
+    __ cmpl(tmp, Immediate(0));
+    __ j(ABOVE, overflow);
+
+    __ Bind(&check_lower);
+    __ pextrd(tmp, result, Immediate(1));
+    __ cmpl(tmp, Immediate(-0x00200000));
+    __ j(LESS, overflow);
+    // Anything in the lower part would make the number bigger than the lower
+    // bound, so we are done.
+
+    __ Bind(&done);
+  }
+}
+
+
 static Condition TokenKindToMintCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQUAL;
     case Token::kNE: return NOT_EQUAL;
     case Token::kLT: return LESS;
     case Token::kGT: return GREATER;
     case Token::kLTE: return LESS_EQUAL;
     case Token::kGTE: return GREATER_EQUAL;
     default:
       UNREACHABLE();
@@ skipping 3605 matching lines @@
   __ Bind(&done);
 }
 
 
 LocationSummary* BinaryMintOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   switch (op_kind()) {
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR: {
-      const intptr_t kNumTemps = 0;
+      const intptr_t kNumTemps =
+          FLAG_throw_on_javascript_int_overflow ? 1 : 0;
       LocationSummary* summary =
           new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
       summary->set_in(0, Location::RequiresFpuRegister());
       summary->set_in(1, Location::RequiresFpuRegister());
+      if (FLAG_throw_on_javascript_int_overflow) {
+        summary->set_temp(0, Location::RequiresRegister());
+      }
       summary->set_out(Location::SameAsFirstInput());
       return summary;
     }
     case Token::kADD:
     case Token::kSUB: {
       const intptr_t kNumTemps = 2;
       LocationSummary* summary =
           new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
       summary->set_in(0, Location::RequiresFpuRegister());
       summary->set_in(1, Location::RequiresFpuRegister());
       summary->set_temp(0, Location::RequiresRegister());
       summary->set_temp(1, Location::RequiresRegister());
       summary->set_out(Location::SameAsFirstInput());
       return summary;
     }
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 void BinaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   XmmRegister left = locs()->in(0).fpu_reg();
   XmmRegister right = locs()->in(1).fpu_reg();
 
   ASSERT(locs()->out().fpu_reg() == left);
 
+  Label* deopt = NULL;
+  if (FLAG_throw_on_javascript_int_overflow) {
+    deopt = compiler->AddDeoptStub(deopt_id(), kDeoptBinaryMintOp);
+  }
   switch (op_kind()) {
     case Token::kBIT_AND: __ andpd(left, right); break;
     case Token::kBIT_OR:  __ orpd(left, right); break;
     case Token::kBIT_XOR: __ xorpd(left, right); break;
     case Token::kADD:
     case Token::kSUB: {
       Register lo = locs()->temp(0).reg();
       Register hi = locs()->temp(1).reg();
-      Label* deopt  = compiler->AddDeoptStub(deopt_id(),
-                                             kDeoptBinaryMintOp);
+      if (!FLAG_throw_on_javascript_int_overflow) {
+        deopt  = compiler->AddDeoptStub(deopt_id(), kDeoptBinaryMintOp);
+      }
+
       Label done, overflow;
       __ pextrd(lo, right, Immediate(0));  // Lower half
       __ pextrd(hi, right, Immediate(1));  // Upper half
       __ subl(ESP, Immediate(2 * kWordSize));
       __ movq(Address(ESP, 0), left);
       if (op_kind() == Token::kADD) {
         __ addl(Address(ESP, 0), lo);
         __ adcl(Address(ESP, 1 * kWordSize), hi);
       } else {
         __ subl(Address(ESP, 0), lo);
         __ sbbl(Address(ESP, 1 * kWordSize), hi);
       }
       __ j(OVERFLOW, &overflow);
       __ movq(left, Address(ESP, 0));
       __ addl(ESP, Immediate(2 * kWordSize));
       __ jmp(&done);
       __ Bind(&overflow);
       __ addl(ESP, Immediate(2 * kWordSize));
       __ jmp(deopt);
       __ Bind(&done);
       break;
     }
     default: UNREACHABLE();
   }
+  if (FLAG_throw_on_javascript_int_overflow) {
+    Register tmp = locs()->temp(0).reg();
+    EmitJavascriptIntOverflowCheck(compiler, deopt, left, tmp);
+  }
 }
 
 
 LocationSummary* ShiftMintOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = op_kind() == Token::kSHL ? 2 : 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresFpuRegister());
   summary->set_in(1, Location::RegisterLocation(ECX));
@@ skipping 50 matching lines @@
       __ j(NOT_EQUAL, deopt);
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
   __ movq(left, Address(ESP, 0));
   __ addl(ESP, Immediate(2 * kWordSize));
   __ Bind(&done);
+  Register tmp = locs()->temp(0).reg();
+  EmitJavascriptIntOverflowCheck(compiler, deopt, left, tmp);
 }
 
 
 LocationSummary* UnaryMintOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
-  const intptr_t kNumTemps = 0;
+  const intptr_t kNumTemps =
+      FLAG_throw_on_javascript_int_overflow ? 1 : 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresFpuRegister());
   summary->set_out(Location::SameAsFirstInput());
   return summary;
 }
 
 
 void UnaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(op_kind() == Token::kBIT_NOT);
   XmmRegister value = locs()->in(0).fpu_reg();
   ASSERT(value == locs()->out().fpu_reg());
+  Label* deopt = NULL;
+  if (FLAG_throw_on_javascript_int_overflow) {
+    deopt = compiler->AddDeoptStub(deopt_id(),
+                                   kDeoptUnaryMintOp);
+  }
   __ pcmpeqq(XMM0, XMM0);  // Generate all 1's.
   __ pxor(value, XMM0);
+  if (FLAG_throw_on_javascript_int_overflow) {
+    Register tmp = locs()->temp(0).reg();
+    EmitJavascriptIntOverflowCheck(compiler, deopt, value, tmp);
+  }
 }
 
 
 LocationSummary* ThrowInstr::MakeLocationSummary() const {
   return new LocationSummary(0, 0, LocationSummary::kCall);
 }
 
 
 
 void ThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 432 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_IA32