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

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/flow_graph_optimizer.h"
+#include "vm/aot_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.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() {
+void AotOptimizer::ApplyICData() {
   VisitBlocks();
 }
 
 
-void FlowGraphOptimizer::PopulateWithICData() {
+void AotOptimizer::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()) {
@@ skipping 13 matching lines @@
   }
 }
 
 
 // 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() {
+void AotOptimizer::ApplyClassIds() {
   ASSERT(current_iterator_ == NULL);
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
        !block_it.Done();
        block_it.Advance()) {
     ForwardInstructionIterator it(block_it.Current());
     current_iterator_ = ⁢
     for (; !it.Done(); it.Advance()) {
       Instruction* instr = it.Current();
       if (instr->IsInstanceCall()) {
         InstanceCallInstr* call = instr->AsInstanceCall();
@@ skipping 10 matching lines @@
   }
 }
 
 
 // TODO(srdjan): Test/support other number types as well.
 static bool IsNumberCid(intptr_t cid) {
   return (cid == kSmiCid) || (cid == kDoubleCid);
 }
 
 
-bool FlowGraphOptimizer::TryCreateICData(InstanceCallInstr* call) {
+static void GetUniqueDynamicTarget(Isolate* isolate,
+                                   const String& fname,
+                                   Object* function) {
+  UniqueFunctionsSet functions_set(
+      isolate->object_store()->unique_dynamic_targets());
+  ASSERT(fname.IsSymbol());
+  *function = functions_set.GetOrNull(fname);
+  ASSERT(functions_set.Release().raw() ==
+      isolate->object_store()->unique_dynamic_targets());
+}
+
+
+bool AotOptimizer::TryCreateICData(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   if (call->ic_data()->NumberOfUsedChecks() > 0) {
     // This occurs when an instance call has too many checks, will be converted
     // to megamorphic call.
     return false;
   }
   GrowableArray<intptr_t> class_ids(call->ic_data()->NumArgsTested());
   ASSERT(call->ic_data()->NumArgsTested() <= call->ArgumentCount());
   for (intptr_t i = 0; i < call->ic_data()->NumArgsTested(); i++) {
     class_ids.Add(call->PushArgumentAt(i)->value()->Type()->ToCid());
@@ skipping 35 matching lines @@
       return false;
     }
     const Array& args_desc_array = Array::Handle(Z,
         ArgumentsDescriptor::New(call->ArgumentCount(),
                                  call->argument_names()));
     ArgumentsDescriptor args_desc(args_desc_array);
     const Function& function = Function::Handle(Z,
         Resolver::ResolveDynamicForReceiverClass(
             receiver_class,
             call->function_name(),
-            args_desc,
-            false /* allow add */));
+            args_desc));
     if (function.IsNull()) {
       return false;
     }
 
     // Create new ICData, do not modify the one attached to the instruction
     // since it is attached to the assembly instruction itself.
     // TODO(srdjan): Prevent modification of ICData object that is
     // referenced in assembly code.
     const ICData& ic_data = ICData::ZoneHandle(Z,
         ICData::NewFrom(*call->ic_data(), class_ids.length()));
     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())) {
+  if (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);
+    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(),
                                    call->argument_names()));
       ArgumentsDescriptor args_desc(args_desc_array);
       const Function& function = Function::Handle(Z,
           Resolver::ResolveDynamicForReceiverClass(owner_class,
                                                    call->function_name(),
-                                                   args_desc,
-                                                   false /* allow_add */));
+                                                   args_desc));
       if (!function.IsNull()) {
         const ICData& ic_data = ICData::ZoneHandle(Z,
             ICData::NewFrom(*call->ic_data(), class_ids.length()));
         ic_data.AddReceiverCheck(owner_class.id(), function);
         call->set_ic_data(&ic_data);
         return true;
       }
     }
   }
 
   return false;
 }
 
 
-const ICData& FlowGraphOptimizer::TrySpecializeICData(const ICData& ic_data,
+const ICData& AotOptimizer::TrySpecializeICData(const ICData& ic_data,
                                                       intptr_t cid) {
   ASSERT(ic_data.NumArgsTested() == 1);
 
   if ((ic_data.NumberOfUsedChecks() == 1) && ic_data.HasReceiverClassId(cid)) {
     return ic_data;  // Nothing to do
   }
 
   const Function& function =
       Function::Handle(Z, ic_data.GetTargetForReceiverClassId(cid));
   // TODO(fschneider): Try looking up the function on the class if it is
   // not found in the ICData.
   if (!function.IsNull()) {
     const ICData& new_ic_data = ICData::ZoneHandle(Z, ICData::New(
         Function::Handle(Z, ic_data.Owner()),
         String::Handle(Z, ic_data.target_name()),
         Object::empty_array(),  // Dummy argument descriptor.
         ic_data.deopt_id(),
         ic_data.NumArgsTested()));
     new_ic_data.SetDeoptReasons(ic_data.DeoptReasons());
     new_ic_data.AddReceiverCheck(cid, function);
     return new_ic_data;
   }
 
   return ic_data;
 }
 
 
-void FlowGraphOptimizer::SpecializePolymorphicInstanceCall(
+void AotOptimizer::SpecializePolymorphicInstanceCall(
     PolymorphicInstanceCallInstr* call) {
   if (!FLAG_polymorphic_with_deopt) {
     // Specialization adds receiver checks which can lead to deoptimization.
     return;
   }
   if (!call->with_checks()) {
     return;  // Already specialized.
   }
 
   const intptr_t receiver_cid =
@@ skipping 28 matching lines @@
 
 static bool IsPositiveOrZeroSmiConst(Definition* d) {
   ConstantInstr* const_instr = d->AsConstant();
   if ((const_instr != NULL) && (const_instr->value().IsSmi())) {
     return Smi::Cast(const_instr->value()).Value() >= 0;
   }
   return false;
 }
 
 
-void FlowGraphOptimizer::OptimizeLeftShiftBitAndSmiOp(
+void AotOptimizer::OptimizeLeftShiftBitAndSmiOp(
     Definition* bit_and_instr,
     Definition* left_instr,
     Definition* right_instr) {
   ASSERT(bit_and_instr != NULL);
   ASSERT((left_instr != NULL) && (right_instr != NULL));
 
   // Check for pattern, smi_shift_left must be single-use.
   bool is_positive_or_zero = IsPositiveOrZeroSmiConst(left_instr);
   if (!is_positive_or_zero) {
     is_positive_or_zero = IsPositiveOrZeroSmiConst(right_instr);
@@ skipping 17 matching lines @@
     BinarySmiOpInstr* smi_op = new(Z) BinarySmiOpInstr(
         Token::kBIT_AND,
         new(Z) Value(left_instr),
         new(Z) Value(right_instr),
         Thread::kNoDeoptId);  // BIT_AND cannot deoptimize.
     bit_and_instr->ReplaceWith(smi_op, current_iterator());
   }
 }
 
 
-void FlowGraphOptimizer::AppendExtractNthOutputForMerged(Definition* instr,
+void AotOptimizer::AppendExtractNthOutputForMerged(Definition* instr,
                                                          intptr_t index,
                                                          Representation rep,
                                                          intptr_t cid) {
   ExtractNthOutputInstr* extract =
       new(Z) ExtractNthOutputInstr(new(Z) Value(instr), index, rep, cid);
   instr->ReplaceUsesWith(extract);
   flow_graph()->InsertAfter(instr, extract, NULL, FlowGraph::kValue);
 }
 
 
 // Dart:
 //  var x = d % 10;
 //  var y = d ~/ 10;
 //  var z = x + y;
 //
 // IL:
 //  v4 <- %(v2, v3)
 //  v5 <- ~/(v2, v3)
 //  v6 <- +(v4, v5)
 //
 // IL optimized:
 //  v4 <- DIVMOD(v2, v3);
 //  v5 <- LoadIndexed(v4, 0); // ~/ result
 //  v6 <- LoadIndexed(v4, 1); // % result
 //  v7 <- +(v5, v6)
 // Because of the environment it is important that merged instruction replaces
 // first original instruction encountered.
-void FlowGraphOptimizer::TryMergeTruncDivMod(
+void AotOptimizer::TryMergeTruncDivMod(
     GrowableArray<BinarySmiOpInstr*>* merge_candidates) {
   if (merge_candidates->length() < 2) {
     // Need at least a TRUNCDIV and a MOD.
     return;
   }
   for (intptr_t i = 0; i < merge_candidates->length(); i++) {
     BinarySmiOpInstr* curr_instr = (*merge_candidates)[i];
     if (curr_instr == NULL) {
       // Instruction was merged already.
       continue;
@@ skipping 40 matching lines @@
         // more candidates are possible.
         // TODO(srdjan): Allow merging of trunc-div/mod into truncDivMod.
         break;
       }
     }
   }
 }
 
 
 // Tries to merge MathUnary operations, in this case sinus and cosinus.
-void FlowGraphOptimizer::TryMergeMathUnary(
+void AotOptimizer::TryMergeMathUnary(
     GrowableArray<MathUnaryInstr*>* merge_candidates) {
   if (!FlowGraphCompiler::SupportsSinCos() || !CanUnboxDouble() ||
       !FLAG_merge_sin_cos) {
     return;
   }
   if (merge_candidates->length() < 2) {
     // Need at least a SIN and a COS.
     return;
   }
   for (intptr_t i = 0; i < merge_candidates->length(); i++) {
@@ skipping 40 matching lines @@
         break;
       }
     }
   }
 }
 
 
 // Optimize (a << b) & c pattern: if c is a positive Smi or zero, then the
 // shift can be a truncating Smi shift-left and result is always Smi.
 // Merging occurs only per basic-block.
-void FlowGraphOptimizer::TryOptimizePatterns() {
+void AotOptimizer::TryOptimizePatterns() {
   if (!FLAG_truncating_left_shift) return;
   ASSERT(current_iterator_ == NULL);
   GrowableArray<BinarySmiOpInstr*> div_mod_merge;
   GrowableArray<MathUnaryInstr*> sin_cos_merge;
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
        !block_it.Done();
        block_it.Advance()) {
     // Merging only per basic-block.
     div_mod_merge.Clear();
     sin_cos_merge.Clear();
@@ skipping 165 matching lines @@
   // Unboxed double operation can't handle case of two smis.
   if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
     return false;
   }
 
   // Check that it have seen only smis and doubles.
   return HasTwoDoubleOrSmi(ic_data);
 }
 
 
-void FlowGraphOptimizer::ReplaceCall(Definition* call,
+void AotOptimizer::ReplaceCall(Definition* call,
                                      Definition* replacement) {
   // Remove the original push arguments.
   for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
     PushArgumentInstr* push = call->PushArgumentAt(i);
     push->ReplaceUsesWith(push->value()->definition());
     push->RemoveFromGraph();
   }
   call->ReplaceWith(replacement, current_iterator());
 }
 
 
-void FlowGraphOptimizer::AddCheckSmi(Definition* to_check,
+void AotOptimizer::AddCheckSmi(Definition* to_check,
                                      intptr_t deopt_id,
                                      Environment* deopt_environment,
                                      Instruction* insert_before) {
   if (to_check->Type()->ToCid() != kSmiCid) {
     InsertBefore(insert_before,
                  new(Z) CheckSmiInstr(new(Z) Value(to_check),
                                       deopt_id,
                                       insert_before->token_pos()),
                  deopt_environment,
                  FlowGraph::kEffect);
   }
 }
 
 
-Instruction* FlowGraphOptimizer::GetCheckClass(Definition* to_check,
+Instruction* AotOptimizer::GetCheckClass(Definition* to_check,
                                                const ICData& unary_checks,
                                                intptr_t deopt_id,
                                                TokenPosition token_pos) {
   if ((unary_checks.NumberOfUsedChecks() == 1) &&
       unary_checks.HasReceiverClassId(kSmiCid)) {
     return new(Z) CheckSmiInstr(new(Z) Value(to_check),
                                 deopt_id,
                                 token_pos);
   }
   return new(Z) CheckClassInstr(
       new(Z) Value(to_check), deopt_id, unary_checks, token_pos);
 }
 
 
-void FlowGraphOptimizer::AddCheckClass(Definition* to_check,
+void AotOptimizer::AddCheckClass(Definition* to_check,
                                        const ICData& unary_checks,
                                        intptr_t deopt_id,
                                        Environment* deopt_environment,
                                        Instruction* insert_before) {
   // Type propagation has not run yet, we cannot eliminate the check.
   Instruction* check = GetCheckClass(
       to_check, unary_checks, deopt_id, insert_before->token_pos());
   InsertBefore(insert_before, check, deopt_environment, FlowGraph::kEffect);
 }
 
 
-void FlowGraphOptimizer::AddReceiverCheck(InstanceCallInstr* call) {
+void AotOptimizer::AddReceiverCheck(InstanceCallInstr* call) {
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecks()),
                 call->deopt_id(),
                 call->env(),
                 call);
 }
 
 
 static bool ArgIsAlways(intptr_t cid,
                         const ICData& ic_data,
                         intptr_t arg_number) {
   ASSERT(ic_data.NumArgsTested() > arg_number);
   if (ic_data.NumberOfUsedChecks() == 0) {
     return false;
   }
   const intptr_t num_checks = ic_data.NumberOfChecks();
   for (intptr_t i = 0; i < num_checks; i++) {
     if (ic_data.IsUsedAt(i) && ic_data.GetClassIdAt(i, arg_number) != cid) {
       return false;
     }
   }
   return true;
 }
 
 
-bool FlowGraphOptimizer::TryReplaceWithIndexedOp(InstanceCallInstr* call) {
+bool AotOptimizer::TryReplaceWithIndexedOp(InstanceCallInstr* call) {
   // Check for monomorphic IC data.
   if (!call->HasICData()) return false;
   const ICData& ic_data =
       ICData::Handle(Z, call->ic_data()->AsUnaryClassChecks());
   if (ic_data.NumberOfChecks() != 1) {
     return false;
   }
   return TryReplaceInstanceCallWithInline(call);
 }
 
@@ skipping 11 matching lines @@
   } else {
     return d->IsStringFromCharCode();
   }
 }
 
 
 // Returns true if the string comparison was converted into char-code
 // comparison. Conversion is only possible for strings of length one.
 // E.g., detect str[x] == "x"; and use an integer comparison of char-codes.
 // TODO(srdjan): Expand for two-byte and external strings.
-bool FlowGraphOptimizer::TryStringLengthOneEquality(InstanceCallInstr* call,
+bool AotOptimizer::TryStringLengthOneEquality(InstanceCallInstr* call,
                                                     Token::Kind op_kind) {
   ASSERT(HasOnlyTwoOf(*call->ic_data(), kOneByteStringCid));
   // Check that left and right are length one strings (either string constants
   // or results of string-from-char-code.
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   Value* left_val = NULL;
   Definition* to_remove_left = NULL;
   if (IsLengthOneString(right)) {
     // Swap, since we know that both arguments are strings
@@ skipping 66 matching lines @@
       to_remove_right->RemoveFromGraph();
     }
     return true;
   }
   return false;
 }
 
 
 static bool SmiFitsInDouble() { return kSmiBits < 53; }
 
-bool FlowGraphOptimizer::TryReplaceWithEqualityOp(InstanceCallInstr* call,
+bool AotOptimizer::TryReplaceWithEqualityOp(InstanceCallInstr* call,
                                                   Token::Kind op_kind) {
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   intptr_t cid = kIllegalCid;
   if (HasOnlyTwoOf(ic_data, kOneByteStringCid)) {
@@ skipping 88 matching lines @@
                                                            op_kind,
                                                            new(Z) Value(left),
                                                            new(Z) Value(right),
                                                            cid,
                                                            call->deopt_id());
   ReplaceCall(call, comp);
   return true;
 }
 
 
-bool FlowGraphOptimizer::TryReplaceWithRelationalOp(InstanceCallInstr* call,
+bool AotOptimizer::TryReplaceWithRelationalOp(InstanceCallInstr* call,
                                                     Token::Kind op_kind) {
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   intptr_t cid = kIllegalCid;
   if (HasOnlyTwoOf(ic_data, kSmiCid)) {
@@ skipping 41 matching lines @@
                                                      op_kind,
                                                      new(Z) Value(left),
                                                      new(Z) Value(right),
                                                      cid,
                                                      call->deopt_id());
   ReplaceCall(call, comp);
   return true;
 }
 
 
-bool FlowGraphOptimizer::TryReplaceWithBinaryOp(InstanceCallInstr* call,
+bool AotOptimizer::TryReplaceWithBinaryOp(InstanceCallInstr* call,
                                                 Token::Kind op_kind) {
   intptr_t operands_type = kIllegalCid;
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   switch (op_kind) {
     case Token::kADD:
     case Token::kSUB:
     case Token::kMUL:
       if (HasOnlyTwoOf(ic_data, kSmiCid)) {
         // Don't generate smi code if the IC data is marked because
@@ skipping 188 matching lines @@
             op_kind,
             new(Z) Value(left),
             new(Z) Value(right),
             call->deopt_id());
     ReplaceCall(call, bin_op);
   }
   return true;
 }
 
 
-bool FlowGraphOptimizer::TryReplaceWithUnaryOp(InstanceCallInstr* call,
+bool AotOptimizer::TryReplaceWithUnaryOp(InstanceCallInstr* call,
                                                Token::Kind op_kind) {
   ASSERT(call->ArgumentCount() == 1);
   Definition* input = call->ArgumentAt(0);
   Definition* unary_op = NULL;
   if (HasOnlyOneSmi(*call->ic_data())) {
     InsertBefore(call,
                  new(Z) CheckSmiInstr(new(Z) Value(input),
                                       call->deopt_id(),
                                       call->token_pos()),
                  call->env(),
@@ skipping 14 matching lines @@
   } else {
     return false;
   }
   ASSERT(unary_op != NULL);
   ReplaceCall(call, unary_op);
   return true;
 }
 
 
 // Using field class
-RawField* FlowGraphOptimizer::GetField(intptr_t class_id,
+RawField* AotOptimizer::GetField(intptr_t class_id,
                                        const String& field_name) {
   Class& cls = Class::Handle(Z, isolate()->class_table()->At(class_id));
   Field& field = Field::Handle(Z);
   while (!cls.IsNull()) {
     field = cls.LookupInstanceField(field_name);
     if (!field.IsNull()) {
       return field.raw();
     }
     cls = cls.SuperClass();
   }
   return Field::null();
 }
 
 
 // Use CHA to determine if the call needs a class check: if the callee's
 // receiver is the same as the caller's receiver and there are no overriden
 // callee functions, then no class check is needed.
-bool FlowGraphOptimizer::InstanceCallNeedsClassCheck(
+bool AotOptimizer::InstanceCallNeedsClassCheck(
     InstanceCallInstr* call, RawFunction::Kind kind) const {
   if (!FLAG_use_cha_deopt && !isolate()->all_classes_finalized()) {
     // Even if class or function are private, lazy class finalization
     // may later add overriding methods.
     return true;
   }
   Definition* callee_receiver = call->ArgumentAt(0);
   ASSERT(callee_receiver != NULL);
   const Function& function = flow_graph_->function();
   if (function.IsDynamicFunction() &&
@@ skipping 10 matching lines @@
             name.ToCString(), cls.ToCString());
       }
       thread()->cha()->AddToLeafClasses(cls);
       return false;
     }
   }
   return true;
 }
 
 
-bool FlowGraphOptimizer::InlineImplicitInstanceGetter(InstanceCallInstr* call,
+bool AotOptimizer::InlineImplicitInstanceGetter(InstanceCallInstr* call,
                                                       bool allow_check) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.HasOneTarget());
   GrowableArray<intptr_t> class_ids;
   ic_data.GetClassIdsAt(0, &class_ids);
   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());
-    }
-    flow_graph()->parsed_function().AddToGuardedFields(&field);
-  }
+
+  // No guarded cid in precompiled mode.
+  ASSERT(field.guarded_cid() == kDynamicCid);
 
   // 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,
+bool AotOptimizer::InlineFloat32x4Getter(InstanceCallInstr* call,
                                                MethodRecognizer::Kind getter) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
                     Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
@@ skipping 54 matching lines @@
         mask,
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   }
   UNREACHABLE();
   return false;
 }
 
 
-bool FlowGraphOptimizer::InlineFloat64x2Getter(InstanceCallInstr* call,
+bool AotOptimizer::InlineFloat64x2Getter(InstanceCallInstr* call,
                                                MethodRecognizer::Kind getter) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
                     Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
   if ((getter == MethodRecognizer::kFloat64x2GetX) ||
       (getter == MethodRecognizer::kFloat64x2GetY)) {
     Simd64x2ShuffleInstr* instr = new(Z) Simd64x2ShuffleInstr(
         getter,
         new(Z) Value(call->ArgumentAt(0)),
         0,
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   }
   UNREACHABLE();
   return false;
 }
 
 
-bool FlowGraphOptimizer::InlineInt32x4Getter(InstanceCallInstr* call,
+bool AotOptimizer::InlineInt32x4Getter(InstanceCallInstr* call,
                                               MethodRecognizer::Kind getter) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
                     Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
@@ skipping 54 matching lines @@
     Int32x4GetFlagInstr* instr = new(Z) Int32x4GetFlagInstr(
         getter,
         new(Z) Value(call->ArgumentAt(0)),
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   }
 }
 
 
-bool FlowGraphOptimizer::InlineFloat32x4BinaryOp(InstanceCallInstr* call,
+bool AotOptimizer::InlineFloat32x4BinaryOp(InstanceCallInstr* call,
                                                  Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   // Type check left.
   AddCheckClass(left,
                 ICData::ZoneHandle(
@@ skipping 12 matching lines @@
   BinaryFloat32x4OpInstr* float32x4_bin_op =
       new(Z) BinaryFloat32x4OpInstr(
           op_kind, new(Z) Value(left), new(Z) Value(right),
           call->deopt_id());
   ReplaceCall(call, float32x4_bin_op);
 
   return true;
 }
 
 
-bool FlowGraphOptimizer::InlineInt32x4BinaryOp(InstanceCallInstr* call,
+bool AotOptimizer::InlineInt32x4BinaryOp(InstanceCallInstr* call,
                                                 Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   // Type check left.
   AddCheckClass(left,
                 ICData::ZoneHandle(
@@ skipping 11 matching lines @@
   // Replace call.
   BinaryInt32x4OpInstr* int32x4_bin_op =
       new(Z) BinaryInt32x4OpInstr(
           op_kind, new(Z) Value(left), new(Z) Value(right),
           call->deopt_id());
   ReplaceCall(call, int32x4_bin_op);
   return true;
 }
 
 
-bool FlowGraphOptimizer::InlineFloat64x2BinaryOp(InstanceCallInstr* call,
+bool AotOptimizer::InlineFloat64x2BinaryOp(InstanceCallInstr* call,
                                                  Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   // Type check left.
   AddCheckClass(left,
                 ICData::ZoneHandle(
@@ skipping 13 matching lines @@
       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.
 // Returns false if 'allow_check' is false and a check is needed.
-bool FlowGraphOptimizer::TryInlineInstanceGetter(InstanceCallInstr* call,
+bool AotOptimizer::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;
   }
   return InlineImplicitInstanceGetter(call, allow_check);
 }
 
 
-bool FlowGraphOptimizer::TryReplaceInstanceCallWithInline(
+bool AotOptimizer::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];
 
   TargetEntryInstr* entry;
   Definition* last;
   if (!FlowGraphInliner::TryInlineRecognizedMethod(flow_graph_,
                                                    receiver_cid,
@@ skipping 23 matching lines @@
   last->LinkTo(call);
   // Remove through the iterator.
   ASSERT(current_iterator()->Current() == call);
   current_iterator()->RemoveCurrentFromGraph();
   call->set_previous(NULL);
   call->set_next(NULL);
   return true;
 }
 
 
-void FlowGraphOptimizer::ReplaceWithMathCFunction(
+void AotOptimizer::ReplaceWithMathCFunction(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   AddReceiverCheck(call);
   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 20 matching lines @@
     case kTypedDataFloat32x4ArrayCid:
     case kTypedDataInt32x4ArrayCid:
       return true;
     default:
       return false;
   }
 }
 
 
 // Inline only simple, frequently called core library methods.
-bool FlowGraphOptimizer::TryInlineInstanceMethod(InstanceCallInstr* call) {
+bool AotOptimizer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if ((ic_data.NumberOfUsedChecks() == 0) || !ic_data.HasOneTarget()) {
     // No type feedback collected or multiple targets found.
     return false;
   }
 
   Function& target = Function::Handle(Z);
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
@@ skipping 212 matching lines @@
                                    new(Z) Value(int32_mask),
                                    call->deopt_id());
       ReplaceCall(call, bit_and);
       return true;
     }
   }
   return false;
 }
 
 
-bool FlowGraphOptimizer::TryInlineFloat32x4Constructor(
+bool AotOptimizer::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(
-            new(Z) Value(call->ArgumentAt(1)), call->deopt_id());
-    ReplaceCall(call, splat);
-    return true;
-  } else if (recognized_kind == MethodRecognizer::kFloat32x4Constructor) {
-    Float32x4ConstructorInstr* con =
-        new(Z) Float32x4ConstructorInstr(
-            new(Z) Value(call->ArgumentAt(1)),
-            new(Z) Value(call->ArgumentAt(2)),
-            new(Z) Value(call->ArgumentAt(3)),
-            new(Z) Value(call->ArgumentAt(4)),
-            call->deopt_id());
-    ReplaceCall(call, con);
-    return true;
-  } else if (recognized_kind == MethodRecognizer::kFloat32x4FromInt32x4Bits) {
-    Int32x4ToFloat32x4Instr* cast =
-        new(Z) Int32x4ToFloat32x4Instr(
-            new(Z) Value(call->ArgumentAt(1)), call->deopt_id());
-    ReplaceCall(call, cast);
-    return true;
-  } else if (recognized_kind == MethodRecognizer::kFloat32x4FromFloat64x2) {
-    Float64x2ToFloat32x4Instr* cast =
-        new(Z) Float64x2ToFloat32x4Instr(
-            new(Z) Value(call->ArgumentAt(1)), call->deopt_id());
-    ReplaceCall(call, cast);
-    return true;
-  }
+  // Cannot handle unboxed instructions.
+  ASSERT(FLAG_precompilation);
   return false;
 }
 
 
-bool FlowGraphOptimizer::TryInlineFloat64x2Constructor(
+bool AotOptimizer::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(
-            new(Z) Value(call->ArgumentAt(1)), call->deopt_id());
-    ReplaceCall(call, splat);
-    return true;
-  } else if (recognized_kind == MethodRecognizer::kFloat64x2Constructor) {
-    Float64x2ConstructorInstr* con =
-        new(Z) Float64x2ConstructorInstr(
-            new(Z) Value(call->ArgumentAt(1)),
-            new(Z) Value(call->ArgumentAt(2)),
-            call->deopt_id());
-    ReplaceCall(call, con);
-    return true;
-  } else if (recognized_kind == MethodRecognizer::kFloat64x2FromFloat32x4) {
-    Float32x4ToFloat64x2Instr* cast =
-        new(Z) Float32x4ToFloat64x2Instr(
-            new(Z) Value(call->ArgumentAt(1)), call->deopt_id());
-    ReplaceCall(call, cast);
-    return true;
-  }
+  // Cannot handle unboxed instructions.
+  ASSERT(FLAG_precompilation);
   return false;
 }
 
 
-bool FlowGraphOptimizer::TryInlineInt32x4Constructor(
+bool AotOptimizer::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)),
-            call->deopt_id());
-    ReplaceCall(call, con);
-    return true;
-  } else if (recognized_kind == MethodRecognizer::kInt32x4FromFloat32x4Bits) {
-    Float32x4ToInt32x4Instr* cast =
-        new(Z) Float32x4ToInt32x4Instr(
-            new(Z) Value(call->ArgumentAt(1)), call->deopt_id());
-    ReplaceCall(call, cast);
-    return true;
-  } else if (recognized_kind == MethodRecognizer::kInt32x4Constructor) {
-    Int32x4ConstructorInstr* con =
-        new(Z) Int32x4ConstructorInstr(
-            new(Z) Value(call->ArgumentAt(1)),
-            new(Z) Value(call->ArgumentAt(2)),
-            new(Z) Value(call->ArgumentAt(3)),
-            new(Z) Value(call->ArgumentAt(4)),
-            call->deopt_id());
-    ReplaceCall(call, con);
-    return true;
-  }
+  // Cannot handle unboxed instructions.
+  ASSERT(FLAG_precompilation);
   return false;
 }
 
 
-bool FlowGraphOptimizer::TryInlineFloat32x4Method(
+bool AotOptimizer::TryInlineFloat32x4Method(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
-  if (!ShouldInlineSimd()) {
-    return false;
-  }
-  ASSERT(call->HasICData());
-  switch (recognized_kind) {
-    case MethodRecognizer::kFloat32x4ShuffleX:
-    case MethodRecognizer::kFloat32x4ShuffleY:
-    case MethodRecognizer::kFloat32x4ShuffleZ:
-    case MethodRecognizer::kFloat32x4ShuffleW:
-    case MethodRecognizer::kFloat32x4GetSignMask:
-      ASSERT(call->ic_data()->HasReceiverClassId(kFloat32x4Cid));
-      ASSERT(call->ic_data()->HasOneTarget());
-      return InlineFloat32x4Getter(call, recognized_kind);
-
-    case MethodRecognizer::kFloat32x4Equal:
-    case MethodRecognizer::kFloat32x4GreaterThan:
-    case MethodRecognizer::kFloat32x4GreaterThanOrEqual:
-    case MethodRecognizer::kFloat32x4LessThan:
-    case MethodRecognizer::kFloat32x4LessThanOrEqual:
-    case MethodRecognizer::kFloat32x4NotEqual: {
-      Definition* left = call->ArgumentAt(0);
-      Definition* right = call->ArgumentAt(1);
-      // Type check left.
-      AddCheckClass(left,
-                    ICData::ZoneHandle(
-                        Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                    call->deopt_id(),
-                    call->env(),
-                    call);
-      // Replace call.
-      Float32x4ComparisonInstr* cmp =
-          new(Z) Float32x4ComparisonInstr(recognized_kind,
-                                          new(Z) Value(left),
-                                          new(Z) Value(right),
-                                          call->deopt_id());
-      ReplaceCall(call, cmp);
-      return true;
-    }
-    case MethodRecognizer::kFloat32x4Min:
-    case MethodRecognizer::kFloat32x4Max: {
-      Definition* left = call->ArgumentAt(0);
-      Definition* right = call->ArgumentAt(1);
-      // Type check left.
-      AddCheckClass(left,
-                    ICData::ZoneHandle(
-                        Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                    call->deopt_id(),
-                    call->env(),
-                    call);
-      Float32x4MinMaxInstr* minmax =
-          new(Z) Float32x4MinMaxInstr(
-              recognized_kind,
-              new(Z) Value(left),
-              new(Z) Value(right),
-              call->deopt_id());
-      ReplaceCall(call, minmax);
-      return true;
-    }
-    case MethodRecognizer::kFloat32x4Scale: {
-      Definition* left = call->ArgumentAt(0);
-      Definition* right = call->ArgumentAt(1);
-      // Type check left.
-      AddCheckClass(left,
-                    ICData::ZoneHandle(
-                        Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                    call->deopt_id(),
-                    call->env(),
-                    call);
-      // Left and right values are swapped when handed to the instruction,
-      // this is done so that the double value is loaded into the output
-      // register and can be destroyed.
-      Float32x4ScaleInstr* scale =
-          new(Z) Float32x4ScaleInstr(recognized_kind,
-                                     new(Z) Value(right),
-                                     new(Z) Value(left),
-                                     call->deopt_id());
-      ReplaceCall(call, scale);
-      return true;
-    }
-    case MethodRecognizer::kFloat32x4Sqrt:
-    case MethodRecognizer::kFloat32x4ReciprocalSqrt:
-    case MethodRecognizer::kFloat32x4Reciprocal: {
-      Definition* left = call->ArgumentAt(0);
-      AddCheckClass(left,
-                    ICData::ZoneHandle(
-                        Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                    call->deopt_id(),
-                    call->env(),
-                    call);
-      Float32x4SqrtInstr* sqrt =
-          new(Z) Float32x4SqrtInstr(recognized_kind,
-                                    new(Z) Value(left),
-                                    call->deopt_id());
-      ReplaceCall(call, sqrt);
-      return true;
-    }
-    case MethodRecognizer::kFloat32x4WithX:
-    case MethodRecognizer::kFloat32x4WithY:
-    case MethodRecognizer::kFloat32x4WithZ:
-    case MethodRecognizer::kFloat32x4WithW: {
-      Definition* left = call->ArgumentAt(0);
-      Definition* right = call->ArgumentAt(1);
-      // Type check left.
-      AddCheckClass(left,
-                    ICData::ZoneHandle(
-                        Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                    call->deopt_id(),
-                    call->env(),
-                    call);
-      Float32x4WithInstr* with = new(Z) Float32x4WithInstr(recognized_kind,
-                                                           new(Z) Value(left),
-                                                           new(Z) Value(right),
-                                                           call->deopt_id());
-      ReplaceCall(call, with);
-      return true;
-    }
-    case MethodRecognizer::kFloat32x4Absolute:
-    case MethodRecognizer::kFloat32x4Negate: {
-      Definition* left = call->ArgumentAt(0);
-      // Type check left.
-      AddCheckClass(left,
-                    ICData::ZoneHandle(
-                        Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                    call->deopt_id(),
-                    call->env(),
-                    call);
-      Float32x4ZeroArgInstr* zeroArg =
-          new(Z) Float32x4ZeroArgInstr(
-              recognized_kind, new(Z) Value(left), call->deopt_id());
-      ReplaceCall(call, zeroArg);
-      return true;
-    }
-    case MethodRecognizer::kFloat32x4Clamp: {
-      Definition* left = call->ArgumentAt(0);
-      Definition* lower = call->ArgumentAt(1);
-      Definition* upper = call->ArgumentAt(2);
-      // Type check left.
-      AddCheckClass(left,
-                    ICData::ZoneHandle(
-                        Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                    call->deopt_id(),
-                    call->env(),
-                    call);
-      Float32x4ClampInstr* clamp = new(Z) Float32x4ClampInstr(
-          new(Z) Value(left),
-          new(Z) Value(lower),
-          new(Z) Value(upper),
-          call->deopt_id());
-      ReplaceCall(call, clamp);
-      return true;
-    }
-    case MethodRecognizer::kFloat32x4ShuffleMix:
-    case MethodRecognizer::kFloat32x4Shuffle: {
-      return InlineFloat32x4Getter(call, recognized_kind);
-    }
-    default:
-      return false;
-  }
+  // Cannot handle unboxed instructions.
+  return false;
 }
 
 
-bool FlowGraphOptimizer::TryInlineFloat64x2Method(
+bool AotOptimizer::TryInlineFloat64x2Method(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
-  if (!ShouldInlineSimd()) {
-    return false;
-  }
-  ASSERT(call->HasICData());
-  switch (recognized_kind) {
-    case MethodRecognizer::kFloat64x2GetX:
-    case MethodRecognizer::kFloat64x2GetY:
-      ASSERT(call->ic_data()->HasReceiverClassId(kFloat64x2Cid));
-      ASSERT(call->ic_data()->HasOneTarget());
-      return InlineFloat64x2Getter(call, recognized_kind);
-    case MethodRecognizer::kFloat64x2Negate:
-    case MethodRecognizer::kFloat64x2Abs:
-    case MethodRecognizer::kFloat64x2Sqrt:
-    case MethodRecognizer::kFloat64x2GetSignMask: {
-      Definition* left = call->ArgumentAt(0);
-      // Type check left.
-      AddCheckClass(left,
-                    ICData::ZoneHandle(
-                        Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                    call->deopt_id(),
-                    call->env(),
-                    call);
-      Float64x2ZeroArgInstr* zeroArg =
-          new(Z) Float64x2ZeroArgInstr(
-              recognized_kind, new(Z) Value(left), call->deopt_id());
-      ReplaceCall(call, zeroArg);
-      return true;
-    }
-    case MethodRecognizer::kFloat64x2Scale:
-    case MethodRecognizer::kFloat64x2WithX:
-    case MethodRecognizer::kFloat64x2WithY:
-    case MethodRecognizer::kFloat64x2Min:
-    case MethodRecognizer::kFloat64x2Max: {
-      Definition* left = call->ArgumentAt(0);
-      Definition* right = call->ArgumentAt(1);
-      // Type check left.
-      AddCheckClass(left,
-                    ICData::ZoneHandle(
-                        Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                    call->deopt_id(),
-                    call->env(),
-                    call);
-      Float64x2OneArgInstr* zeroArg =
-          new(Z) Float64x2OneArgInstr(recognized_kind,
-                                      new(Z) Value(left),
-                                      new(Z) Value(right),
-                                      call->deopt_id());
-      ReplaceCall(call, zeroArg);
-      return true;
-    }
-    default:
-      return false;
-  }
+  // Cannot handle unboxed instructions.
+  return false;
 }
 
 
-bool FlowGraphOptimizer::TryInlineInt32x4Method(
+bool AotOptimizer::TryInlineInt32x4Method(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
-  if (!ShouldInlineSimd()) {
-    return false;
-  }
-  ASSERT(call->HasICData());
-  switch (recognized_kind) {
-    case MethodRecognizer::kInt32x4ShuffleMix:
-    case MethodRecognizer::kInt32x4Shuffle:
-    case MethodRecognizer::kInt32x4GetFlagX:
-    case MethodRecognizer::kInt32x4GetFlagY:
-    case MethodRecognizer::kInt32x4GetFlagZ:
-    case MethodRecognizer::kInt32x4GetFlagW:
-    case MethodRecognizer::kInt32x4GetSignMask:
-      ASSERT(call->ic_data()->HasReceiverClassId(kInt32x4Cid));
-      ASSERT(call->ic_data()->HasOneTarget());
-      return InlineInt32x4Getter(call, recognized_kind);
-
-    case MethodRecognizer::kInt32x4Select: {
-      Definition* mask = call->ArgumentAt(0);
-      Definition* trueValue = call->ArgumentAt(1);
-      Definition* falseValue = call->ArgumentAt(2);
-      // Type check left.
-      AddCheckClass(mask,
-                    ICData::ZoneHandle(
-                        Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                    call->deopt_id(),
-                    call->env(),
-                    call);
-      Int32x4SelectInstr* select = new(Z) Int32x4SelectInstr(
-          new(Z) Value(mask),
-          new(Z) Value(trueValue),
-          new(Z) Value(falseValue),
-          call->deopt_id());
-      ReplaceCall(call, select);
-      return true;
-    }
-    case MethodRecognizer::kInt32x4WithFlagX:
-    case MethodRecognizer::kInt32x4WithFlagY:
-    case MethodRecognizer::kInt32x4WithFlagZ:
-    case MethodRecognizer::kInt32x4WithFlagW: {
-      Definition* left = call->ArgumentAt(0);
-      Definition* flag = call->ArgumentAt(1);
-      // Type check left.
-      AddCheckClass(left,
-                    ICData::ZoneHandle(
-                        Z, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                    call->deopt_id(),
-                    call->env(),
-                    call);
-      Int32x4SetFlagInstr* setFlag = new(Z) Int32x4SetFlagInstr(
-          recognized_kind,
-          new(Z) Value(left),
-          new(Z) Value(flag),
-          call->deopt_id());
-      ReplaceCall(call, setFlag);
-      return true;
-    }
-    default:
-      return false;
-  }
+  // Cannot handle unboxed instructions.
+  return false;
 }
 
 
 // If type tests specified by 'ic_data' do not depend on type arguments,
 // return mapping cid->result in 'results' (i : cid; i + 1: result).
 // If all tests yield the same result, return it otherwise return Bool::null.
 // If no mapping is possible, 'results' is empty.
 // An instance-of test returning all same results can be converted to a class
 // check.
-RawBool* FlowGraphOptimizer::InstanceOfAsBool(
+RawBool* AotOptimizer::InstanceOfAsBool(
     const ICData& ic_data,
     const AbstractType& type,
     ZoneGrowableArray<intptr_t>* results) const {
   ASSERT(results->is_empty());
   ASSERT(ic_data.NumArgsTested() == 1);  // Unary checks only.
   if (type.IsFunctionType() || type.IsDartFunctionType() ||
       !type.IsInstantiated() || type.IsMalformedOrMalbounded()) {
     return Bool::null();
   }
   const Class& type_class = Class::Handle(Z, type.type_class());
@@ skipping 38 matching lines @@
       if (is_subtype != prev.value()) {
         results_differ = true;
       }
     }
   }
   return results_differ ?  Bool::null() : prev.raw();
 }
 
 
 // Returns true if checking against this type is a direct class id comparison.
-bool FlowGraphOptimizer::TypeCheckAsClassEquality(const AbstractType& type) {
+bool AotOptimizer::TypeCheckAsClassEquality(const AbstractType& type) {
   ASSERT(type.IsFinalized() && !type.IsMalformedOrMalbounded());
   // Requires CHA.
   if (!type.IsInstantiated()) return false;
   // Function types have different type checking rules.
   if (type.IsFunctionType()) return false;
   const Class& type_class = Class::Handle(type.type_class());
   // Could be an interface check?
   if (CHA::IsImplemented(type_class)) return false;
   // Check if there are subclasses.
   if (CHA::HasSubclasses(type_class)) {
@@ skipping 83 matching lines @@
     TryAddTest(results, kBigintCid, true);
     // Cannot deoptimize since all tests returning true have been added.
     return false;
   }
 
   return true;  // May deoptimize since we have not identified all 'true' tests.
 }
 
 
 // TODO(srdjan): Use ICData to check if always true or false.
-void FlowGraphOptimizer::ReplaceWithInstanceOf(InstanceCallInstr* call) {
+void AotOptimizer::ReplaceWithInstanceOf(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeTestOperator(call->token_kind()));
   Definition* left = call->ArgumentAt(0);
   Definition* type_args = NULL;
   AbstractType& type = AbstractType::ZoneHandle(Z);
   bool negate = false;
   if (call->ArgumentCount() == 2) {
     type_args = flow_graph()->constant_null();
     if (call->function_name().raw() ==
         Library::PrivateCoreLibName(Symbols::_instanceOfNum()).raw()) {
       type = Type::Number();
@@ skipping 87 matching lines @@
                              new(Z) Value(left),
                              new(Z) Value(type_args),
                              type,
                              negate,
                              call->deopt_id());
   ReplaceCall(call, instance_of);
 }
 
 
 // TODO(srdjan): Apply optimizations as in ReplaceWithInstanceOf (TestCids).
-void FlowGraphOptimizer::ReplaceWithTypeCast(InstanceCallInstr* call) {
+void AotOptimizer::ReplaceWithTypeCast(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeCastOperator(call->token_kind()));
   Definition* left = call->ArgumentAt(0);
   Definition* type_args = call->ArgumentAt(1);
   const AbstractType& type =
       AbstractType::Cast(call->ArgumentAt(2)->AsConstant()->value());
   ASSERT(!type.IsMalformedOrMalbounded());
   const ICData& unary_checks =
       ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecks());
   if ((unary_checks.NumberOfChecks() > 0) &&
       (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks)) {
@@ skipping 22 matching lines @@
       new(Z) AssertAssignableInstr(call->token_pos(),
                                    new(Z) Value(left),
                                    new(Z) Value(type_args),
                                    type,
                                    dst_name,
                                    call->deopt_id());
   ReplaceCall(call, assert_as);
 }
 
 
-bool FlowGraphOptimizer::IsBlackListedForInlining(intptr_t call_deopt_id) {
+bool AotOptimizer::IsBlackListedForInlining(intptr_t call_deopt_id) {
   for (intptr_t i = 0; i < inlining_black_list_->length(); ++i) {
     if ((*inlining_black_list_)[i] == call_deopt_id) return true;
   }
   return false;
 }
 
 // Special optimizations when running in --noopt mode.
-void FlowGraphOptimizer::InstanceCallNoopt(InstanceCallInstr* instr) {
+void AotOptimizer::InstanceCallNoopt(InstanceCallInstr* instr) {
   // TODO(srdjan): Investigate other attempts, as they are not allowed to
   // deoptimize.
 
   // Type test is special as it always gets converted into inlined code.
   const Token::Kind op_kind = instr->token_kind();
   if (Token::IsTypeTestOperator(op_kind)) {
     ReplaceWithInstanceOf(instr);
     return;
   }
   if (Token::IsTypeCastOperator(op_kind)) {
@@ skipping 118 matching lines @@
         new(Z) PolymorphicInstanceCallInstr(instr, ic_data,
                                             /* 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;
-  }
-
-  if (Token::IsTypeCastOperator(op_kind)) {
-    ReplaceWithTypeCast(instr);
-    return;
-  }
-
-  const ICData& unary_checks =
-      ICData::ZoneHandle(Z, instr->ic_data()->AsUnaryClassChecks());
-
-  const intptr_t max_checks = (op_kind == Token::kEQ)
-      ? FLAG_max_equality_polymorphic_checks
-      : FLAG_max_polymorphic_checks;
-  if ((unary_checks.NumberOfChecks() > max_checks) &&
-      InstanceCallNeedsClassCheck(instr, RawFunction::kRegularFunction)) {
-    // Too many checks, it will be megamorphic which needs unary checks.
-    instr->set_ic_data(&unary_checks);
-    return;
-  }
-
-  if ((op_kind == Token::kASSIGN_INDEX) && TryReplaceWithIndexedOp(instr)) {
-    return;
-  }
-  if ((op_kind == Token::kINDEX) && TryReplaceWithIndexedOp(instr)) {
-    return;
-  }
-
-  if (op_kind == Token::kEQ && TryReplaceWithEqualityOp(instr, op_kind)) {
-    return;
-  }
-
-  if (Token::IsRelationalOperator(op_kind) &&
-      TryReplaceWithRelationalOp(instr, op_kind)) {
-    return;
-  }
-
-  if (Token::IsBinaryOperator(op_kind) &&
-      TryReplaceWithBinaryOp(instr, op_kind)) {
-    return;
-  }
-  if (Token::IsUnaryOperator(op_kind) &&
-      TryReplaceWithUnaryOp(instr, op_kind)) {
-    return;
-  }
-  if ((op_kind == Token::kGET) && TryInlineInstanceGetter(instr)) {
-    return;
-  }
-  if ((op_kind == Token::kSET) &&
-      TryInlineInstanceSetter(instr, unary_checks)) {
-    return;
-  }
-  if (TryInlineInstanceMethod(instr)) {
-    return;
-  }
-
-  bool has_one_target = unary_checks.HasOneTarget();
-
-  if (has_one_target) {
-    // Check if the single target is a polymorphic target, if it is,
-    // we don't have one target.
-    const Function& target =
-        Function::Handle(Z, unary_checks.GetTargetAt(0));
-    const bool polymorphic_target = MethodRecognizer::PolymorphicTarget(target);
-    has_one_target = !polymorphic_target;
-  }
-
-  if (has_one_target) {
-    RawFunction::Kind function_kind =
-        Function::Handle(Z, unary_checks.GetTargetAt(0)).kind();
-    if (!InstanceCallNeedsClassCheck(instr, function_kind)) {
-      PolymorphicInstanceCallInstr* call =
-          new(Z) PolymorphicInstanceCallInstr(instr, unary_checks,
-                                              /* call_with_checks = */ false);
-      instr->ReplaceWith(call, current_iterator());
-      return;
-    }
-  }
-
-  if (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks) {
-    bool call_with_checks;
-    if (has_one_target && FLAG_polymorphic_with_deopt) {
-      // Type propagation has not run yet, we cannot eliminate the check.
-      AddReceiverCheck(instr);
-      // Call can still deoptimize, do not detach environment from instr.
-      call_with_checks = false;
-    } else {
-      call_with_checks = true;
-    }
-    PolymorphicInstanceCallInstr* call =
-        new(Z) PolymorphicInstanceCallInstr(instr, unary_checks,
-                                            call_with_checks);
-    instr->ReplaceWith(call, current_iterator());
-  }
+void AotOptimizer::VisitInstanceCall(InstanceCallInstr* instr) {
+  ASSERT(FLAG_precompilation);
+  InstanceCallNoopt(instr);
 }
 
 
-void FlowGraphOptimizer::VisitStaticCall(StaticCallInstr* call) {
+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) {
-    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);
+    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);
       break;
     case MethodRecognizer::kFloat64x2Constructor:
     case MethodRecognizer::kFloat64x2Zero:
     case MethodRecognizer::kFloat64x2Splat:
@@ skipping 55 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(),
-                                          recognized_kind,
-                                          call->token_pos());
-      ReplaceCall(call, invoke);
-      break;
+      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);
             ReplaceCall(call,
                         new(Z) SmiToDoubleInstr(new(Z) Value(arg),
@@ skipping 35 matching lines @@
             default:
               break;
           }
         }
       }
     }
   }
 }
 
 
-void FlowGraphOptimizer::VisitStoreInstanceField(
-    StoreInstanceFieldInstr* instr) {
-  if (instr->IsUnboxedStore()) {
-    ASSERT(instr->is_potential_unboxed_initialization_);
-    // Determine if this field should be unboxed based on the usage of getter
-    // and setter functions: The heuristic requires that the setter has a
-    // usage count of at least 1/kGetterSetterRatio of the getter usage count.
-    // This is to avoid unboxing fields where the setter is never or rarely
-    // executed.
-    const Field& field = Field::ZoneHandle(Z, instr->field().raw());
-    const String& field_name = String::Handle(Z, field.name());
-    const Class& owner = Class::Handle(Z, field.owner());
-    const Function& getter =
-        Function::Handle(Z, owner.LookupGetterFunction(field_name));
-    const Function& setter =
-        Function::Handle(Z, owner.LookupSetterFunction(field_name));
-    bool unboxed_field = false;
-    if (!getter.IsNull() && !setter.IsNull()) {
-      if (field.is_double_initialized()) {
-        unboxed_field = true;
-      } else if ((setter.usage_counter() > 0) &&
-                 ((FLAG_getter_setter_ratio * setter.usage_counter()) >=
-                   getter.usage_counter())) {
-        unboxed_field = true;
-      }
-    }
-    if (!unboxed_field) {
-      // TODO(srdjan): Instead of aborting pass this field to the mutator thread
-      // so that it can:
-      // - set it to unboxed
-      // - deoptimize dependent code.
-      if (Compiler::IsBackgroundCompilation()) {
-        isolate()->AddDeoptimizingBoxedField(field);
-        Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId);
-        UNREACHABLE();
-      }
-      if (FLAG_trace_optimization || FLAG_trace_field_guards) {
-        THR_Print("Disabling unboxing of %s\n", field.ToCString());
-        if (!setter.IsNull()) {
-          OS::Print("  setter usage count: %" Pd "\n", setter.usage_counter());
-        }
-        if (!getter.IsNull()) {
-          OS::Print("  getter usage count: %" Pd "\n", getter.usage_counter());
-        }
-      }
-      field.set_is_unboxing_candidate(false);
-      field.DeoptimizeDependentCode();
-    } else {
-      flow_graph()->parsed_function().AddToGuardedFields(&field);
-    }
-  }
-}
-
-
-void FlowGraphOptimizer::VisitAllocateContext(AllocateContextInstr* instr) {
+void AotOptimizer::VisitAllocateContext(AllocateContextInstr* instr) {
   // Replace generic allocation with a sequence of inlined allocation and
   // explicit initalizing stores.
   AllocateUninitializedContextInstr* replacement =
       new AllocateUninitializedContextInstr(instr->token_pos(),
                                             instr->num_context_variables());
   instr->ReplaceWith(replacement, current_iterator());
 
   StoreInstanceFieldInstr* store =
       new(Z) StoreInstanceFieldInstr(Context::parent_offset(),
                                      new Value(replacement),
@@ skipping 14 matching lines @@
                                        instr->token_pos());
     // Storing into uninitialized memory; remember to prevent dead store
     // elimination and ensure proper GC barrier.
     store->set_is_object_reference_initialization(true);
     flow_graph_->InsertAfter(cursor, store, NULL, FlowGraph::kEffect);
     cursor = store;
   }
 }
 
 
-void FlowGraphOptimizer::VisitLoadCodeUnits(LoadCodeUnitsInstr* instr) {
+void AotOptimizer::VisitLoadCodeUnits(LoadCodeUnitsInstr* instr) {
   // TODO(zerny): Use kUnboxedUint32 once it is fully supported/optimized.
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_ARM)
   if (!instr->can_pack_into_smi())
     instr->set_representation(kUnboxedMint);
 #endif
 }
 
 
-bool FlowGraphOptimizer::TryInlineInstanceSetter(InstanceCallInstr* instr,
+bool AotOptimizer::TryInlineInstanceSetter(InstanceCallInstr* instr,
                                                  const ICData& unary_ic_data,
                                                  bool allow_checks) {
   ASSERT((unary_ic_data.NumberOfChecks() > 0) &&
       (unary_ic_data.NumArgsTested() == 1));
   if (I->flags().type_checks()) {
     // Checked mode setters are inlined like normal methods by conventional
     // inlining.
     return false;
   }
 
@@ skipping 54 matching lines @@
   }
 
   // Field guard was detached.
   StoreInstanceFieldInstr* store = new(Z) StoreInstanceFieldInstr(
       field,
       new(Z) Value(instr->ArgumentAt(0)),
       new(Z) Value(instr->ArgumentAt(1)),
       kEmitStoreBarrier,
       instr->token_pos());
 
-  if (store->IsUnboxedStore()) {
-    flow_graph()->parsed_function().AddToGuardedFields(&field);
-  }
+  // No unboxed stores in precompiled code.
+  ASSERT(!store->IsUnboxedStore());
 
   // Discard the environment from the original instruction because the store
   // can't deoptimize.
   instr->RemoveEnvironment();
   ReplaceCall(instr, store);
   return true;
 }
 
 
 }  // namespace dart