Convert some compiler passes to preserve valid def-use chains.

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/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 545 matching lines @@
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_subst_timer,
                          isolate);
 
         // Plug result in the caller graph.
         inlining_context->ReplaceCall(caller_graph_, call, callee_graph);
 
         // Remove push arguments of the call.
         for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
-          PushArgumentInstr* push = call->ArgumentAt(i);
+          PushArgumentInstr* push = call->PushArgumentAt(i);
           push->ReplaceUsesWith(push->value()->definition());
           push->RemoveFromGraph();
         }
 
         // Replace each stub with the actual argument or the caller's constant.
         // Nulls denote optional parameters for which no actual was given.
         for (intptr_t i = 0; i < arguments->length(); ++i) {
           Definition* stub = param_stubs[i];
           Value* actual = (*arguments)[i];
           if (actual != NULL) stub->ReplaceUsesWith(actual->definition());
@@ skipping 68 matching lines @@
   }
 
   void InlineStaticCalls() {
     const GrowableArray<StaticCallInstr*>& calls =
         inlining_call_sites_->static_calls();
     TRACE_INLINING(OS::Print("  Static Calls (%d)\n", calls.length()));
     for (intptr_t i = 0; i < calls.length(); ++i) {
       StaticCallInstr* call = calls[i];
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int i = 0; i < call->ArgumentCount(); ++i) {
-        arguments.Add(call->ArgumentAt(i)->value());
+        arguments.Add(call->PushArgumentAt(i)->value());
       }
       TryInlining(call->function(), call->argument_names(), &arguments, call);
     }
   }
 
   void InlineClosureCalls() {
     const GrowableArray<ClosureCallInstr*>& calls =
         inlining_call_sites_->closure_calls();
     TRACE_INLINING(OS::Print("  Closure Calls (%d)\n", calls.length()));
     for (intptr_t i = 0; i < calls.length(); ++i) {
       ClosureCallInstr* call = calls[i];
       // Find the closure of the callee.
       ASSERT(call->ArgumentCount() > 0);
       const CreateClosureInstr* closure =
-          call->ArgumentAt(0)->value()->definition()->AsCreateClosure();
+          call->ArgumentAt(0)->AsCreateClosure();
       if (closure == NULL) {
         TRACE_INLINING(OS::Print("     Bailout: non-closure operator\n"));
         continue;
       }
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int i = 0; i < call->ArgumentCount(); ++i) {
-        arguments.Add(call->ArgumentAt(i)->value());
+        arguments.Add(call->PushArgumentAt(i)->value());
       }
       TryInlining(closure->function(),
                   call->argument_names(),
                   &arguments,
                   call);
     }
   }
 
   void InlineInstanceCalls() {
     const GrowableArray<CallSites::InstanceCallInfo>& call_info =
@@ skipping 15 matching lines @@
       if ((call_info[i].ratio * 100) < FLAG_inlining_hotness) {
         TRACE_INLINING(OS::Print(
             "  => %s (deopt count %d)\n     Bailout: cold %f\n",
             target.ToCString(),
             target.deoptimization_counter(),
             call_info[i].ratio));
         continue;
       }
       GrowableArray<Value*> arguments(instr->ArgumentCount());
       for (int arg_i = 0; arg_i < instr->ArgumentCount(); ++arg_i) {
-        arguments.Add(instr->ArgumentAt(arg_i)->value());
+        arguments.Add(instr->PushArgumentAt(arg_i)->value());
       }
       TryInlining(target,
                   instr->instance_call()->argument_names(),
                   &arguments,
                   instr);
     }
   }
 
   void AdjustForOptionalParameters(const ParsedFunction& parsed_function,
                                    const Array& argument_names,
@@ skipping 144 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart