Move CreateArray and CreateClosure to new location template.

runtime/vm/intermediate_language_x64.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/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "lib/error.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
@@ skipping 563 matching lines @@
   compiler->GenerateInstanceOf(cid(),
                                token_index(),
                                try_index(),
                                type(),
                                negate_result());
   ASSERT(locs()->out().reg() == RAX);
 }
 
 
 LocationSummary* CreateArrayComp::MakeLocationSummary() const {
-  return NULL;
+  const intptr_t kNumInputs = 0;
+  const intptr_t kNumTemps = 2;
+  LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+  locs->set_temp(0, Location::RegisterLocation(R10));
+  locs->set_temp(1, Location::RegisterLocation(RBX));
+  locs->set_out(Location::RegisterLocation(RAX));
+  return locs;
 }
 
 
 void CreateArrayComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  ASSERT(locs()->temp(0).reg() == R10);
+  ASSERT(locs()->temp(1).reg() == RBX);
+
+  // 1. Allocate the array.  R10 = length, RBX = element type.
+  __ movq(R10, Immediate(Smi::RawValue(ElementCount())));
+  compiler->LoadValue(RBX, element_type());

[Vyacheslav Egorov (Google), 2012/05/30 10:44:11]

New templates should not use LoadValue directly. Instead RBX should become an
input.

I can see however that our instruction prologue does not have a proper support
for constant inputs though. So it will try to pop something that is not pushed
if you try that.

It seems that the only way around is to teach prologue about connection between
inputs locations and input values, so that it could support both constants and
non-constants.

[Vyacheslav Egorov (Google), 2012/05/30 11:13:41]

Actually I misread the code in BuildInstantiatedTypeArguments. It will never
return a constant directly even if it is null. So you can just convert Remove
load value and do

locs->set_in(0, Location::RegisterLocation(RBX))

+  compiler->GenerateCall(token_index(),
+                         try_index(),
+                         &StubCode::AllocateArrayLabel(),
+                         PcDescriptors::kOther);
+
+  // 2. Initialize the array in RAX with the element values.
+  __ leaq(R10, FieldAddress(RAX, Array::data_offset()));
+  for (int i = ElementCount() - 1; i >= 0; --i) {
+    if (ElementAt(i)->IsUse()) {
+      __ popq(Address(R10, i * kWordSize));
+    } else {
+      compiler->LoadValue(RBX, ElementAt(i));
+      __ movq(Address(R10, i * kWordSize), RBX);
+    }
+  }
 }
 
 
 LocationSummary* CreateClosureComp::MakeLocationSummary() const {
-  return NULL;
+  return MakeCallSummary();
 }
 
 
 void CreateClosureComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  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_index(), try_index(), &label,
+                         PcDescriptors::kOther);
+
+  const Class& cls = Class::Handle(closure_function.signature_class());
+  if (cls.HasTypeArguments()) {
+    __ Drop(1);  // Discard type arguments.
+  }
+  if (closure_function.IsImplicitInstanceClosureFunction()) {
+    __ Drop(1);  // Discard receiver.
+  }
 }
 
 
 LocationSummary* AllocateObjectComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void AllocateObjectComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Class& cls = Class::ZoneHandle(constructor().owner());
@@ skipping 355 matching lines @@
   if (locs()->out().reg() != RAX) {
     __ movq(locs()->out().reg(), RAX);
   }
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64