Use off-heap data for class check instructions

runtime/vm/aot_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/aot_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 430 matching lines @@
                                Instruction* insert_before) {
   if (to_check->Type()->ToCid() != kSmiCid) {
     InsertBefore(insert_before,
                  new (Z) CheckSmiInstr(new (Z) Value(to_check), deopt_id,
                                        insert_before->token_pos()),
                  deopt_environment, FlowGraph::kEffect);
   }
 }
 
 
-Instruction* AotOptimizer::GetCheckClass(Definition* to_check,
-                                         const ICData& unary_checks,
-                                         intptr_t deopt_id,
-                                         TokenPosition token_pos) {
-  if ((unary_checks.NumberOfUsedChecks() == 1) &&
-      unary_checks.HasReceiverClassId(kSmiCid)) {
-    return new (Z) CheckSmiInstr(new (Z) Value(to_check), deopt_id, token_pos);
-  }
-  return new (Z) CheckClassInstr(new (Z) Value(to_check), deopt_id,
-                                 unary_checks, token_pos);
-}
-
-
 void AotOptimizer::AddCheckClass(Definition* to_check,
-                                 const ICData& unary_checks,
+                                 const Cids& cids,
                                  intptr_t deopt_id,
                                  Environment* deopt_environment,
                                  Instruction* insert_before) {
   // Type propagation has not run yet, we cannot eliminate the check.
-  Instruction* check = GetCheckClass(to_check, unary_checks, deopt_id,
-                                     insert_before->token_pos());
+  Instruction* check = flow_graph_->CreateCheckClass(
+      to_check, cids, deopt_id, insert_before->token_pos());
   InsertBefore(insert_before, check, deopt_environment, FlowGraph::kEffect);
 }
 
 
-void AotOptimizer::AddReceiverCheck(InstanceCallInstr* call) {
-  AddCheckClass(call->ArgumentAt(0),
-                ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecks()),
-                call->deopt_id(), call->env(), call);
+void AotOptimizer::AddChecksToArgNr(InstanceCallInstr* call,
+                                    Definition* instr,
+                                    int argument_number) {
+  const Cids* cids = Cids::Create(Z, *call->ic_data(), argument_number);
+  AddCheckClass(instr, *cids, call->deopt_id(), call->env(), call);
 }
 
 
 static bool ArgIsAlways(intptr_t cid,
                         const ICData& ic_data,
                         intptr_t arg_number) {
   ASSERT(ic_data.NumArgsTested() > arg_number);
   if (ic_data.NumberOfUsedChecks() == 0) {
     return false;
   }
   const intptr_t num_checks = ic_data.NumberOfChecks();
   for (intptr_t i = 0; i < num_checks; i++) {
     if (ic_data.IsUsedAt(i) && ic_data.GetClassIdAt(i, arg_number) != cid) {
       return false;
     }
   }
   return true;
 }
 
 
-bool AotOptimizer::TryReplaceWithIndexedOp(InstanceCallInstr* call) {
+bool AotOptimizer::TryReplaceWithIndexedOp(InstanceCallInstr* call,
+                                           const ICData* unary_checks) {
   // Check for monomorphic IC data.
-  if (!call->HasICData()) return false;
-  const ICData& ic_data =
-      ICData::Handle(Z, call->ic_data()->AsUnaryClassChecks());
-  if (!ic_data.NumberOfChecksIs(1)) {
+  ASSERT(unary_checks->NumberOfChecks() > 0);
+  if (unary_checks->NumberOfChecksIs(1)) {
     return false;
   }
   return FlowGraphInliner::TryReplaceInstanceCallWithInline(
       flow_graph_, current_iterator(), call);
 }
 
 
 // Return true if d is a string of length one (a constant or result from
 // from string-from-char-code instruction.
 static bool IsLengthOneString(Definition* d) {
@@ skipping 52 matching lines @@
 
     Definition* to_remove_right = NULL;
     Value* right_val = NULL;
     if (right->IsOneByteStringFromCharCode()) {
       // Skip string-from-char-code, and use its input as right value.
       OneByteStringFromCharCodeInstr* right_instr =
           right->AsOneByteStringFromCharCode();
       right_val = new (Z) Value(right_instr->char_code()->definition());
       to_remove_right = right_instr;
     } else {
-      const ICData& unary_checks_1 =
-          ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecksForArgNr(1));
-      AddCheckClass(right, unary_checks_1, call->deopt_id(), call->env(), call);
+      AddChecksToArgNr(call, right, /* arg_number = */ 1);
       // String-to-char-code instructions returns -1 (illegal charcode) if
       // string is not of length one.
       StringToCharCodeInstr* char_code_right = new (Z)
           StringToCharCodeInstr(new (Z) Value(right), kOneByteStringCid);
       InsertBefore(call, char_code_right, call->env(), FlowGraph::kValue);
       right_val = new (Z) Value(char_code_right);
     }
 
     // Comparing char-codes instead of strings.
     EqualityCompareInstr* comp =
@@ skipping 70 matching lines @@
   return false;
 }
 
 
 bool AotOptimizer::TryReplaceWithEqualityOp(InstanceCallInstr* call,
                                             Token::Kind op_kind) {
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
   ASSERT(call->ArgumentCount() == 2);
-  Definition* left = call->ArgumentAt(0);
-  Definition* right = call->ArgumentAt(1);
+  Definition* const left = call->ArgumentAt(0);
+  Definition* const right = call->ArgumentAt(1);
 
   intptr_t cid = kIllegalCid;
   if (HasOnlyTwoOf(ic_data, kOneByteStringCid)) {
     return TryStringLengthOneEquality(call, op_kind);
   } else if (HasOnlyTwoOf(ic_data, kSmiCid)) {
     InsertBefore(call,
                  new (Z) CheckSmiInstr(new (Z) Value(left), call->deopt_id(),
                                        call->token_pos()),
                  call->env(), FlowGraph::kEffect);
     InsertBefore(call,
@@ skipping 23 matching lines @@
     }
   } else {
     // Check if ICDData contains checks with Smi/Null combinations. In that case
     // we can still emit the optimized Smi equality operation but need to add
     // checks for null or Smi.
     GrowableArray<intptr_t> smi_or_null(2);
     smi_or_null.Add(kSmiCid);
     smi_or_null.Add(kNullCid);
     if (ICDataHasOnlyReceiverArgumentClassIds(ic_data, smi_or_null,
                                               smi_or_null)) {
-      const ICData& unary_checks_0 =
-          ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecks());
-      AddCheckClass(left, unary_checks_0, call->deopt_id(), call->env(), call);
+      AddChecksToArgNr(call, left, /* arg_number = */ 0);
+      AddChecksToArgNr(call, right, /* arg_number = */ 1);
 
-      const ICData& unary_checks_1 =
-          ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecksForArgNr(1));
-      AddCheckClass(right, unary_checks_1, call->deopt_id(), call->env(), call);
       cid = kSmiCid;
     } else {
       // Shortcut for equality with null.
       // TODO(vegorov): this optimization is not speculative and should
       // be hoisted out of this function.
       ConstantInstr* right_const = right->AsConstant();
       ConstantInstr* left_const = left->AsConstant();
       if ((right_const != NULL && right_const->value().IsNull()) ||
           (left_const != NULL && left_const->value().IsNull())) {
         StrictCompareInstr* comp = new (Z)
@@ skipping 337 matching lines @@
   return true;
 }
 
 
 bool AotOptimizer::InlineFloat32x4BinaryOp(InstanceCallInstr* call,
                                            Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->ArgumentCount() == 2);
-  Definition* left = call->ArgumentAt(0);
-  Definition* right = call->ArgumentAt(1);
-  // Type check left.
-  AddCheckClass(left, ICData::ZoneHandle(
-                          Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                call->deopt_id(), call->env(), call);
-  // Type check right.
-  AddCheckClass(right, ICData::ZoneHandle(
-                           Z, call->ic_data()->AsUnaryClassChecksForArgNr(1)),
-                call->deopt_id(), call->env(), call);
+  Definition* const left = call->ArgumentAt(0);
+  Definition* const right = call->ArgumentAt(1);
+  // Type check left and right.
+  AddChecksToArgNr(call, left, /* arg_number = */ 0);
+  AddChecksToArgNr(call, right, /* arg_number = */ 1);
   // Replace call.
   BinaryFloat32x4OpInstr* float32x4_bin_op = new (Z) BinaryFloat32x4OpInstr(
       op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
   ReplaceCall(call, float32x4_bin_op);
 
   return true;
 }
 
 
 bool AotOptimizer::InlineInt32x4BinaryOp(InstanceCallInstr* call,
                                          Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->ArgumentCount() == 2);
-  Definition* left = call->ArgumentAt(0);
-  Definition* right = call->ArgumentAt(1);
-  // Type check left.
-  AddCheckClass(left, ICData::ZoneHandle(
-                          Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                call->deopt_id(), call->env(), call);
-  // Type check right.
-  AddCheckClass(right, ICData::ZoneHandle(
-                           Z, call->ic_data()->AsUnaryClassChecksForArgNr(1)),
-                call->deopt_id(), call->env(), call);
+  Definition* const left = call->ArgumentAt(0);
+  Definition* const right = call->ArgumentAt(1);
+  // Type check left and right.
+  AddChecksToArgNr(call, left, /* arg_number = */ 0);
+  AddChecksToArgNr(call, right, /* arg_number = */ 1);
   // Replace call.
   BinaryInt32x4OpInstr* int32x4_bin_op = new (Z) BinaryInt32x4OpInstr(
       op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
   ReplaceCall(call, int32x4_bin_op);
   return true;
 }
 
 
 bool AotOptimizer::InlineFloat64x2BinaryOp(InstanceCallInstr* call,
                                            Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->ArgumentCount() == 2);
-  Definition* left = call->ArgumentAt(0);
-  Definition* right = call->ArgumentAt(1);
-  // Type check left.
-  AddCheckClass(
-      left, ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-      call->deopt_id(), call->env(), call);
-  // Type check right.
-  AddCheckClass(
-      right, ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecksForArgNr(1)),
-      call->deopt_id(), call->env(), call);
+  Definition* const left = call->ArgumentAt(0);
+  Definition* const right = call->ArgumentAt(1);
+  // Type check left and right.
+  AddChecksToArgNr(call, left, /* arg_number = */ 0);
+  AddChecksToArgNr(call, right, /* arg_number = */ 1);
   // Replace call.
   BinaryFloat64x2OpInstr* float64x2_bin_op = new (Z) BinaryFloat64x2OpInstr(
       op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
   ReplaceCall(call, float64x2_bin_op);
   return true;
 }
 
 
 // Only unique implicit instance getters can be currently handled.
 bool AotOptimizer::TryInlineInstanceGetter(InstanceCallInstr* call) {
@@ skipping 644 matching lines @@
   }
 
   if ((op_kind == Token::kEQ) && TryReplaceWithHaveSameRuntimeType(instr)) {
     return;
   }
 
   const ICData& unary_checks =
       ICData::ZoneHandle(Z, instr->ic_data()->AsUnaryClassChecks());
   const intptr_t number_of_checks = unary_checks.NumberOfChecks();
   if (IsAllowedForInlining(instr->deopt_id()) && number_of_checks > 0) {
-    if ((op_kind == Token::kINDEX) && TryReplaceWithIndexedOp(instr)) {
+    if ((op_kind == Token::kINDEX) &&
+        TryReplaceWithIndexedOp(instr, &unary_checks)) {
       return;
     }
-    if ((op_kind == Token::kASSIGN_INDEX) && TryReplaceWithIndexedOp(instr)) {
+    if ((op_kind == Token::kASSIGN_INDEX) &&
+        TryReplaceWithIndexedOp(instr, &unary_checks)) {
       return;
     }
     if ((op_kind == Token::kEQ) && TryReplaceWithEqualityOp(instr, op_kind)) {
       return;
     }
 
     if (Token::IsRelationalOperator(op_kind) &&
         TryReplaceWithRelationalOp(instr, op_kind)) {
       return;
     }
@@ skipping 85 matching lines @@
         Class::Handle(Z, isolate()->class_table()->At(receiver_cid));
 
     const Array& args_desc_array =
         Array::Handle(Z, ArgumentsDescriptor::New(instr->ArgumentCount(),
                                                   instr->argument_names()));
     ArgumentsDescriptor args_desc(args_desc_array);
     Function& function = Function::Handle(
         Z, Resolver::ResolveDynamicForReceiverClass(
                receiver_class, instr->function_name(), args_desc));
     if (!function.IsNull()) {
-      CallTargets* targets = new (Z) CallTargets();
+      CallTargets* targets = new (Z) CallTargets(Z);
       Function& target = Function::ZoneHandle(Z, function.raw());
-      targets->Add(CidRangeTarget(receiver_class.id(), receiver_class.id(),
-                                  &target, /*count = */ 1));
+      targets->Add(new (Z) TargetInfo(receiver_class.id(), receiver_class.id(),
+                                      &target, /*count = */ 1));
       PolymorphicInstanceCallInstr* call =
           new (Z) PolymorphicInstanceCallInstr(instr, *targets,
                                                /* with_checks = */ false,
                                                /* complete = */ true);
       instr->ReplaceWith(call, current_iterator());
       return;
     }
   }
 
   Definition* callee_receiver = instr->ArgumentAt(0);
@@ skipping 208 matching lines @@
                                               kDoubleCid)) {
           result_cid = kDoubleCid;
         } else if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid,
                                                      kSmiCid)) {
           result_cid = kSmiCid;
         }
         if (result_cid != kIllegalCid) {
           MathMinMaxInstr* min_max = new (Z) MathMinMaxInstr(
               recognized_kind, new (Z) Value(call->ArgumentAt(0)),
               new (Z) Value(call->ArgumentAt(1)), call->deopt_id(), result_cid);
-          const ICData& unary_checks =
-              ICData::ZoneHandle(Z, ic_data.AsUnaryClassChecks());
-          AddCheckClass(min_max->left()->definition(), unary_checks,
-                        call->deopt_id(), call->env(), call);
-          AddCheckClass(min_max->right()->definition(), unary_checks,
-                        call->deopt_id(), call->env(), call);
+          const Cids* cids = Cids::Create(Z, ic_data, 0);

[Vyacheslav Egorov (Google), 2017/05/09 21:07:27]

please add a comment here about what does 0 means.

[erikcorry, 2017/05/10 08:47:43]

Done.

+          AddCheckClass(min_max->left()->definition(), *cids, call->deopt_id(),
+                        call->env(), call);
+          AddCheckClass(min_max->right()->definition(), *cids, call->deopt_id(),
+                        call->env(), call);
           ReplaceCall(call, min_max);
         }
       }
       break;
     }
     case MethodRecognizer::kDoubleFromInteger: {
       if (call->HasICData() && call->ic_data()->NumberOfChecksIs(1)) {
         const ICData& ic_data = *call->ic_data();
         if (CanUnboxDouble()) {
           if (ArgIsAlways(kSmiCid, ic_data, 1)) {
@@ skipping 95 matching lines @@
                                   FlowGraph::kEffect);
         current_iterator()->RemoveCurrentFromGraph();
       }
     }
   }
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart