Revert "Move precompilation-related flags to flags list."

runtime/vm/aot_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/aot_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 11 matching lines @@
 #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 {
 
+DECLARE_FLAG(bool, precompilation);
+
 // Quick access to the current isolate and zone.
 #define I (isolate())
 #define Z (zone())
 
 static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
 
 static bool CanUnboxDouble() {
@@ skipping 1983 matching lines @@
     }
   }
   return false;
 }
 
 
 bool AotOptimizer::TryInlineFloat32x4Constructor(
     StaticCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   // Cannot handle unboxed instructions.
-  ASSERT(FLAG_precompiled_mode);
+  ASSERT(FLAG_precompilation);
   return false;
 }
 
 
 bool AotOptimizer::TryInlineFloat64x2Constructor(
     StaticCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   // Cannot handle unboxed instructions.
-  ASSERT(FLAG_precompiled_mode);
+  ASSERT(FLAG_precompilation);
   return false;
 }
 
 
 bool AotOptimizer::TryInlineInt32x4Constructor(
     StaticCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   // Cannot handle unboxed instructions.
-  ASSERT(FLAG_precompiled_mode);
+  ASSERT(FLAG_precompilation);
   return false;
 }
 
 
 bool AotOptimizer::TryInlineFloat32x4Method(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   // Cannot handle unboxed instructions.
   return false;
 }
@@ skipping 476 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 AotOptimizer::VisitInstanceCall(InstanceCallInstr* instr) {
-  ASSERT(FLAG_precompiled_mode);
+  ASSERT(FLAG_precompilation);
   InstanceCallNoopt(instr);
 }
 
 
 void AotOptimizer::VisitStaticCall(StaticCallInstr* call) {
   if (!CanUnboxDouble()) {
     return;
   }
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(call->function());
   MathUnaryInstr::MathUnaryKind unary_kind;
   switch (recognized_kind) {
     case MethodRecognizer::kMathSqrt:
       unary_kind = MathUnaryInstr::kSqrt;
       break;
     case MethodRecognizer::kMathSin:
       unary_kind = MathUnaryInstr::kSin;
       break;
     case MethodRecognizer::kMathCos:
       unary_kind = MathUnaryInstr::kCos;
       break;
     default:
       unary_kind = MathUnaryInstr::kIllegal;
       break;
   }
   if (unary_kind != MathUnaryInstr::kIllegal) {
-    ASSERT(FLAG_precompiled_mode);
+    ASSERT(FLAG_precompilation);
     // TODO(srdjan): Adapt MathUnaryInstr to allow tagged inputs as well.
     return;
   }
 
   switch (recognized_kind) {
     case MethodRecognizer::kFloat32x4Zero:
     case MethodRecognizer::kFloat32x4Splat:
     case MethodRecognizer::kFloat32x4Constructor:
     case MethodRecognizer::kFloat32x4FromFloat64x2:
       TryInlineFloat32x4Constructor(call, recognized_kind);
@@ skipping 59 matching lines @@
         }
       }
       break;
     }
     case MethodRecognizer::kMathDoublePow:
     case MethodRecognizer::kMathTan:
     case MethodRecognizer::kMathAsin:
     case MethodRecognizer::kMathAcos:
     case MethodRecognizer::kMathAtan:
     case MethodRecognizer::kMathAtan2: {
-      ASSERT(FLAG_precompiled_mode);
+      ASSERT(FLAG_precompilation);
       // No UnboxDouble instructions allowed.
       return;
     }
     case MethodRecognizer::kDoubleFromInteger: {
       if (call->HasICData() && (call->ic_data()->NumberOfChecks() == 1)) {
         const ICData& ic_data = *call->ic_data();
         if (CanUnboxDouble()) {
           if (ArgIsAlways(kSmiCid, ic_data, 1)) {
             Definition* arg = call->ArgumentAt(1);
             AddCheckSmi(arg, call->deopt_id(), call->env(), call);
@@ skipping 139 matching lines @@
 
   // Discard the environment from the original instruction because the store
   // can't deoptimize.
   instr->RemoveEnvironment();
   ReplaceCall(instr, store);
   return true;
 }
 
 
 }  // namespace dart