Support compilation of ArrayNode.

runtime/vm/flow_graph_compiler_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 "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 52 matching lines @@
 
 
 void FlowGraphCompiler::GenerateAssertAssignable(intptr_t node_id,
                                                  intptr_t token_index,
                                                  const AbstractType& dst_type,
                                                  const String& dst_name) {
   Bailout("GenerateAssertAssignable");
 }
 
 
-void FlowGraphCompiler::LoadValue(Value* value) {
+void FlowGraphCompiler::LoadValue(Register dst, Value* value) {
   if (value->IsConstant()) {
     ConstantVal* constant = value->AsConstant();
     if (constant->instance().IsSmi()) {
       int64_t imm = reinterpret_cast<int64_t>(constant->instance().raw());
-      __ movq(RAX, Immediate(imm));
+      __ movq(dst, Immediate(imm));
     } else {
-      __ LoadObject(RAX, value->AsConstant()->instance());
+      __ LoadObject(dst, value->AsConstant()->instance());
     }
   } else {
     ASSERT(value->IsTemp());
-    __ popq(RAX);
+    __ popq(dst);
   }
 }
 
 
 void FlowGraphCompiler::VisitTemp(TempVal* val) {
-  LoadValue(val);
+  LoadValue(RAX, val);
 }
 
 
 void FlowGraphCompiler::VisitConstant(ConstantVal* val) {
-  LoadValue(val);
+  LoadValue(RAX, val);
 }
 
 
 void FlowGraphCompiler::VisitAssertAssignable(AssertAssignableComp* comp) {
   Bailout("AssertAssignableComp");
 }
 
 
 // True iff. the arguments to a call will be properly pushed and can
 // be popped after the call.
@@ skipping 97 matching lines @@
     Bailout("load of context variable");
   }
   __ movq(RAX, Address(RBP, comp->local().index() * kWordSize));
 }
 
 
 void FlowGraphCompiler::VisitStoreLocal(StoreLocalComp* comp) {
   if (comp->local().is_captured()) {
     Bailout("store to context variable");
   }
-  LoadValue(comp->value());
+  LoadValue(RAX, comp->value());
   __ movq(Address(RBP, comp->local().index() * kWordSize), RAX);
 }
 
 
 void FlowGraphCompiler::VisitNativeCall(NativeCallComp* comp) {
   Bailout("NativeCallComp");
 }
 
 
 void FlowGraphCompiler::VisitLoadInstanceField(LoadInstanceFieldComp* comp) {
-  LoadValue(comp->instance());  // -> RAX.
+  LoadValue(RAX, comp->instance());
   __ movq(RAX, FieldAddress(RAX, comp->field().Offset()));
 }
 
 
 void FlowGraphCompiler::VisitStoreInstanceField(StoreInstanceFieldComp* comp) {
   VerifyValues(comp->instance(), comp->value());
-  LoadValue(comp->value());
-  __ movq(R10, RAX);
-  LoadValue(comp->instance());  // -> RAX.
-  __ StoreIntoObject(RAX, FieldAddress(RAX, comp->field().Offset()), R10);
+  LoadValue(RDX, comp->value());
+  LoadValue(RAX, comp->instance());
+  __ StoreIntoObject(RAX, FieldAddress(RAX, comp->field().Offset()), RDX);
 }
 
 
 
 void FlowGraphCompiler::VisitLoadStaticField(LoadStaticFieldComp* comp) {
   __ LoadObject(RDX, comp->field());
   __ movq(RAX, FieldAddress(RDX, Field::value_offset()));
 }
 
 
 void FlowGraphCompiler::VisitStoreStaticField(StoreStaticFieldComp* comp) {
-  LoadValue(comp->value());
+  LoadValue(RAX, comp->value());
   __ LoadObject(RDX, comp->field());
   __ StoreIntoObject(RDX, FieldAddress(RDX, Field::value_offset()), RAX);
 }
 
 
 void FlowGraphCompiler::VisitStoreIndexed(StoreIndexedComp* comp) {
   // Call operator []= but preserve the third argument value under the
   // arguments as the result of the computation.
   const String& function_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
@@ skipping 27 matching lines @@
   EmitInstanceCall(comp->node_id(), comp->token_index(), function_name, 2,
                    Array::ZoneHandle(), 1);
   __ popq(RAX);
 }
 
 
 void FlowGraphCompiler::VisitBooleanNegate(BooleanNegateComp* comp) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   Label done;
-  LoadValue(comp->value());
-  __ movq(RDX, RAX);
+  LoadValue(RDX, comp->value());
   __ LoadObject(RAX, bool_true);
   __ cmpq(RAX, RDX);
   __ j(NOT_EQUAL, &done, Assembler::kNearJump);
   __ LoadObject(RAX, bool_false);
   __ Bind(&done);
 }
 
 
 void FlowGraphCompiler::VisitInstanceOf(InstanceOfComp* comp) {
   Bailout("InstanceOf");
 }
 
 
+void FlowGraphCompiler::VisitCreateArray(CreateArrayComp* comp) {
+  // 1. Allocate the array.  R10 = length, RBX = element type.
+  __ movq(R10, Immediate(Smi::RawValue(comp->ElementCount())));
+  const AbstractTypeArguments& element_type = comp->type_arguments();
+  ASSERT(element_type.IsNull() || element_type.IsInstantiated());
+  __ LoadObject(RBX, element_type);
+  GenerateCall(comp->token_index(),
+               &StubCode::AllocateArrayLabel(),
+               PcDescriptors::kOther);
+
+  // 2. Initialize the array in RAX with the element values.
+  __ leaq(RCX, FieldAddress(RAX, Array::data_offset()));
+  for (int i = comp->ElementCount() - 1; i >= 0; --i) {
+    if (comp->ElementAt(i)->IsTemp()) {
+      __ popq(Address(RCX, i * kWordSize));
+    } else {
+      LoadValue(RDX, comp->ElementAt(i));
+      __ movq(Address(RCX, i * kWordSize), RDX);
+    }
+  }
+}
+
+
 void FlowGraphCompiler::VisitBlocks(
     const GrowableArray<BlockEntryInstr*>& blocks) {
   for (intptr_t i = blocks.length() - 1; i >= 0; --i) {
     // Compile the block entry.
     current_block_ = blocks[i];
     Instruction* instr = current_block()->Accept(this);
     // Compile all successors until an exit, branch, or a block entry.
     while ((instr != NULL) && !instr->IsBlockEntry()) {
       instr = instr->Accept(this);
     }
@@ skipping 48 matching lines @@
 }
 
 
 void FlowGraphCompiler::VisitBind(BindInstr* instr) {
   instr->computation()->Accept(this);
   __ pushq(RAX);
 }
 
 
 void FlowGraphCompiler::VisitReturn(ReturnInstr* instr) {
-  LoadValue(instr->value());
+  LoadValue(RAX, instr->value());
 
 #ifdef DEBUG
   // Check that the entry stack size matches the exit stack size.
   __ movq(R10, RBP);
   __ subq(R10, RSP);
   __ cmpq(R10, Immediate(stack_local_count() * kWordSize));
   Label stack_ok;
   __ j(EQUAL, &stack_ok, Assembler::kNearJump);
   __ Stop("Exit stack size does not match the entry stack size.");
   __ Bind(&stack_ok);
@@ skipping 32 matching lines @@
 
 void FlowGraphCompiler::VisitBranch(BranchInstr* instr) {
   // Determine if the true branch is fall through (!negated) or the false
   // branch is.  They cannot both be backwards branches.
   intptr_t index = blocks_->length() - current_block()->block_number() - 1;
   ASSERT(index > 0);
 
   bool negated = ((*blocks_)[index - 1] == instr->false_successor());
   ASSERT(!negated == ((*blocks_)[index - 1] == instr->true_successor()));
 
-  LoadValue(instr->value());
+  LoadValue(RAX, instr->value());
   __ LoadObject(RDX, Bool::ZoneHandle(Bool::True()));
   __ cmpq(RAX, RDX);
   if (negated) {
     __ j(EQUAL, &block_info_[instr->true_successor()->block_number()]->label);
   } else {
     __ j(NOT_EQUAL,
          &block_info_[instr->false_successor()->block_number()]->label);
   }
 }
 
@@ skipping 131 matching lines @@
 void FlowGraphCompiler::FinalizeExceptionHandlers(const Code& code) {
   // We don't compile exception handlers yet.
   code.set_exception_handlers(
       ExceptionHandlers::Handle(ExceptionHandlers::New(0)));
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64