Support instance getters and setters, indexed loads and stores.

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;

[srdjan, 2012/03/01 23:19:31]

Can you check that last temp is on TOS, i.e., with highest index?

[Kevin Millikin (Google), 2012/03/02 09:01:28]

We can't easily check that it's actually on top of the stack.  That needs some
flow-sensitive stack height tracking that I've left as a TODO just above.  We
could also assert invariants about stack height (temporary indexes) in the graph
construction algorithm.

The current handling of calls/arguments is actually a bit fishy.  They mention
their arguments as operands, but they don't actually use them (for instance).

+}
+
+
+void FlowGraphCompiler::EmitInstanceCall(intptr_t node_id,
+                                         intptr_t token_index,
+                                         const String& function_name,
+                                         intptr_t argument_count,
+                                         const Array& argument_names,
+                                         intptr_t checked_argument_count) {
+  ICData& ic_data =
+      ICData::ZoneHandle(ICData::New(parsed_function_.function(),
+                                     function_name,
+                                     node_id,
+                                     checked_argument_count));
+  const Array& arguments_descriptor =
+      CodeGenerator::ArgumentsDescriptor(argument_count, argument_names);
+  __ LoadObject(RBX, ic_data);
+  __ LoadObject(R10, arguments_descriptor);
+
+  uword label_address = 0;
+  switch (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, node_id, token_index);
+  __ addq(RSP, Immediate(argument_count * kWordSize));
+}
+
+
 void FlowGraphCompiler::VisitInstanceCall(InstanceCallComp* comp) {
-  Bailout("InstanceCallComp");
+  ASSERT(VerifyCallComputation(comp));
+  EmitInstanceCall(comp->node_id(),
+                   comp->token_index(),
+                   comp->function_name(),
+                   comp->ArgumentCount(),
+                   comp->argument_names(),
+                   comp->checked_argument_count());
 }
 
 
 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));
 }
 
 
 void FlowGraphCompiler::VisitStoreLocal(StoreLocalComp* comp) {
   if (comp->local().is_captured()) {
     Bailout("store to context variable");
   }
   LoadValue(comp->value());
   __ movq(Address(RBP, comp->local().index() * kWordSize), 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)));
+  // Placeholder is under value, index, and receiver.
+  const int kPlaceholderOffset = 3 * kWordSize;
+  __ movq(RAX, Address(RSP, 0));  // Value.
+  __ movq(Address(RSP, kPlaceholderOffset), RAX);
+  EmitInstanceCall(comp->node_id(), comp->token_index(), function_name, 3,
+                   Array::ZoneHandle(), 1);
+  __ popq(RAX);
+}
+
+
+void FlowGraphCompiler::VisitInstanceSetter(InstanceSetterComp* comp) {
+  // Preserve the second argument under the arguments as the result of the
+  // computation, then call the getter.

[srdjan, 2012/03/01 23:19:31]

Can you verify that place holder, value, array and and index are all in right
positions? (also in other added instructions).

[Kevin Millikin (Google), 2012/03/02 09:01:28]

Yes.

+  const String& function_name =
+      String::ZoneHandle(Field::SetterSymbol(comp->field_name()));
+  // Placeholder is under value and receiver.
+  const int kPlaceholderOffset = 2 * kWordSize;
+  __ movq(RAX, Address(RSP, 0));  // Value.
+  __ movq(Address(RSP, kPlaceholderOffset), RAX);
+  EmitInstanceCall(comp->node_id(), comp->token_index(), function_name, 2,
+                   Array::ZoneHandle(), 1);
+  __ popq(RAX);
+}
+
+
 void FlowGraphCompiler::VisitJoinEntry(JoinEntryInstr* instr) {
   Bailout("JoinEntryInstr");
 }
 
 
 void FlowGraphCompiler::VisitTargetEntry(TargetEntryInstr* instr) {
   // Since we don't handle branching control flow yet, there is nothing to do.
 }
 
 
@@ skipping 139 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