Revert r38116 because of crashes.

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 1301 matching lines @@
 
   // Replace parameter stubs and constants.  Replace the receiver argument
   // with a redefinition to prevent code from the inlined body from being
   // hoisted above the inlined entry.
   ASSERT(arguments.length() > 0);
   Value* actual = arguments[0];
   RedefinitionInstr* redefinition = new(isolate())
       RedefinitionInstr(actual->Copy(isolate()));
   redefinition->set_ssa_temp_index(
       owner_->caller_graph()->alloc_ssa_temp_index());
-  redefinition->UpdateType(CompileType::FromCid(receiver_cid));
   redefinition->InsertAfter(callee_graph->graph_entry()->normal_entry());
   Definition* stub = (*call_data.parameter_stubs)[0];
   stub->ReplaceUsesWith(redefinition);
 
   for (intptr_t i = 1; i < arguments.length(); ++i) {
     actual = arguments[i];
     if (actual != NULL) {
       stub = (*call_data.parameter_stubs)[i];
       stub->ReplaceUsesWith(actual->definition());
     }
@@ skipping 94 matching lines @@
   // There are at least two variants including non-inlined ones, so we have
   // at least one branch on the class id.
   LoadClassIdInstr* load_cid =
       new(isolate()) LoadClassIdInstr(new(isolate()) Value(receiver));
   load_cid->set_ssa_temp_index(owner_->caller_graph()->alloc_ssa_temp_index());
   cursor = AppendInstruction(cursor, load_cid);
   for (intptr_t i = 0; i < inlined_variants_.length(); ++i) {
     // 1. Guard the body with a class id check.
     if ((i == (inlined_variants_.length() - 1)) &&
         non_inlined_variants_.is_empty()) {
-      // If it is the last variant use a check class id instruction which can
-      // deoptimize, followed unconditionally by the body.
-      const Smi& cid = Smi::ZoneHandle(Smi::New(inlined_variants_[i].cid));
-      ConstantInstr* cid_constant = new(isolate()) ConstantInstr(cid);
-      cid_constant->set_ssa_temp_index(
+      // If it is the last variant use a check class or check smi
+      // instruction which can deoptimize, followed unconditionally by the
+      // body.  Check a redefinition of the receiver, to prevent the check
+      // from being hoisted.
+      RedefinitionInstr* redefinition =
+          new(isolate()) RedefinitionInstr(new(isolate()) Value(receiver));
+      redefinition->set_ssa_temp_index(
           owner_->caller_graph()->alloc_ssa_temp_index());
-      cursor = AppendInstruction(cursor, cid_constant);
-
-      CheckClassIdInstr* check_class_id =
-          new(isolate()) CheckClassIdInstr(new(isolate()) Value(load_cid),
-                                           new(isolate()) Value(cid_constant),
-                                           call_->deopt_id());
-      check_class_id->InheritDeoptTarget(isolate(), call_);
-      cursor = AppendInstruction(cursor, check_class_id);
-
+      cursor = AppendInstruction(cursor, redefinition);
+      if (inlined_variants_[i].cid == kSmiCid) {
+        CheckSmiInstr* check_smi =
+            new CheckSmiInstr(new Value(redefinition),
+                              call_->deopt_id(),
+                              call_->token_pos());
+        check_smi->InheritDeoptTarget(isolate(), call_);
+        cursor = AppendInstruction(cursor, check_smi);
+      } else {
+        const ICData& old_checks = call_->ic_data();
+        const ICData& new_checks = ICData::ZoneHandle(
+            ICData::New(Function::Handle(old_checks.owner()),
+                        String::Handle(old_checks.target_name()),
+                        Array::Handle(old_checks.arguments_descriptor()),
+                        old_checks.deopt_id(),
+                        1));  // Number of args tested.
+        new_checks.AddReceiverCheck(inlined_variants_[i].cid,
+                                    *inlined_variants_[i].target);
+        CheckClassInstr* check_class =
+            new CheckClassInstr(new Value(redefinition),
+                                call_->deopt_id(),
+                                new_checks,
+                                call_->token_pos());
+        check_class->InheritDeoptTarget(isolate(), call_);
+        cursor = AppendInstruction(cursor, check_class);
+      }
       // The next instruction is the first instruction of the inlined body.
       // Handle the two possible cases (unshared and shared subsequent
       // predecessors) separately.
       BlockEntryInstr* callee_entry = inlined_entries_[i];
       if (callee_entry->IsGraphEntry()) {
         // Unshared.  Graft the normal entry on after the check class
         // instruction.
         TargetEntryInstr* target =
             callee_entry->AsGraphEntry()->normal_entry();
         cursor->LinkTo(target->next());
@@ skipping 246 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart