With --noopt run unoptimized code through optimizer, more optimizations can be done later.

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"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_range_analysis.h"
 #include "vm/hash_map.h"
 #include "vm/il_printer.h"
 #include "vm/intermediate_language.h"
 #include "vm/object_store.h"
@@ skipping 61 matching lines @@
 #endif
 }
 
 
 // Optimize instance calls using ICData.
 void FlowGraphOptimizer::ApplyICData() {
   VisitBlocks();
 }
 
 
+void FlowGraphOptimizer::PopulateWithICData() {
+  ASSERT(current_iterator_ == NULL);
+  for (intptr_t i = 0; i < block_order_.length(); ++i) {
+    BlockEntryInstr* entry = block_order_[i];
+    ForwardInstructionIterator it(entry);
+    for (; !it.Done(); it.Advance()) {
+      Instruction* instr = it.Current();
+      if (instr->IsInstanceCall()) {
+        InstanceCallInstr* call = instr->AsInstanceCall();
+        if (!call->HasICData()) {
+          const Array& arguments_descriptor =
+              Array::Handle(zone(),
+                  ArgumentsDescriptor::New(call->ArgumentCount(),
+                                           call->argument_names()));
+          const ICData& ic_data = ICData::ZoneHandle(zone(), ICData::New(
+              function(), call->function_name(),
+              arguments_descriptor, call->deopt_id(),
+              call->checked_argument_count()));
+          call->set_ic_data(&ic_data);
+        }
+      }
+    }
+    current_iterator_ = NULL;
+  }
+}
+
+
 // Optimize instance calls using cid.  This is called after optimizer
 // converted instance calls to instructions. Any remaining
 // instance calls are either megamorphic calls, cannot be optimized or
 // have no runtime type feedback collected.
 // Attempts to convert an instance call (IC call) using propagated class-ids,
 // e.g., receiver class id, guarded-cid, or by guessing cid-s.
 void FlowGraphOptimizer::ApplyClassIds() {
   ASSERT(current_iterator_ == NULL);
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* entry = block_order_[i];
@@ skipping 55 matching lines @@
     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.
-    const intptr_t cid_0 = class_ids[0];
-    const intptr_t cid_1 = class_ids[1];
-    if ((cid_0 == kDynamicCid) && (IsNumberCid(cid_1))) {
-      class_ids[0] = cid_1;
-    } else if (IsNumberCid(cid_0) && (cid_1 == kDynamicCid)) {
-      class_ids[1] = cid_0;
+    if (Compiler::guess_other_cid()) {
+      const intptr_t cid_0 = class_ids[0];
+      const intptr_t cid_1 = class_ids[1];
+      if ((cid_0 == kDynamicCid) && (IsNumberCid(cid_1))) {
+        class_ids[0] = cid_1;
+      } else if (IsNumberCid(cid_0) && (cid_1 == kDynamicCid)) {
+        class_ids[1] = cid_0;
+      }
     }
   }
 
   for (intptr_t i = 0; i < class_ids.length(); i++) {
     if (class_ids[i] == kDynamicCid) {
       // Not all cid-s known.
       return false;
     }
   }
 
@@ skipping 2075 matching lines @@
     const String& name = (kind == RawFunction::kMethodExtractor)
         ? String::Handle(Z, Field::NameFromGetter(call->function_name()))
         : call->function_name();
     return thread()->cha()->HasOverride(Class::Handle(Z, function.Owner()),
                                         name);
   }
   return true;
 }
 
 
-void FlowGraphOptimizer::InlineImplicitInstanceGetter(InstanceCallInstr* call) {
+bool FlowGraphOptimizer::InlineImplicitInstanceGetter(InstanceCallInstr* call,
+                                                      bool allow_check) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.HasOneTarget());
   Function& target = Function::Handle(Z);
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   ASSERT(class_ids.length() == 1);
   // Inline implicit instance getter.
   const String& field_name =
       String::Handle(Z, Field::NameFromGetter(call->function_name()));
   const Field& field =
       Field::ZoneHandle(Z, GetField(class_ids[0], field_name));
   ASSERT(!field.IsNull());
 
   if (InstanceCallNeedsClassCheck(call, RawFunction::kImplicitGetter)) {
+    if (!allow_check) {
+      return false;
+    }
     AddReceiverCheck(call);
   }
   LoadFieldInstr* load = new(Z) LoadFieldInstr(
       new(Z) Value(call->ArgumentAt(0)),
       &field,
       AbstractType::ZoneHandle(Z, field.type()),
       call->token_pos());
   load->set_is_immutable(field.is_final());
   if (field.guarded_cid() != kIllegalCid) {
     if (!field.is_nullable() || (field.guarded_cid() == kNullCid)) {
       load->set_result_cid(field.guarded_cid());
     }
     FlowGraph::AddToGuardedFields(flow_graph_->guarded_fields(), &field);
   }
 
   // Discard the environment from the original instruction because the load
   // can't deoptimize.
   call->RemoveEnvironment();
   ReplaceCall(call, load);
 
   if (load->result_cid() != kDynamicCid) {
     // Reset value types if guarded_cid was used.
     for (Value::Iterator it(load->input_use_list());
          !it.Done();
          it.Advance()) {
       it.Current()->SetReachingType(NULL);
     }
   }
+  return true;
 }
 
 
 bool FlowGraphOptimizer::InlineFloat32x4Getter(InstanceCallInstr* call,
                                                MethodRecognizer::Kind getter) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
@@ skipping 257 matching lines @@
   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 FlowGraphOptimizer::TryInlineInstanceGetter(InstanceCallInstr* call) {
+// Returns false if 'allow_check' is false and a check is needed.
+bool FlowGraphOptimizer::TryInlineInstanceGetter(InstanceCallInstr* call,
+                                                 bool allow_check) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if (ic_data.NumberOfUsedChecks() == 0) {
     // No type feedback collected.
     return false;
   }
 
   if (!ic_data.HasOneTarget()) {
     // Polymorphic sites are inlined like normal methods by conventional
     // inlining in FlowGraphInliner.
     return false;
   }
 
   const Function& target = Function::Handle(Z, ic_data.GetTargetAt(0));
   if (target.kind() != RawFunction::kImplicitGetter) {
     // Non-implicit getters are inlined like normal methods by conventional
     // inlining in FlowGraphInliner.
     return false;
   }
-  InlineImplicitInstanceGetter(call);
-  return true;
+  return InlineImplicitInstanceGetter(call, allow_check);
 }
 
 
 bool FlowGraphOptimizer::TryReplaceInstanceCallWithInline(
     InstanceCallInstr* call) {
   Function& target = Function::Handle(Z);
   GrowableArray<intptr_t> class_ids;
   call->ic_data()->GetCheckAt(0, &class_ids, &target);
   const intptr_t receiver_cid = class_ids[0];
 
@@ skipping 500 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::TryInlineFloat32x4Constructor(
     StaticCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
+  if (Compiler::always_optimize()) {
+    // Cannot handle unboxed instructions.
+    return false;
+  }
   if (!ShouldInlineSimd()) {
     return false;
   }
   if (recognized_kind == MethodRecognizer::kFloat32x4Zero) {
     Float32x4ZeroInstr* zero = new(Z) Float32x4ZeroInstr();
     ReplaceCall(call, zero);
     return true;
   } else if (recognized_kind == MethodRecognizer::kFloat32x4Splat) {
     Float32x4SplatInstr* splat =
         new(Z) Float32x4SplatInstr(
@@ skipping 23 matching lines @@
     ReplaceCall(call, cast);
     return true;
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::TryInlineFloat64x2Constructor(
     StaticCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
+  if (Compiler::always_optimize()) {
+    // Cannot handle unboxed instructions.
+    return false;
+  }
   if (!ShouldInlineSimd()) {
     return false;
   }
   if (recognized_kind == MethodRecognizer::kFloat64x2Zero) {
     Float64x2ZeroInstr* zero = new(Z) Float64x2ZeroInstr();
     ReplaceCall(call, zero);
     return true;
   } else if (recognized_kind == MethodRecognizer::kFloat64x2Splat) {
     Float64x2SplatInstr* splat =
         new(Z) Float64x2SplatInstr(
@@ skipping 15 matching lines @@
     ReplaceCall(call, cast);
     return true;
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::TryInlineInt32x4Constructor(
     StaticCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
+  if (Compiler::always_optimize()) {
+    // Cannot handle unboxed instructions.
+    return false;
+  }
   if (!ShouldInlineSimd()) {
     return false;
   }
   if (recognized_kind == MethodRecognizer::kInt32x4BoolConstructor) {
     Int32x4BoolConstructorInstr* con =
         new(Z) Int32x4BoolConstructorInstr(
             new(Z) Value(call->ArgumentAt(1)),
             new(Z) Value(call->ArgumentAt(2)),
             new(Z) Value(call->ArgumentAt(3)),
             new(Z) Value(call->ArgumentAt(4)),
@@ skipping 928 matching lines @@
 
 
 // Tries to optimize instance call by replacing it with a faster instruction
 // (e.g, binary op, field load, ..).
 void FlowGraphOptimizer::VisitInstanceCall(InstanceCallInstr* instr) {
   if (!instr->HasICData() || (instr->ic_data()->NumberOfUsedChecks() == 0)) {
     return;
   }
 
   const Token::Kind op_kind = instr->token_kind();
+  if (Compiler::always_optimize()) {
+    // TODO(srdjan): Investigate other attempts, as they are not allowed to
+    // deoptimize.
+    if ((op_kind == Token::kGET) && TryInlineInstanceGetter(instr, false)) {
+      return;
+    }
+    return;
+  }
+
   // Type test is special as it always gets converted into inlined code.
   if (Token::IsTypeTestOperator(op_kind)) {
     ReplaceWithInstanceOf(instr);
     return;
   }
 
   if (Token::IsTypeCastOperator(op_kind)) {
     ReplaceWithTypeCast(instr);
     return;
   }
@@ skipping 103 matching lines @@
       unary_kind = MathUnaryInstr::kSin;
       break;
     case MethodRecognizer::kMathCos:
       unary_kind = MathUnaryInstr::kCos;
       break;
     default:
       unary_kind = MathUnaryInstr::kIllegal;
       break;
   }
   if (unary_kind != MathUnaryInstr::kIllegal) {
-    MathUnaryInstr* math_unary =
-        new(Z) MathUnaryInstr(unary_kind,
-                              new(Z) Value(call->ArgumentAt(0)),
-                              call->deopt_id());
-    ReplaceCall(call, math_unary);
+    if (Compiler::always_optimize()) {
+      // TODO(srdjan): Adapt MathUnaryInstr to allow tagged inputs as well.
+    } else {
+      MathUnaryInstr* math_unary =
+          new(Z) MathUnaryInstr(unary_kind,
+                                new(Z) Value(call->ArgumentAt(0)),
+                                call->deopt_id());
+      ReplaceCall(call, math_unary);
+    }
   } else if ((recognized_kind == MethodRecognizer::kFloat32x4Zero) ||
              (recognized_kind == MethodRecognizer::kFloat32x4Splat) ||
              (recognized_kind == MethodRecognizer::kFloat32x4Constructor) ||
              (recognized_kind == MethodRecognizer::kFloat32x4FromFloat64x2)) {
     TryInlineFloat32x4Constructor(call, recognized_kind);
   } else if ((recognized_kind == MethodRecognizer::kFloat64x2Constructor) ||
              (recognized_kind == MethodRecognizer::kFloat64x2Zero) ||
              (recognized_kind == MethodRecognizer::kFloat64x2Splat) ||
              (recognized_kind == MethodRecognizer::kFloat64x2FromFloat32x4)) {
     TryInlineFloat64x2Constructor(call, recognized_kind);
@@ skipping 40 matching lines @@
                       call);
         AddCheckClass(min_max->right()->definition(),
                       unary_checks,
                       call->deopt_id(),
                       call->env(),
                       call);
         ReplaceCall(call, min_max);
       }
     }
   } else if (recognized_kind == MethodRecognizer::kMathDoublePow) {
+    if (Compiler::always_optimize()) {
+      // No UnboxDouble instructons allowed.
+      return;
+    }
     // We know that first argument is double, the second is num.
     // InvokeMathCFunctionInstr requires unboxed doubles. UnboxDouble
     // instructions contain type checks and conversions to double.
     ZoneGrowableArray<Value*>* args =
         new(Z) ZoneGrowableArray<Value*>(call->ArgumentCount());
     for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
       args->Add(new(Z) Value(call->ArgumentAt(i)));
     }
     InvokeMathCFunctionInstr* invoke =
         new(Z) InvokeMathCFunctionInstr(args,
@@ skipping 4228 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