Clean up global variables related to precompilation.

runtime/vm/flow_graph_inliner.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_inliner.h"
 
 #include "vm/block_scheduler.h"
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
@@ skipping 43 matching lines @@
     "Inline recursive function calls up to threshold recursion depth.");
 DEFINE_FLAG(int, max_inlined_per_depth, 500,
     "Max. number of inlined calls per depth");
 DEFINE_FLAG(bool, print_inlining_tree, false, "Print inlining tree");
 DEFINE_FLAG(bool, enable_inlining_annotations, false,
             "Enable inlining annotations");
 
 DECLARE_FLAG(bool, compiler_stats);
 DECLARE_FLAG(int, max_deoptimization_counter_threshold);
 DECLARE_FLAG(bool, polymorphic_with_deopt);
+DECLARE_FLAG(bool, precompilation);
 DECLARE_FLAG(bool, print_flow_graph);
 DECLARE_FLAG(bool, print_flow_graph_optimized);
 DECLARE_FLAG(bool, verify_compiler);
 
 // Quick access to the current zone.
 #define Z (zone())
 
 #define TRACE_INLINING(statement)                                              \
   do {                                                                         \
     if (trace_inlining()) statement;                                           \
@@ skipping 548 matching lines @@
     // Abort if the inlinable bit on the function is low.
     if (!function.CanBeInlined()) {
       TRACE_INLINING(THR_Print("     Bailout: not inlinable\n"));
       PRINT_INLINING_TREE("Not inlinable",
           &call_data->caller, &function, call_data->call);
       return false;
     }
 
     // Function has no type feedback. With precompilation we don't rely on
     // type feedback.
-    if (!Compiler::always_optimize() &&
+    if (!FLAG_precompilation &&
         function.ic_data_array() == Object::null()) {
       TRACE_INLINING(THR_Print("     Bailout: not compiled yet\n"));
       PRINT_INLINING_TREE("Not compiled",
           &call_data->caller, &function, call_data->call);
       return false;
     }
 
     // Abort if this function has deoptimized too much.
     if (function.deoptimization_counter() >=
         FLAG_max_deoptimization_counter_threshold) {
@@ skipping 136 matching lines @@
           DEBUG_ASSERT(callee_graph->VerifyUseLists());
         }
 
         {
           CSTAT_TIMER_SCOPE(thread(), graphinliner_opt_timer);
           // TODO(fschneider): Improve suppression of speculative inlining.
           // Deopt-ids overlap between caller and callee.
           FlowGraphOptimizer optimizer(callee_graph,
                                        inliner_->use_speculative_inlining_,
                                        inliner_->inlining_black_list_);
-          if (Compiler::always_optimize()) {
+          if (FLAG_precompilation) {
             optimizer.PopulateWithICData();
 
             optimizer.ApplyClassIds();
             DEBUG_ASSERT(callee_graph->VerifyUseLists());
 
             FlowGraphTypePropagator::Propagate(callee_graph);
             DEBUG_ASSERT(callee_graph->VerifyUseLists());
           }
           optimizer.ApplyICData();
           DEBUG_ASSERT(callee_graph->VerifyUseLists());
@@ skipping 106 matching lines @@
           return false;
         } else {
           // Fall through to exit long jump scope.
         }
       }
     }
 
     // Propagate a compile-time error. Only in precompilation do we attempt to
     // inline functions that have never been compiled before; when JITing we
     // should only see compile-time errors in unoptimized compilation.
-    ASSERT(Compiler::always_optimize());
+    ASSERT(FLAG_precompilation);
     Thread::Current()->long_jump_base()->Jump(1, error);
     UNREACHABLE();
     return false;
   }
 
   void PrintInlinedInfo(const Function& top) {
     if (inlined_info_.length() > 0) {
       THR_Print("Inlining into: '%s' growth: %f (%" Pd " -> %" Pd ")\n",
           top.ToFullyQualifiedCString(),
           GrowthFactor(),
@@ skipping 1007 matching lines @@
 intptr_t FlowGraphInliner::NextInlineId(const Function& function,
                                         intptr_t parent_id) {
   const intptr_t id = inline_id_to_function_->length();
   inline_id_to_function_->Add(&function);
   caller_inline_id_->Add(parent_id);
   return id;
 }
 
 
 }  // namespace dart