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 = 1;
+  const intptr_t kNumTemps = 2;

[Vyacheslav Egorov (Google), 2012/05/30 11:42:17]

should be 1

[regis, 2012/05/30 13:41:10]

Done.

+  LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+  locs->set_in(0, Location::RegisterLocation(RBX));
+  locs->set_temp(0, Location::RegisterLocation(R10));
+  locs->set_out(Location::RegisterLocation(RAX));
+  return locs;
 }
 
 
 void CreateArrayComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  ASSERT(locs()->in(0).reg() == RBX);
+  ASSERT(locs()->temp(0).reg() == R10);
+
+  // 1. Allocate the array.  R10 = length, RBX = element type.
+  __ movq(R10, Immediate(Smi::RawValue(ElementCount())));
+  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);
+    }
+  }

[Vyacheslav Egorov (Google), 2012/05/30 11:42:17]

On the one hand: it has all arguments on the stack and behaves like a call (and
does a call inside). So we could just MakeCallSummary() and load RBX explicitly
from the stack in the template.

On the other hand: we would not want to load something from the stack (like a
null constant) if we can have it loaded directly into register --- so loading
EBX is better left outside of the template.

I think what we have now is perfectly fine. But I defer it for you to decide. 

What I would do is to add TODO into MakeLocationSummary to keep in mind that
this instruction is a call (because real register allocator would have to know
that) and leave everything as it is in this version. 

[regis, 2012/05/30 13:41:10]

Added comment.

 }
 
 
 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