VM: Separate precompilation-specific code, make flags const.

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/branch_optimizer.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_inliner.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"
 #include "vm/parser.h"
-#include "vm/precompiler.h"
 #include "vm/resolver.h"
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
-DEFINE_FLAG(int, getter_setter_ratio, 13,
-    "Ratio of getter/setter usage used for double field unboxing heuristics");
-DEFINE_FLAG(bool, guess_icdata_cid, true,
-    "Artificially create type feedback for arithmetic etc. operations"
-    " by guessing the other unknown argument cid");
-DEFINE_FLAG(int, max_polymorphic_checks, 4,
-    "Maximum number of polymorphic check, otherwise it is megamorphic.");
-DEFINE_FLAG(int, max_equality_polymorphic_checks, 32,
-    "Maximum number of polymorphic checks in equality operator,"
-    " otherwise use megamorphic dispatch.");
-DEFINE_FLAG(bool, merge_sin_cos, false, "Merge sin/cos into sincos");
-DEFINE_FLAG(bool, trace_optimization, false, "Print optimization details.");
-DEFINE_FLAG(bool, truncating_left_shift, true,
-    "Optimize left shift to truncate if possible");
-DEFINE_FLAG(bool, use_cha_deopt, true,
-    "Use class hierarchy analysis even if it can cause deoptimization.");
-
-DECLARE_FLAG(bool, precompilation);
-DECLARE_FLAG(bool, polymorphic_with_deopt);
-DECLARE_FLAG(bool, trace_cha);
-DECLARE_FLAG(bool, trace_field_guards);
-
 // Quick access to the current isolate and zone.
 #define I (isolate())
 #define Z (zone())
 
 static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
 
 static bool CanUnboxDouble() {
   return FlowGraphCompiler::SupportsUnboxedDoubles();
 }
 
 
 static bool CanConvertUnboxedMintToDouble() {
   return FlowGraphCompiler::CanConvertUnboxedMintToDouble();
 }
 
 
 // Optimize instance calls using ICData.
 void FlowGraphOptimizer::ApplyICData() {
   VisitBlocks();
 }
 
 
-void FlowGraphOptimizer::PopulateWithICData() {
-  ASSERT(current_iterator_ == NULL);
-  for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
-       !block_it.Done();
-       block_it.Advance()) {
-    ForwardInstructionIterator it(block_it.Current());
-    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 (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
        !block_it.Done();
@@ skipping 95 matching lines @@
     if (class_ids.length() > 1) {
       ic_data.AddCheck(class_ids, function);
     } else {
       ASSERT(class_ids.length() == 1);
       ic_data.AddReceiverCheck(class_ids[0], function);
     }
     call->set_ic_data(&ic_data);
     return true;
   }
 
-#ifdef DART_PRECOMPILER
-  if (FLAG_precompilation &&
-      (isolate()->object_store()->unique_dynamic_targets() != Array::null())) {
-    // Check if the target is unique.
-    Function& target_function = Function::Handle(Z);
-    Precompiler::GetUniqueDynamicTarget(
-        isolate(), call->function_name(), &target_function);
-    // Calls with named arguments must be resolved/checked at runtime.
-    String& error_message = String::Handle(Z);
-    if (!target_function.IsNull() &&
-        !target_function.HasOptionalNamedParameters() &&
-        target_function.AreValidArgumentCounts(call->ArgumentCount(), 0,
-                                               &error_message)) {
-      const intptr_t cid = Class::Handle(Z, target_function.Owner()).id();
-      const ICData& ic_data = ICData::ZoneHandle(Z,
-          ICData::NewFrom(*call->ic_data(), 1));
-      ic_data.AddReceiverCheck(cid, target_function);
-      call->set_ic_data(&ic_data);
-      return true;
-    }
-  }
-#endif
-
   // Check if getter or setter in function's class and class is currently leaf.
   if (FLAG_guess_icdata_cid &&
       ((call->token_kind() == Token::kGET) ||
           (call->token_kind() == Token::kSET))) {
     const Class& owner_class = Class::Handle(Z, function().Owner());
     if (!owner_class.is_abstract() &&
         !CHA::HasSubclasses(owner_class) &&
         !CHA::IsImplemented(owner_class)) {
       const Array& args_desc_array = Array::Handle(Z,
           ArgumentsDescriptor::New(call->ArgumentCount(),
@@ skipping 1797 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::TryInlineFloat32x4Constructor(
     StaticCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
-  if (FLAG_precompilation) {
-    // 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 (FLAG_precompilation) {
-    // 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 (FLAG_precompilation) {
-    // 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 770 matching lines @@
                                             /* with_checks = */ false);
     instr->ReplaceWith(call, current_iterator());
     return;
   }
 }
 
 
 // Tries to optimize instance call by replacing it with a faster instruction
 // (e.g, binary op, field load, ..).
 void FlowGraphOptimizer::VisitInstanceCall(InstanceCallInstr* instr) {
-  if (FLAG_precompilation) {
-    InstanceCallNoopt(instr);
-    return;
-  }
-
   if (!instr->HasICData() || (instr->ic_data()->NumberOfUsedChecks() == 0)) {
     return;
   }
   const Token::Kind op_kind = instr->token_kind();
 
   // Type test is special as it always gets converted into inlined code.
   if (Token::IsTypeTestOperator(op_kind)) {
     ReplaceWithInstanceOf(instr);
     return;
   }
@@ skipping 107 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) {
-    if (FLAG_precompilation) {
-      // TODO(srdjan): Adapt MathUnaryInstr to allow tagged inputs as well.
-      return;
-    }
     MathUnaryInstr* math_unary =
         new(Z) MathUnaryInstr(unary_kind,
                               new(Z) Value(call->ArgumentAt(0)),
                               call->deopt_id());
     ReplaceCall(call, math_unary);
     return;
   }
   switch (recognized_kind) {
     case MethodRecognizer::kFloat32x4Zero:
     case MethodRecognizer::kFloat32x4Splat:
@@ skipping 62 matching lines @@
         }
       }
       break;
     }
     case MethodRecognizer::kMathDoublePow:
     case MethodRecognizer::kMathTan:
     case MethodRecognizer::kMathAsin:
     case MethodRecognizer::kMathAcos:
     case MethodRecognizer::kMathAtan:
     case MethodRecognizer::kMathAtan2: {
-      if (FLAG_precompilation) {
-        // No UnboxDouble instructons allowed.
-        return;
-      }
       // 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,
                                           call->deopt_id(),
@@ skipping 235 matching lines @@
 
   // Discard the environment from the original instruction because the store
   // can't deoptimize.
   instr->RemoveEnvironment();
   ReplaceCall(instr, store);
   return true;
 }
 
 
 }  // namespace dart