Implement StaticCall and InstanceCall in the new code generator.

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 34 matching lines @@
       __ LoadObject(RAX, value->AsConstant()->instance());
     }
   } else {
     ASSERT(value->IsTemp());
     __ popq(RAX);
   }
 }
 
 
 void FlowGraphCompiler::VisitTemp(TempVal* val) {
-  Bailout("TempVal");
+  LoadValue(val);
 }
 
 
 void FlowGraphCompiler::VisitConstant(ConstantVal* val) {
-  Bailout("ConstantVal");
+  LoadValue(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.
+template <typename T> static bool VerifyCallComputation(T* comp) {
+  // Argument values should be consecutive temps.
+  //
+  // TODO(kmillikin): implement stack height tracking so we can also assert
+  // they are on top of the stack.
+  intptr_t previous = -1;
+  for (int i = 0; i < comp->ArgumentCount(); ++i) {
+    TempVal* temp = comp->ArgumentAt(i)->AsTemp();
+    if (temp == NULL) return false;
+    if (i != 0) {
+      if (temp->index() != previous + 1) return false;
+    }
+    previous = temp->index();
+  }
+  return true;
+}
+
+
 void FlowGraphCompiler::VisitInstanceCall(InstanceCallComp* comp) {
-  Bailout("InstanceCallComp");
+  ASSERT(VerifyCallComputation(comp));
+
+  ICData& ic_data =
+      ICData::ZoneHandle(ICData::New(parsed_function_.function(),
+                                     comp->function_name(),
+                                     comp->node_id(),
+                                     comp->checked_argument_count()));
+  int argument_count = comp->ArgumentCount();
+  const Array& arguments_descriptor =
+      CodeGenerator::ArgumentsDescriptor(argument_count,
+                                         comp->argument_names());
+  __ LoadObject(RBX, ic_data);
+  __ LoadObject(R10, arguments_descriptor);
+
+  uword label_address = 0;
+  switch (comp->checked_argument_count()) {
+    case 1:
+      label_address = StubCode::OneArgCheckInlineCacheEntryPoint();
+      break;
+    case 2:
+      label_address = StubCode::TwoArgsCheckInlineCacheEntryPoint();
+      break;
+    default:
+      UNIMPLEMENTED();
+  }
+  ExternalLabel target_label("InlineCache", label_address);
+  __ call(&target_label);
+  AddCurrentDescriptor(PcDescriptors::kIcCall,
+                       comp->node_id(),
+                       comp->token_index());
+  __ addq(RSP, Immediate(argument_count * kWordSize));
 }
 
 
 void FlowGraphCompiler::VisitStrictCompare(StrictCompareComp* comp) {
   Bailout("StrictCompareComp");
 }
 
 
 
 void FlowGraphCompiler::VisitStaticCall(StaticCallComp* comp) {
-  Bailout("StaticCallComp");
+  ASSERT(VerifyCallComputation(comp));
+
+  int argument_count = comp->ArgumentCount();
+  const Array& arguments_descriptor =
+      CodeGenerator::ArgumentsDescriptor(argument_count,
+                                         comp->argument_names());
+  __ LoadObject(RBX, comp->function());
+  __ LoadObject(R10, arguments_descriptor);
+
+  GenerateCall(comp->token_index(),
+               &StubCode::CallStaticFunctionLabel(),
+               PcDescriptors::kFuncCall);
+  __ addq(RSP, Immediate(argument_count * kWordSize));
 }
 
 
 void FlowGraphCompiler::VisitLoadLocal(LoadLocalComp* comp) {
   if (comp->local().is_captured()) {
     Bailout("load of context variable");
   }
   __ movq(RAX, Address(RBP, comp->local().index() * kWordSize));
 }
 
@@ skipping 159 matching lines @@
   pc_descriptors_list_->AddDescriptor(PcDescriptors::kPatchCode,
                                       assembler_->CodeSize(),
                                       AstNode::kNoId,
                                       0,
                                       -1);
   __ jmp(&StubCode::FixCallersTargetLabel());
 }
 
 
 // Infrastructure copied from class CodeGenerator.
+void FlowGraphCompiler::GenerateCall(intptr_t token_index,
+                                     const ExternalLabel* label,
+                                     PcDescriptors::Kind kind) {
+  __ call(label);
+  AddCurrentDescriptor(kind, AstNode::kNoId, token_index);
+}
+
+
 void FlowGraphCompiler::GenerateCallRuntime(intptr_t node_id,
                                             intptr_t token_index,
                                             const RuntimeEntry& entry) {
   __ CallRuntimeFromDart(entry);
   AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_index);
 }
 
 
 // Uses current pc position and try-index.
 void FlowGraphCompiler::AddCurrentDescriptor(PcDescriptors::Kind kind,
@@ skipping 26 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