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

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 91 matching lines @@
 
 
 // Attempt to build ICData for call using propagated class-ids.
 bool FlowGraphOptimizer::TryCreateICData(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   if (call->ic_data()->NumberOfChecks() > 0) {
     // This occurs when an instance call has too many checks, will be converted
     // to megamorphic call.
     return false;
   }
-  GrowableArray<intptr_t> class_ids(call->ic_data()->num_args_tested());
-  ASSERT(call->ic_data()->num_args_tested() <= call->ArgumentCount());
-  for (intptr_t i = 0; i < call->ic_data()->num_args_tested(); i++) {
+  GrowableArray<intptr_t> class_ids(call->ic_data()->NumArgsTested());
+  ASSERT(call->ic_data()->NumArgsTested() <= call->ArgumentCount());
+  for (intptr_t i = 0; i < call->ic_data()->NumArgsTested(); i++) {
     const intptr_t cid = call->PushArgumentAt(i)->value()->Type()->ToCid();
     class_ids.Add(cid);
   }
 
   const Token::Kind op_kind = call->token_kind();
   if (Token::IsRelationalOperator(op_kind) ||
       Token::IsEqualityOperator(op_kind) ||
       Token::IsBinaryOperator(op_kind)) {
     // Guess cid: if one of the inputs is a number assume that the other
     // is a number of same type.
@@ skipping 41 matching lines @@
   } else {
     ASSERT(class_ids.length() == 1);
     ic_data.AddReceiverCheck(class_ids[0], function);
   }
   call->set_ic_data(&ic_data);
   return true;
 }
 
 
 static const ICData& TrySpecializeICData(const ICData& ic_data, intptr_t cid) {
-  ASSERT(ic_data.num_args_tested() == 1);
+  ASSERT(ic_data.NumArgsTested() == 1);
 
   if ((ic_data.NumberOfChecks() == 1) &&
       (ic_data.GetReceiverClassIdAt(0) == cid)) {
     return ic_data;  // Nothing to do
   }
 
   const Function& function =
       Function::Handle(ic_data.GetTargetForReceiverClassId(cid));
   // TODO(fschneider): Try looking up the function on the class if it is
   // not found in the ICData.
   if (!function.IsNull()) {
     const ICData& new_ic_data = ICData::ZoneHandle(ICData::New(
-        Function::Handle(ic_data.function()),
+        Function::Handle(ic_data.owner()),
         String::Handle(ic_data.target_name()),
         Object::empty_array(),  // Dummy argument descriptor.
         ic_data.deopt_id(),
-        ic_data.num_args_tested()));
-    new_ic_data.set_deopt_reason(ic_data.deopt_reason());
+        ic_data.NumArgsTested()));
+    new_ic_data.SetDeoptReasons(ic_data.DeoptReasons());
     new_ic_data.AddReceiverCheck(cid, function);
     return new_ic_data;
   }
 
   return ic_data;
 }
 
 
 void FlowGraphOptimizer::SpecializePolymorphicInstanceCall(
     PolymorphicInstanceCallInstr* call) {
@@ skipping 605 matching lines @@
     }
   }
 }
 
 
 static bool ICDataHasReceiverArgumentClassIds(const ICData& ic_data,
                                               intptr_t receiver_class_id,
                                               intptr_t argument_class_id) {
   ASSERT(receiver_class_id != kIllegalCid);
   ASSERT(argument_class_id != kIllegalCid);
-  if (ic_data.num_args_tested() != 2) return false;
+  if (ic_data.NumArgsTested() != 2) return false;
 
   Function& target = Function::Handle();
   const intptr_t len = ic_data.NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
     GrowableArray<intptr_t> class_ids;
     ic_data.GetCheckAt(i, &class_ids, &target);
     ASSERT(class_ids.length() == 2);
     if ((class_ids[0] == receiver_class_id) &&
         (class_ids[1] == argument_class_id)) {
       return true;
@@ skipping 13 matching lines @@
   return false;
 }
 
 
 // Returns true if ICData tests two arguments and all ICData cids are in the
 // required sets 'receiver_class_ids' or 'argument_class_ids', respectively.
 static bool ICDataHasOnlyReceiverArgumentClassIds(
     const ICData& ic_data,
     const GrowableArray<intptr_t>& receiver_class_ids,
     const GrowableArray<intptr_t>& argument_class_ids) {
-  if (ic_data.num_args_tested() != 2) return false;
+  if (ic_data.NumArgsTested() != 2) return false;
   Function& target = Function::Handle();
   const intptr_t len = ic_data.NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
     GrowableArray<intptr_t> class_ids;
     ic_data.GetCheckAt(i, &class_ids, &target);
     ASSERT(class_ids.length() == 2);
     if (!ClassIdIsOneOf(class_ids[0], receiver_class_ids) ||
         !ClassIdIsOneOf(class_ids[1], argument_class_ids)) {
       return false;
     }
@@ skipping 116 matching lines @@
                 ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecks()),
                 call->deopt_id(),
                 call->env(),
                 call);
 }
 
 
 static bool ArgIsAlways(intptr_t cid,
                         const ICData& ic_data,
                         intptr_t arg_number) {
-  ASSERT(ic_data.num_args_tested() > arg_number);
+  ASSERT(ic_data.NumArgsTested() > arg_number);
   const intptr_t num_checks = ic_data.NumberOfChecks();
   if (num_checks == 0) return false;
   for (intptr_t i = 0; i < num_checks; i++) {
     if (ic_data.GetClassIdAt(i, arg_number) != cid) return false;
   }
   return true;
 }
 
 
 static bool CanUnboxInt32() {
@@ skipping 576 matching lines @@
                                      array_cid,
                                      &array,
                                      index,
                                      &cursor);
 
   intptr_t deopt_id = Isolate::kNoDeoptId;
   if ((array_cid == kTypedDataInt32ArrayCid) ||
       (array_cid == kTypedDataUint32ArrayCid)) {
     // Set deopt_id if we can optimistically assume that the result is Smi.
     // Assume mixed Mint/Smi if this instruction caused deoptimization once.
-    deopt_id = (ic_data.deopt_reason() == kDeoptUnknown) ?
-        call->deopt_id() : Isolate::kNoDeoptId;
+    deopt_id = ic_data.HasDeoptReasons() ?
+        Isolate::kNoDeoptId : call->deopt_id();
   }
 
   // Array load and return.
   intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(array_cid);
   *last = new LoadIndexedInstr(new Value(array),
                                new Value(index),
                                index_scale,
                                array_cid,
                                deopt_id);
   cursor = flow_graph()->AppendTo(
@@ skipping 160 matching lines @@
   }
   return false;
 }
 
 
 static bool SmiFitsInDouble() { return kSmiBits < 53; }
 
 bool FlowGraphOptimizer::TryReplaceWithEqualityOp(InstanceCallInstr* call,
                                                   Token::Kind op_kind) {
   const ICData& ic_data = *call->ic_data();
-  ASSERT(ic_data.num_args_tested() == 2);
+  ASSERT(ic_data.NumArgsTested() == 2);
 
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   intptr_t cid = kIllegalCid;
   if (HasOnlyTwoOf(ic_data, kOneByteStringCid)) {
     if (TryStringLengthOneEquality(call, op_kind)) {
       return true;
     } else {
@@ skipping 83 matching lines @@
                                                         cid,
                                                         call->deopt_id());
   ReplaceCall(call, comp);
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithRelationalOp(InstanceCallInstr* call,
                                                     Token::Kind op_kind) {
   const ICData& ic_data = *call->ic_data();
-  ASSERT(ic_data.num_args_tested() == 2);
+  ASSERT(ic_data.NumArgsTested() == 2);
 
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   intptr_t cid = kIllegalCid;
   if (HasOnlyTwoOf(ic_data, kSmiCid)) {
     InsertBefore(call,
                  new CheckSmiInstr(new Value(left), call->deopt_id()),
                  call->env(),
@@ skipping 44 matching lines @@
                                                 Token::Kind op_kind) {
   intptr_t operands_type = kIllegalCid;
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   switch (op_kind) {
     case Token::kADD:
     case Token::kSUB:
       if (HasOnlyTwoOf(ic_data, kSmiCid)) {
         // Don't generate smi code if the IC data is marked because
         // of an overflow.
-        operands_type = (ic_data.deopt_reason() == kDeoptBinarySmiOp)
+        operands_type = ic_data.HasDeoptReason(ICData::kDeoptBinarySmiOp)
             ? kMintCid
             : kSmiCid;
       } else if (HasTwoMintOrSmi(ic_data) &&
                  FlowGraphCompiler::SupportsUnboxedMints()) {
         // Don't generate mint code if the IC data is marked because of an
         // overflow.
-        if (ic_data.deopt_reason() == kDeoptBinaryMintOp) return false;
+        if (ic_data.HasDeoptReason(ICData::kDeoptBinaryMintOp)) return false;
         operands_type = kMintCid;
       } else if (ShouldSpecializeForDouble(ic_data)) {
         operands_type = kDoubleCid;
       } else if (HasOnlyTwoOf(ic_data, kFloat32x4Cid)) {
         operands_type = kFloat32x4Cid;
       } else if (HasOnlyTwoOf(ic_data, kInt32x4Cid)) {
         operands_type = kInt32x4Cid;
       } else if (HasOnlyTwoOf(ic_data, kFloat64x2Cid)) {
         operands_type = kFloat64x2Cid;
       } else {
         return false;
       }
       break;
     case Token::kMUL:
       if (HasOnlyTwoOf(ic_data, kSmiCid)) {
         // Don't generate smi code if the IC data is marked because of an
         // overflow.
         // TODO(fschneider): Add unboxed mint multiplication.
-        if (ic_data.deopt_reason() == kDeoptBinarySmiOp) return false;
+        if (ic_data.HasDeoptReason(ICData::kDeoptBinarySmiOp)) return false;
         operands_type = kSmiCid;
       } else if (ShouldSpecializeForDouble(ic_data)) {
         operands_type = kDoubleCid;
       } else if (HasOnlyTwoOf(ic_data, kFloat32x4Cid)) {
         operands_type = kFloat32x4Cid;
       } else if (HasOnlyTwoOf(ic_data, kFloat64x2Cid)) {
         operands_type = kFloat64x2Cid;
       } else {
         return false;
       }
@@ skipping 22 matching lines @@
       } else {
         return false;
       }
       break;
     case Token::kSHR:
     case Token::kSHL:
       if (HasOnlyTwoOf(ic_data, kSmiCid)) {
         // Left shift may overflow from smi into mint or big ints.
         // Don't generate smi code if the IC data is marked because
         // of an overflow.
-        if (ic_data.deopt_reason() == kDeoptShiftMintOp) {
+        if (ic_data.HasDeoptReason(ICData::kDeoptShiftMintOp)) {
           return false;
         }
-        operands_type = (ic_data.deopt_reason() == kDeoptBinarySmiOp)
+        operands_type = ic_data.HasDeoptReason(ICData::kDeoptBinarySmiOp)
             ? kMintCid
             : kSmiCid;
       } else if (HasTwoMintOrSmi(ic_data) &&
                  HasOnlyOneSmi(ICData::Handle(
                      ic_data.AsUnaryClassChecksForArgNr(1)))) {
         // Don't generate mint code if the IC data is marked because of an
         // overflow.
-        if (ic_data.deopt_reason() == kDeoptShiftMintOp) {
+        if (ic_data.HasDeoptReason(ICData::kDeoptShiftMintOp)) {
           return false;
         }
         // Check for smi/mint << smi or smi/mint >> smi.
         operands_type = kMintCid;
       } else {
         return false;
       }
       break;
     case Token::kMOD:
     case Token::kTRUNCDIV:
       if (HasOnlyTwoOf(ic_data, kSmiCid)) {
-        if (ic_data.deopt_reason() == kDeoptBinarySmiOp) {
+        if (ic_data.HasDeoptReason(ICData::kDeoptBinarySmiOp)) {
           return false;
         }
         operands_type = kSmiCid;
       } else {
         return false;
       }
       break;
     default:
       UNREACHABLE();
   }
@@ skipping 782 matching lines @@
   }
 
   if (class_ids[0] == kDoubleCid) {
     switch (recognized_kind) {
       case MethodRecognizer::kDoubleToInteger: {
         AddReceiverCheck(call);
         ASSERT(call->HasICData());
         const ICData& ic_data = *call->ic_data();
         Definition* input = call->ArgumentAt(0);
         Definition* d2i_instr = NULL;
-        if (ic_data.deopt_reason() == kDeoptDoubleToSmi) {
+        if (ic_data.HasDeoptReason(ICData::kDeoptDoubleToSmi)) {
           // Do not repeatedly deoptimize because result didn't fit into Smi.
           d2i_instr = new DoubleToIntegerInstr(new Value(input), call);
         } else {
           // Optimistically assume result fits into Smi.
           d2i_instr = new DoubleToSmiInstr(new Value(input), call->deopt_id());
         }
         ReplaceCall(call, d2i_instr);
         return true;
       }
       case MethodRecognizer::kDoubleMod:
@@ skipping 87 matching lines @@
   if ((class_ids[0] == kInt32x4Cid) && (ic_data.NumberOfChecks() == 1)) {
     return TryInlineInt32x4Method(call, recognized_kind);
   }
 
   if ((class_ids[0] == kFloat64x2Cid) && (ic_data.NumberOfChecks() == 1)) {
     return TryInlineFloat64x2Method(call, recognized_kind);
   }
 
   if (recognized_kind == MethodRecognizer::kIntegerLeftShiftWithMask32) {
     ASSERT(call->ArgumentCount() == 3);
-    ASSERT(ic_data.num_args_tested() == 2);
+    ASSERT(ic_data.NumArgsTested() == 2);
     Definition* value = call->ArgumentAt(0);
     Definition* count = call->ArgumentAt(1);
     Definition* int32_mask = call->ArgumentAt(2);
     if (HasOnlyTwoOf(ic_data, kSmiCid)) {
-      if (ic_data.deopt_reason() == kDeoptShiftMintOp) {
+      if (ic_data.HasDeoptReason(ICData::kDeoptShiftMintOp)) {
         return false;
       }
       // We cannot overflow. The input value must be a Smi
       AddCheckSmi(value, call->deopt_id(), call->env(), call);
       AddCheckSmi(count, call->deopt_id(), call->env(), call);
       ASSERT(int32_mask->IsConstant());
       const Integer& mask_literal = Integer::Cast(
           int32_mask->AsConstant()->value());
       const int64_t mask_value = mask_literal.AsInt64Value();
       ASSERT(mask_value >= 0);
@@ skipping 16 matching lines @@
                                  new Value(left_shift), new Value(int32_mask),
                                  call->deopt_id());
         ReplaceCall(call, bit_and);
       }
       return true;
     }
 
     if (HasTwoMintOrSmi(ic_data) &&
         HasOnlyOneSmi(ICData::Handle(ic_data.AsUnaryClassChecksForArgNr(1)))) {
       if (!FlowGraphCompiler::SupportsUnboxedMints() ||
-          (ic_data.deopt_reason() == kDeoptShiftMintOp)) {
+          ic_data.HasDeoptReason(ICData::kDeoptShiftMintOp)) {
         return false;
       }
       ShiftMintOpInstr* left_shift =
           new ShiftMintOpInstr(Token::kSHL,
                                new Value(value), new Value(count),
                                call->deopt_id());
       InsertBefore(call, left_shift, call->env(), Definition::kValue);
       BinaryMintOpInstr* bit_and =
           new BinaryMintOpInstr(Token::kBIT_AND,
                                 new Value(left_shift), new Value(int32_mask),
@@ skipping 405 matching lines @@
                                            view_cid,
                                            &array,
                                            index,
                                            &cursor);
 
   intptr_t deopt_id = Isolate::kNoDeoptId;
   if ((array_cid == kTypedDataInt32ArrayCid) ||
       (array_cid == kTypedDataUint32ArrayCid)) {
     // Set deopt_id if we can optimistically assume that the result is Smi.
     // Assume mixed Mint/Smi if this instruction caused deoptimization once.
-    deopt_id = (ic_data.deopt_reason() == kDeoptUnknown) ?
-        call->deopt_id() : Isolate::kNoDeoptId;
+    deopt_id = ic_data.HasDeoptReasons() ?
+        Isolate::kNoDeoptId : call->deopt_id();
   }
 
   *last = new LoadIndexedInstr(new Value(array),
                                new Value(index),
                                1,
                                view_cid,
                                deopt_id);
   cursor = flow_graph()->AppendTo(
       cursor,
       *last,
@@ skipping 60 matching lines @@
                                 Isolate::kNoDeoptId,
                                 1);
       value_check.AddReceiverCheck(kSmiCid, target);
       break;
     }
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
       // We don't have ICData for the value stored, so we optimistically assume
       // smis first. If we ever deoptimized here, we require to unbox the value
       // before storing to handle the mint case, too.
-      if (i_call->ic_data()->deopt_reason() == kDeoptUnknown) {
+      if (!i_call->ic_data()->HasDeoptReasons()) {
         value_check = ICData::New(flow_graph_->parsed_function().function(),
                                   i_call->function_name(),
                                   Object::empty_array(),  // Dummy args. descr.
                                   Isolate::kNoDeoptId,
                                   1);
         value_check.AddReceiverCheck(kSmiCid, target);
       }
       break;
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid: {
@@ skipping 174 matching lines @@
 // return mapping cid->result in 'results' (i : cid; i + 1: result).
 // If all tests yield the same result, return it otherwise return Bool::null.
 // If no mapping is possible, 'results' is empty.
 // An instance-of test returning all same results can be converted to a class
 // check.
 RawBool* FlowGraphOptimizer::InstanceOfAsBool(
     const ICData& ic_data,
     const AbstractType& type,
     ZoneGrowableArray<intptr_t>* results) const {
   results->Clear();
-  ASSERT(ic_data.num_args_tested() == 1);  // Unary checks only.
+  ASSERT(ic_data.NumArgsTested() == 1);  // Unary checks only.
   if (!type.IsInstantiated() || type.IsMalformedOrMalbounded()) {
     return Bool::null();
   }
   const Class& type_class = Class::Handle(type.type_class());
   const intptr_t num_type_args = type_class.NumTypeArguments();
   if (num_type_args > 0) {
     // Only raw types can be directly compared, thus disregarding type
     // arguments.
     const intptr_t num_type_params = type_class.NumTypeParameters();
     const intptr_t from_index = num_type_args - num_type_params;
@@ skipping 523 matching lines @@
     } else {
       FlowGraph::AddToGuardedFields(flow_graph_->guarded_fields(), &field);
     }
   }
 }
 
 
 bool FlowGraphOptimizer::TryInlineInstanceSetter(InstanceCallInstr* instr,
                                                  const ICData& unary_ic_data) {
   ASSERT((unary_ic_data.NumberOfChecks() > 0) &&
-      (unary_ic_data.num_args_tested() == 1));
+      (unary_ic_data.NumArgsTested() == 1));
   if (FLAG_enable_type_checks) {
     // Checked mode setters are inlined like normal methods by conventional
     // inlining.
     return false;
   }
 
   ASSERT(instr->HasICData());
   if (unary_ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     return false;
@@ skipping 4911 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart