Add an explicit push-argument instruction to the IL.

vm/intermediate_language.cc

 // Copyright (c) 2012, 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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 108 matching lines @@
 intptr_t InstanceCallComp::InputCount() const {
   return ArgumentCount();
 }
 
 
 intptr_t StaticCallComp::InputCount() const {
   return ArgumentCount();
 }
 
 
-intptr_t ClosureCallComp::InputCount() const {
-  return ArgumentCount();
-}
-
-
 intptr_t AllocateObjectComp::InputCount() const {
   return arguments().length();
 }
 
 
 intptr_t AllocateObjectWithBoundsCheckComp::InputCount() const {
   return arguments().length();
 }
 
 
@@ skipping 117 matching lines @@
   UNREACHABLE();
   return NULL;
 }
 
 
 void GotoInstr::SetInputAt(intptr_t i, Value* value) {
   UNREACHABLE();
 }
 
 
+intptr_t PushArgumentInstr::InputCount() const {
+  return 1;
+}
+
+
+Value* PushArgumentInstr::InputAt(intptr_t i) const {
+  if (i == 0) return value();
+  UNREACHABLE();
+  return NULL;
+}
+
+
+void PushArgumentInstr::SetInputAt(intptr_t i, Value* value) {
+  if (i == 0) {
+    value_ = value;
+    return;
+  }
+  UNREACHABLE();
+}
+
+
 intptr_t ReturnInstr::InputCount() const {
   return 1;
 }
 
 
 Value* ReturnInstr::InputAt(intptr_t i) const {
   if (i == 0) return value();
   UNREACHABLE();
   return NULL;
 }
@@ skipping 827 matching lines @@
   __ j(true_condition, &load_true, Assembler::kNearJump);
   __ LoadObject(result, compiler->bool_false());
   __ jmp(&done, Assembler::kNearJump);
   __ Bind(&load_true);
   __ LoadObject(result, compiler->bool_true());
   __ Bind(&done);
 }
 
 
 void ClosureCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  ASSERT(VerifyCallComputation(this));
   // The arguments to the stub include the closure.  The arguments
   // descriptor describes the closure's arguments (and so does not include
   // the closure).
   Register temp_reg = locs()->temp(0).reg();
   int argument_count = ArgumentCount();
   const Array& arguments_descriptor =
       DartEntry::ArgumentsDescriptor(argument_count - 1,
                                          argument_names());
   __ LoadObject(temp_reg, arguments_descriptor);
 
@@ skipping 168 matching lines @@
   const Function& closure_function = function();
   const Code& stub = Code::Handle(
       StubCode::GetAllocationStubForClosure(closure_function));
   const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_pos(), try_index(), &label,
                          PcDescriptors::kOther);
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 
+LocationSummary* PushArgumentInstr::MakeLocationSummary() const {
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps= 0;
+  LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+  // TODO(fschneider): Use Any() once it is supported by all code generators.
+  locs->set_in(0, Location::RequiresRegister());
+  return locs;
+}
+
+
+void PushArgumentInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  // In SSA mode, we need an explicit push. Nothing to do in non-SSA mode
+  // where PushArgument is handled in FrameRegisterAllocator::AllocateRegisters.
+  // Instead of popping the value it is left alone on the simulated frame
+  // and materialized on the physical stack before the call.
+  // TODO(fschneider): Avoid special-casing for SSA mode here.
+  if (compiler->is_ssa()) {
+    ASSERT(locs()->in(0).IsRegister());
+    __ PushRegister(locs()->in(0).reg());
+  }
+}
+
+
 #undef __
 
 }  // namespace dart