Clean up global variables related to precompilation.

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 236 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;
   }
 
-  if (Compiler::always_optimize() &&
+  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,
@@ skipping 2898 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::TryInlineFloat32x4Constructor(
     StaticCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
-  if (Compiler::always_optimize()) {
+  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;
@@ skipping 26 matching lines @@
     ReplaceCall(call, cast);
     return true;
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::TryInlineFloat64x2Constructor(
     StaticCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
-  if (Compiler::always_optimize()) {
+  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;
@@ skipping 18 matching lines @@
     ReplaceCall(call, cast);
     return true;
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::TryInlineInt32x4Constructor(
     StaticCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
-  if (Compiler::always_optimize()) {
+  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)),
@@ skipping 1083 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 (Compiler::always_optimize()) {
+  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.
@@ skipping 111 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 (Compiler::always_optimize()) {
+    if (FLAG_precompilation) {
       // 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) ||
@@ skipping 48 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()) {
+    if (FLAG_precompilation) {
       // 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)));
@@ skipping 641 matching lines @@
   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() ||
-      Compiler::always_optimize()) {
+      FLAG_precompilation) {
     // Do not hoist any: Either deoptimized on a hoisted check,
     // or compiling precompiled code where we can't do optimistic
     // hoisting of checks.
     return;
   }
 
   const ZoneGrowableArray<BlockEntryInstr*>& loop_headers =
       flow_graph()->LoopHeaders();
 
   for (intptr_t i = 0; i < loop_headers.length(); ++i) {
@@ skipping 3606 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