Remember all deopt reasons in ic_data, not just the last one.

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 "vm/dart_entry.h"
@@ skipping 584 matching lines @@
 }
 
 
 Condition TestCidsInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
                                             BranchLabels labels) {
   ASSERT((kind() == Token::kIS) || (kind() == Token::kISNOT));
   Register val_reg = locs()->in(0).reg();
   Register cid_reg = locs()->temp(0).reg();
 
   Label* deopt = CanDeoptimize() ?
-  compiler->AddDeoptStub(deopt_id(), kDeoptTestCids) : NULL;
+  compiler->AddDeoptStub(deopt_id(), ICData::kDeoptTestCids) : NULL;
 
   const intptr_t true_result = (kind() == Token::kIS) ? 1 : 0;
   const ZoneGrowableArray<intptr_t>& data = cid_results();
   ASSERT(data[0] == kSmiCid);
   bool result = data[1] == true_result;
   __ testl(val_reg, Immediate(kSmiTagMask));
   __ j(ZERO, result ? labels.true_label : labels.false_label);
   __ LoadClassId(cid_reg, val_reg);
   for (intptr_t i = 2; i < data.length(); i += 2) {
     const intptr_t test_cid = data[i];
@@ skipping 457 matching lines @@
     case kTypedDataInt16ArrayCid:
       __ movsxw(result, element_address);
       __ SmiTag(result);
       break;
     case kTypedDataUint16ArrayCid:
     case kTwoByteStringCid:
       __ movzxw(result, element_address);
       __ SmiTag(result);
       break;
     case kTypedDataInt32ArrayCid: {
-        Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptInt32Load);
+        Label* deopt = compiler->AddDeoptStub(deopt_id(),
+                                              ICData::kDeoptInt32Load);
         __ movl(result, element_address);
         // Verify that the signed value in 'result' can fit inside a Smi.
         __ cmpl(result, Immediate(0xC0000000));
         __ j(NEGATIVE, deopt);
         __ SmiTag(result);
       }
       break;
     case kTypedDataUint32ArrayCid: {
-        Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptUint32Load);
+        Label* deopt = compiler->AddDeoptStub(deopt_id(),
+                                              ICData::kDeoptUint32Load);
         __ movl(result, element_address);
         // Verify that the unsigned value in 'result' can fit inside a Smi.
         __ testl(result, Immediate(0xC0000000));
         __ j(NOT_ZERO, deopt);
         __ SmiTag(result);
       }
       break;
     default:
       ASSERT((class_id() == kArrayCid) || (class_id() == kImmutableArrayCid));
       __ movl(result, element_address);
@@ skipping 264 matching lines @@
 
   Register value_cid_reg = needs_value_temp_reg ?
       locs()->temp(0).reg() : kNoRegister;
 
   Register field_reg = needs_field_temp_reg ?
       locs()->temp(locs()->temp_count() - 1).reg() : kNoRegister;
 
   Label ok, fail_label;
 
   Label* deopt = compiler->is_optimizing() ?
-      compiler->AddDeoptStub(deopt_id(), kDeoptGuardField) : NULL;
+      compiler->AddDeoptStub(deopt_id(), ICData::kDeoptGuardField) : NULL;
 
   Label* fail = (deopt != NULL) ? deopt : &fail_label;
 
   if (!compiler->is_optimizing() || (field_cid == kIllegalCid)) {
     if (!compiler->is_optimizing() && (field_reg == kNoRegister)) {
       // Currently we can't have different location summaries for optimized
       // and non-optimized code. So instead we manually pick up a register
       // that is known to be free because we know how non-optimizing compiler
       // allocates registers.
       field_reg = EBX;
@@ skipping 1291 matching lines @@
 
 
 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();
   ASSERT(left == result);
   Label* deopt = shift_left->CanDeoptimize() ?
-      compiler->AddDeoptStub(shift_left->deopt_id(), kDeoptBinarySmiOp) : NULL;
+      compiler->AddDeoptStub(shift_left->deopt_id(), ICData::kDeoptBinarySmiOp)
+      : NULL;
   if (locs.in(1).IsConstant()) {
     const Object& constant = locs.in(1).constant();
     ASSERT(constant.IsSmi());
     // shll operation masks the count to 5 bits.
     const intptr_t kCountLimit = 0x1F;
     const intptr_t value = Smi::Cast(constant).Value();
     if (value == 0) {
       // No code needed.
     } else if ((value < 0) || (value >= kCountLimit)) {
       // This condition may not be known earlier in some cases because
@@ skipping 173 matching lines @@
     EmitSmiShiftLeft(compiler, this);
     return;
   }
 
   ASSERT(!is_truncating());
   Register left = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   ASSERT(left == result);
   Label* deopt = NULL;
   if (CanDeoptimize()) {
-    deopt  = compiler->AddDeoptStub(deopt_id(), kDeoptBinarySmiOp);
+    deopt  = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinarySmiOp);
   }
 
   if (locs()->in(1).IsConstant()) {
     const Object& constant = locs()->in(1).constant();
     ASSERT(constant.IsSmi());
     const int32_t imm =
         reinterpret_cast<int32_t>(constant.raw());
     switch (op_kind()) {
       case Token::kADD:
         __ addl(left, Immediate(imm));
@@ skipping 285 matching lines @@
   LocationSummary* summary =
     new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_in(1, Location::RequiresRegister());
   if (need_temp) summary->set_temp(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void CheckEitherNonSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptBinaryDoubleOp);
+  Label* deopt = compiler->AddDeoptStub(deopt_id(),
+                                        ICData::kDeoptBinaryDoubleOp);
   intptr_t left_cid = left()->Type()->ToCid();
   intptr_t right_cid = right()->Type()->ToCid();
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   if (left_cid == kSmiCid) {
     __ testl(right, Immediate(kSmiTagMask));
   } else if (right_cid == kSmiCid) {
     __ testl(left, Immediate(kSmiTagMask));
   } else {
     Register temp = locs()->temp(0).reg();
@@ skipping 59 matching lines @@
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register value = locs()->in(0).reg();
   const XmmRegister result = locs()->out(0).fpu_reg();
 
   if (value_cid == kDoubleCid) {
     __ movsd(result, FieldAddress(value, Double::value_offset()));
   } else if (value_cid == kSmiCid) {
     __ SmiUntag(value);  // Untag input before conversion.
     __ cvtsi2sd(result, value);
   } else {
-    Label* deopt = compiler->AddDeoptStub(deopt_id_, kDeoptBinaryDoubleOp);
+    Label* deopt = compiler->AddDeoptStub(deopt_id_,
+                                          ICData::kDeoptBinaryDoubleOp);
     Register temp = locs()->temp(0).reg();
     Label is_smi, done;
     __ testl(value, Immediate(kSmiTagMask));
     __ j(ZERO, &is_smi);
     __ CompareClassId(value, kDoubleCid, temp);
     __ j(NOT_EQUAL, deopt);
     __ movsd(result, FieldAddress(value, Double::value_offset()));
     __ jmp(&done);
     __ Bind(&is_smi);
     __ movl(temp, value);
@@ skipping 50 matching lines @@
 }
 
 
 void UnboxFloat32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register value = locs()->in(0).reg();
   const XmmRegister result = locs()->out(0).fpu_reg();
 
   if (value_cid != kFloat32x4Cid) {
     const Register temp = locs()->temp(0).reg();
-    Label* deopt = compiler->AddDeoptStub(deopt_id_, kDeoptCheckClass);
+    Label* deopt = compiler->AddDeoptStub(deopt_id_, ICData::kDeoptCheckClass);
     __ testl(value, Immediate(kSmiTagMask));
     __ j(ZERO, deopt);
     __ CompareClassId(value, kFloat32x4Cid, temp);
     __ j(NOT_EQUAL, deopt);
   }
   __ movups(result, FieldAddress(value, Float32x4::value_offset()));
 }
 
 
 LocationSummary* BoxFloat64x2Instr::MakeLocationSummary(bool opt) const {
@@ skipping 42 matching lines @@
 }
 
 
 void UnboxFloat64x2Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register value = locs()->in(0).reg();
   const XmmRegister result = locs()->out(0).fpu_reg();
 
   if (value_cid != kFloat64x2Cid) {
     const Register temp = locs()->temp(0).reg();
-    Label* deopt = compiler->AddDeoptStub(deopt_id_, kDeoptCheckClass);
+    Label* deopt = compiler->AddDeoptStub(deopt_id_, ICData::kDeoptCheckClass);
     __ testl(value, Immediate(kSmiTagMask));
     __ j(ZERO, deopt);
     __ CompareClassId(value, kFloat64x2Cid, temp);
     __ j(NOT_EQUAL, deopt);
   }
   __ movups(result, FieldAddress(value, Float64x2::value_offset()));
 }
 
 
 LocationSummary* BoxInt32x4Instr::MakeLocationSummary(bool opt) const {
@@ skipping 74 matching lines @@
 }
 
 
 void UnboxInt32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register value = locs()->in(0).reg();
   const XmmRegister result = locs()->out(0).fpu_reg();
 
   if (value_cid != kInt32x4Cid) {
     const Register temp = locs()->temp(0).reg();
-    Label* deopt = compiler->AddDeoptStub(deopt_id_, kDeoptCheckClass);
+    Label* deopt = compiler->AddDeoptStub(deopt_id_, ICData::kDeoptCheckClass);
     __ testl(value, Immediate(kSmiTagMask));
     __ j(ZERO, deopt);
     __ CompareClassId(value, kInt32x4Cid, temp);
     __ j(NOT_EQUAL, deopt);
   }
   __ movups(result, FieldAddress(value, Int32x4::value_offset()));
 }
 
 
 
@@ skipping 1122 matching lines @@
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
 
 
 void UnarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   ASSERT(value == locs()->out(0).reg());
   switch (op_kind()) {
     case Token::kNEGATE: {
-      Label* deopt = compiler->AddDeoptStub(deopt_id(),
-                                            kDeoptUnaryOp);
+      Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnaryOp);
       __ negl(value);
       __ j(OVERFLOW, deopt);
       break;
     }
     case Token::kBIT_NOT:
       __ notl(value);
       __ andl(value, Immediate(~kSmiTagMask));  // Remove inverted smi-tag.
       break;
     default:
       UNREACHABLE();
@@ skipping 87 matching lines @@
   const intptr_t kNumTemps = 0;
   LocationSummary* result = new LocationSummary(
       kNumInputs, kNumTemps, LocationSummary::kNoCall);
   result->set_in(0, Location::RequiresFpuRegister());
   result->set_out(0, Location::RequiresRegister());
   return result;
 }
 
 
 void DoubleToSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptDoubleToSmi);
+  Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptDoubleToSmi);
   Register result = locs()->out(0).reg();
   XmmRegister value = locs()->in(0).fpu_reg();
   __ cvttsd2si(result, value);
   // Check for overflow and that it fits into Smi.
   __ cmpl(result, Immediate(0xC0000000));
   __ j(NEGATIVE, deopt);
   __ SmiTag(result);
 }
 
 
@@ skipping 254 matching lines @@
 typedef void (*SinCosCFunction) (double x, double* res_sin, double* res_cos);
 
 extern const RuntimeEntry kSinCosRuntimeEntry(
     "libc_sincos", reinterpret_cast<RuntimeFunction>(
         static_cast<SinCosCFunction>(&SinCos)), 1, true, true);
 
 
 void MergedMathInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = NULL;
   if (CanDeoptimize()) {
-    deopt  = compiler->AddDeoptStub(deopt_id(), kDeoptBinarySmiOp);
+    deopt  = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinarySmiOp);
   }
 
   if (kind() == MergedMathInstr::kTruncDivMod) {
     Register left = locs()->in(0).reg();
     Register right = locs()->in(1).reg();
     ASSERT(locs()->out(0).IsPairLocation());
     PairLocation* pair = locs()->out(0).AsPairLocation();
     Register result1 = pair->At(0).reg();
     Register result2 = pair->At(1).reg();
     Range* right_range = InputAt(1)->definition()->range();
@@ skipping 78 matching lines @@
 }
 
 
 LocationSummary* PolymorphicInstanceCallInstr::MakeLocationSummary(
     bool opt) const {
   return MakeCallSummary();
 }
 
 
 void PolymorphicInstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Label* deopt = compiler->AddDeoptStub(deopt_id(),
-                                        kDeoptPolymorphicInstanceCallTestFail);
+  Label* deopt = compiler->AddDeoptStub(
+      deopt_id(), ICData::kDeoptPolymorphicInstanceCallTestFail);
   if (ic_data().NumberOfChecks() == 0) {
     __ jmp(deopt);
     return;
   }
-  ASSERT(ic_data().num_args_tested() == 1);
+  ASSERT(ic_data().NumArgsTested() == 1);
   if (!with_checks()) {
     ASSERT(ic_data().HasOneTarget());
     const Function& target = Function::ZoneHandle(ic_data().GetTargetAt(0));
     compiler->GenerateStaticCall(deopt_id(),
                                  instance_call()->token_pos(),
                                  target,
                                  instance_call()->ArgumentCount(),
                                  instance_call()->argument_names(),
                                  locs());
     return;
@@ skipping 37 matching lines @@
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   if (!IsNullCheck()) {
     summary->AddTemp(Location::RequiresRegister());
   }
   return summary;
 }
 
 
 void CheckClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  const DeoptReasonId deopt_reason =
-      licm_hoisted_ ? kDeoptHoistedCheckClass : kDeoptCheckClass;
+  const ICData::DeoptReasonId deopt_reason = licm_hoisted_ ?
+      ICData::kDeoptHoistedCheckClass : ICData::kDeoptCheckClass;
   if (IsNullCheck()) {
     Label* deopt = compiler->AddDeoptStub(deopt_id(), deopt_reason);
     const Immediate& raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     __ cmpl(locs()->in(0).reg(), raw_null);
     __ j(EQUAL, deopt);
     return;
   }
 
   ASSERT((unary_checks().GetReceiverClassIdAt(0) != kSmiCid) ||
@@ skipping 36 matching lines @@
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void CheckSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
-  Label* deopt = compiler->AddDeoptStub(deopt_id(),
-                                        kDeoptCheckSmi);
+  Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptCheckSmi);
   __ testl(value, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 }
 
 
 // Length: register or constant.
 // Index: register, constant or stack slot.
 LocationSummary* CheckArrayBoundInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(kLengthPos, Location::RegisterOrSmiConstant(length()));
   ConstantInstr* index_constant = index()->definition()->AsConstant();
   if (index_constant != NULL) {
     locs->set_in(kIndexPos, Location::RegisterOrSmiConstant(index()));
   } else {
     locs->set_in(kIndexPos, Location::PrefersRegister());
   }
   return locs;
 }
 
 
 void CheckArrayBoundInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptCheckArrayBound);
+  Label* deopt = compiler->AddDeoptStub(deopt_id(),
+                                        ICData::kDeoptCheckArrayBound);
 
   Location length_loc = locs()->in(kLengthPos);
   Location index_loc = locs()->in(kIndexPos);
 
   if (length_loc.IsConstant() && index_loc.IsConstant()) {
     // TODO(srdjan): remove this code once failures are fixed.
     if ((Smi::Cast(length_loc.constant()).Value() >
          Smi::Cast(index_loc.constant()).Value()) &&
         (Smi::Cast(index_loc.constant()).Value() >= 0)) {
       // This CheckArrayBoundInstr should have been eliminated.
@@ skipping 62 matching lines @@
   const XmmRegister result = locs()->out(0).fpu_reg();
 
   if (value_cid == kMintCid) {
     __ movsd(result, FieldAddress(value, Mint::value_offset()));
   } else if (value_cid == kSmiCid) {
     __ SmiUntag(value);  // Untag input before conversion.
     __ movd(result, value);
     __ pmovsxdq(result, result);
   } else {
     Register temp = locs()->temp(0).reg();
-    Label* deopt = compiler->AddDeoptStub(deopt_id_, kDeoptUnboxInteger);
+    Label* deopt = compiler->AddDeoptStub(deopt_id_,
+                                          ICData::kDeoptUnboxInteger);
     Label is_smi, done;
     __ testl(value, Immediate(kSmiTagMask));
     __ j(ZERO, &is_smi);
     __ CompareClassId(value, kMintCid, temp);
     __ j(NOT_EQUAL, deopt);
     __ movsd(result, FieldAddress(value, Mint::value_offset()));
     __ jmp(&done);
     __ Bind(&is_smi);
     __ movl(temp, value);
     __ SmiUntag(temp);
@@ skipping 131 matching lines @@
 
 
 void BinaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   XmmRegister left = locs()->in(0).fpu_reg();
   XmmRegister right = locs()->in(1).fpu_reg();
 
   ASSERT(locs()->out(0).fpu_reg() == left);
 
   Label* deopt = NULL;
   if (FLAG_throw_on_javascript_int_overflow) {
-    deopt = compiler->AddDeoptStub(deopt_id(), kDeoptBinaryMintOp);
+    deopt = compiler->AddDeoptStub(deopt_id(), ICData::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();
       if (!FLAG_throw_on_javascript_int_overflow) {
-        deopt  = compiler->AddDeoptStub(deopt_id(), kDeoptBinaryMintOp);
+        deopt  = compiler->AddDeoptStub(deopt_id(), ICData::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);
@@ skipping 34 matching lines @@
   summary->set_out(0, Location::SameAsFirstInput());
   return summary;
 }
 
 
 void ShiftMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   XmmRegister left = locs()->in(0).fpu_reg();
   ASSERT(locs()->in(1).reg() == ECX);
   ASSERT(locs()->out(0).fpu_reg() == left);
 
-  Label* deopt = compiler->AddDeoptStub(deopt_id(),
-                                        kDeoptShiftMintOp);
+  Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptShiftMintOp);
   Label done;
   __ testl(ECX, ECX);
   __ j(ZERO, &done);  // Shift by 0 is a nop.
   __ subl(ESP, Immediate(2 * kWordSize));
   __ movq(Address(ESP, 0), left);
   // Deoptimize if shift count is > 31.
   // sarl operation masks the count to 5 bits and
   // shrd is undefined with count > operand size (32)
   // TODO(fschneider): Support shift counts > 31 without deoptimization.
   __ SmiUntag(ECX);
@@ skipping 52 matching lines @@
   return summary;
 }
 
 
 void UnaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(op_kind() == Token::kBIT_NOT);
   XmmRegister value = locs()->in(0).fpu_reg();
   ASSERT(value == locs()->out(0).fpu_reg());
   Label* deopt = NULL;
   if (FLAG_throw_on_javascript_int_overflow) {
-    deopt = compiler->AddDeoptStub(deopt_id(),
-                                   kDeoptUnaryMintOp);
+    deopt = compiler->AddDeoptStub(deopt_id(), ICData::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);
   }
 }
 
 
@@ skipping 322 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_IA32