VM: Speculative inlining in precompiled code.

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/compiler.h"
 #include "vm/cpu.h"
@@ skipping 4184 matching lines @@
                                    new(Z) Value(left),
                                    new(Z) Value(instantiator),
                                    new(Z) Value(type_args),
                                    type,
                                    dst_name,
                                    call->deopt_id());
   ReplaceCall(call, assert_as);
 }
 
 
+bool FlowGraphOptimizer::IsBlackListed(intptr_t deopt_id) {

[srdjan, 2015/11/17 17:35:23]

s/deopt_id/call_deopt_id/ makes it clearer IMO.

[srdjan, 2015/11/17 17:35:23]

s/IsBlackListed/ IsBlackListedForInlining/

[Florian Schneider, 2015/11/17 19:38:56]

Done.

[Florian Schneider, 2015/11/17 19:38:56]

Done.

+  for (intptr_t i = 0; i < inlining_black_list_->length(); ++i) {
+    if ((*inlining_black_list_)[i] == deopt_id) return true;
+  }
+  return false;
+}
+
 // Special optimizations when running in --noopt mode.
 void FlowGraphOptimizer::InstanceCallNoopt(InstanceCallInstr* instr) {
   // TODO(srdjan): Investigate other attempts, as they are not allowed to
   // deoptimize.
 
   // Type test is special as it always gets converted into inlined code.
   const Token::Kind op_kind = instr->token_kind();
   if (Token::IsTypeTestOperator(op_kind)) {
     ReplaceWithInstanceOf(instr);
     return;
   }
   if (Token::IsTypeCastOperator(op_kind)) {
     ReplaceWithTypeCast(instr);
     return;
   }
 
   if ((op_kind == Token::kGET) &&
       TryInlineInstanceGetter(instr, false /* no checks allowed */)) {
     return;
   }
   const ICData& unary_checks =
       ICData::ZoneHandle(Z, instr->ic_data()->AsUnaryClassChecks());
   if ((unary_checks.NumberOfChecks() > 0) &&
       (op_kind == Token::kSET) &&
       TryInlineInstanceSetter(instr, unary_checks, false /* no checks */)) {
     return;
   }
 
+  if (use_speculative_inlining_ &&
+      !IsBlackListed(instr->deopt_id()) &&
+      unary_checks.NumberOfChecks() > 0) {

[srdjan, 2015/11/17 17:35:23]

Add parentheses

[Florian Schneider, 2015/11/17 19:38:56]

Done.

+    if ((op_kind == Token::kINDEX) && TryReplaceWithIndexedOp(instr)) {
+      return;
+    }
+    if ((op_kind == Token::kASSIGN_INDEX) && TryReplaceWithIndexedOp(instr)) {
+      return;
+    }
+    if (op_kind == Token::kEQ && TryReplaceWithEqualityOp(instr, op_kind)) {

[srdjan, 2015/11/17 17:35:23]

Add parentheses

[Florian Schneider, 2015/11/17 19:38:56]

Done.

+      return;
+    }
+
+    if (Token::IsRelationalOperator(op_kind) &&
+        TryReplaceWithRelationalOp(instr, op_kind)) {
+      return;
+    }
+
+    if (Token::IsBinaryOperator(op_kind) &&
+        TryReplaceWithBinaryOp(instr, op_kind)) {
+      return;
+    }
+    if (Token::IsUnaryOperator(op_kind) &&
+        TryReplaceWithUnaryOp(instr, op_kind)) {
+      return;
+    }
+  }
+
   bool has_one_target =
       (unary_checks.NumberOfChecks() > 0) && unary_checks.HasOneTarget();
   if (has_one_target) {
     // Check if the single target is a polymorphic target, if it is,
     // we don't have one target.
     const Function& target =
         Function::Handle(Z, unary_checks.GetTargetAt(0));
     const bool polymorphic_target = MethodRecognizer::PolymorphicTarget(target);
     has_one_target = !polymorphic_target;
   }
@@ skipping 926 matching lines @@
                                 Instruction* instr) {
   return IsLoadEliminationCandidate(instr) &&
       (sets != NULL) &&
       instr->HasPlaceId() &&
       ((*sets)[loop_header_index] != NULL) &&
       (*sets)[loop_header_index]->Contains(instr->place_id());
 }
 
 
 void LICM::OptimisticallySpecializeSmiPhis() {
-  if (!flow_graph()->function().allows_hoisting_check_class()) {
+  if (!flow_graph()->function().allows_hoisting_check_class() ||
+      Compiler::always_optimize()) {

[srdjan, 2015/11/17 17:35:23]

Add comment why not do it for precompilation.

[Florian Schneider, 2015/11/17 19:38:56]

Done.

     // Do not hoist any.
     return;
   }
 
   const ZoneGrowableArray<BlockEntryInstr*>& loop_headers =
       flow_graph()->LoopHeaders();
 
   for (intptr_t i = 0; i < loop_headers.length(); ++i) {
     JoinEntryInstr* header = loop_headers[i]->AsJoinEntry();
     // Skip loop that don't have a pre-header block.
@@ skipping 3599 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, *slots);
   }
 }
 
 
 }  // namespace dart