Move ReturnInstr to new scheme (x64 and ia32) and implement more code in new ia32 compiler.

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"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stub_code.h"
 
 #define __ compiler->assembler()->
 
 namespace dart {
 
+DECLARE_FLAG(bool, optimization_counter_threshold);
+DECLARE_FLAG(bool, trace_functions);
 
 // 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) {
@@ skipping 16 matching lines @@
      v2->AsUse()->definition()->temp_index();
 }
 
 
 void BindInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   computation()->EmitNativeCode(compiler);
   __ pushq(locs()->out().reg());
 }
 
 
-static LocationSummary* MakeSimpleLocationSummary(
-    intptr_t input_count, Location out) {
-  LocationSummary* summary = new LocationSummary(input_count, 0);
-  for (intptr_t i = 0; i < input_count; i++) {
-    summary->set_in(i, Location::RequiresRegister());
+LocationSummary* ReturnInstr::locs() {
+  if (locs_ == NULL) {
+    const intptr_t kNumInputs = 1;
+    const intptr_t kNumTemps = 1;
+    locs_ = new LocationSummary(kNumInputs, kNumTemps);
+    locs_->set_in(0, Location::RegisterLocation(RAX));
+    locs_->set_temp(0, Location::RequiresRegister());
   }
-  summary->set_out(out);
-  return summary;
+  return locs_;
+}
+
+
+void ReturnInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register result = locs()->in(0).reg();
+  Register temp = locs()->temp(0).reg();
+  ASSERT(result == RAX);
+  if (!compiler->is_optimizing()) {
+    // Count only in unoptimized code.
+    // TODO(srdjan): Replace the counting code with a type feedback
+    // collection and counting stub.
+    const Function& function =
+          Function::ZoneHandle(compiler->parsed_function().function().raw());
+    __ LoadObject(temp, function);
+    __ incq(FieldAddress(temp, Function::usage_counter_offset()));
+    if (CodeGenerator::CanOptimize()) {
+      // Do not optimize if usage count must be reported.
+      __ cmpl(FieldAddress(temp, Function::usage_counter_offset()),
+          Immediate(FLAG_optimization_counter_threshold));
+      Label not_yet_hot;
+      __ j(LESS_EQUAL, &not_yet_hot, Assembler::kNearJump);
+      __ pushq(result);  // Preserve result.
+      __ pushq(temp);  // Argument for runtime: function to optimize.
+      __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry);
+      __ popq(temp);  // Remove argument.
+      __ popq(result);  // Restore result.
+      __ Bind(&not_yet_hot);
+    }
+  }
+  if (FLAG_trace_functions) {
+    __ pushq(result);  // Preserve result.
+    const Function& function =
+        Function::ZoneHandle(compiler->parsed_function().function().raw());
+    __ LoadObject(temp, function);
+    __ pushq(temp);
+    compiler->GenerateCallRuntime(AstNode::kNoId,
+                                  0,
+                                  CatchClauseNode::kInvalidTryIndex,
+                                  kTraceFunctionExitRuntimeEntry);
+    __ popq(temp);  // Remove argument.
+    __ popq(result);  // Restore result.
+  }
+  __ LeaveFrame();
+  __ ret();
+
+  // Generate 8 bytes of NOPs so that the debugger can patch the
+  // return pattern with a call to the debug stub.
+  __ nop(1);
+  __ nop(1);
+  __ nop(1);
+  __ nop(1);
+  __ nop(1);
+  __ nop(1);
+  __ nop(1);
+  __ nop(1);
+  compiler->AddCurrentDescriptor(PcDescriptors::kReturn,
+                                 cid(),
+                                 token_index(),
+                                 CatchClauseNode::kInvalidTryIndex);
 }
 
 
 LocationSummary* CurrentContextComp::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(0, Location::RequiresRegister());
+  return LocationSummary::Make(0, Location::RequiresRegister());
 }
 
 
 void CurrentContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ movq(locs()->out().reg(), CTX);
 }
 
 
 LocationSummary* StoreContextComp::MakeLocationSummary() const {
   LocationSummary* summary = new LocationSummary(1, 0);
   summary->set_in(0, Location::RegisterLocation(CTX));
   return summary;
 }
 
 
 void StoreContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Nothing to do.  Context register were loaded by register allocator.
   ASSERT(locs()->in(0).reg() == CTX);
 }
 
 
 LocationSummary* StrictCompareComp::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(2, Location::SameAsFirstInput());
+  return LocationSummary::Make(2, Location::SameAsFirstInput());
 }
 
 
 void StrictCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   Register result = locs()->out().reg();
@@ skipping 76 matching lines @@
   ASSERT(VerifyCallComputation(this));
   compiler->EmitStaticCall(token_index(),
                            try_index(),
                            function(),
                            ArgumentCount(),
                            argument_names());
 }
 
 
 LocationSummary* LoadLocalComp::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(0, Location::RequiresRegister());
+  return LocationSummary::Make(0, Location::RequiresRegister());
 }
 
 
 void LoadLocalComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out().reg();
   __ movq(result, Address(RBP, local().index() * kWordSize));
 }
 
 
 LocationSummary* StoreLocalComp::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(1, Location::SameAsFirstInput());
+  return LocationSummary::Make(1, Location::SameAsFirstInput());
 }
 
 
 void StoreLocalComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
   ASSERT(result == value);  // Assert that register assignment is correct.
   __ movq(Address(RBP, local().index() * kWordSize), value);
 }
 
 
 LocationSummary* ConstantVal::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(0, Location::RequiresRegister());
+  return LocationSummary::Make(0, Location::RequiresRegister());
 }
 
 
 void ConstantVal::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out().reg();
   if (value().IsSmi()) {
     int64_t imm = reinterpret_cast<int64_t>(value().raw());
     __ movq(result, Immediate(imm));
   } else {
     __ LoadObject(result, value());
@@ skipping 29 matching lines @@
   compiler->GenerateAssertAssignable(cid(),
                                      token_index(),
                                      try_index(),
                                      dst_type(),
                                      dst_name());
   ASSERT(locs()->in(0).reg() == locs()->out().reg());
 }
 
 
 LocationSummary* AssertBooleanComp::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(1, Location::SameAsFirstInput());
+  return LocationSummary::Make(1, Location::SameAsFirstInput());
 }
 
 
 void AssertBooleanComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register obj = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   // Check that the type of the value is allowed in conditional context.
   // Call the runtime if the object is not bool::true or bool::false.
   Label done;
@@ skipping 65 matching lines @@
                              kNumArgumentsChecked);
   __ Bind(&done);
 }
 
 
 LocationSummary* NativeCallComp::MakeLocationSummary() const {
   LocationSummary* locs = new LocationSummary(0, 3);
   locs->set_temp(0, Location::RegisterLocation(RAX));
   locs->set_temp(1, Location::RegisterLocation(RBX));
   locs->set_temp(2, Location::RegisterLocation(R10));
-  locs->set_out(Location::RegisterLocation(RAX));
+  locs->set_out(Location::RequiresRegister());
   return locs;
 }
 
 
 void NativeCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == RAX);
   ASSERT(locs()->temp(1).reg() == RBX);
   ASSERT(locs()->temp(2).reg() == R10);
-  ASSERT(locs()->out().reg() == RAX);
+  Register result = locs()->out().reg();
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   // Pass a pointer to the first argument in RAX.
   if (!has_optional_parameters()) {
     __ leaq(RAX, Address(RBP, (1 + argument_count()) * kWordSize));
   } else {
     __ leaq(RAX,
             Address(RBP, ParsedFunction::kFirstLocalSlotIndex * kWordSize));
   }
   __ movq(RBX, Immediate(reinterpret_cast<uword>(native_c_function())));
   __ movq(R10, Immediate(argument_count()));
   compiler->GenerateCall(token_index(),
                          try_index(),
                          &StubCode::CallNativeCFunctionLabel(),
                          PcDescriptors::kOther);
-  __ popq(RAX);
+  __ popq(result);
 }
 
 
 LocationSummary* StoreIndexedComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
-  return MakeSimpleLocationSummary(kNumInputs, Location::NoLocation());
+  return LocationSummary::Make(kNumInputs, Location::NoLocation());
 }
 
 
 void StoreIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
   Register value = locs()->in(2).reg();
 
   const String& function_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
 
   __ pushq(receiver);
   __ pushq(index);
   __ pushq(value);
   const intptr_t kNumArguments = 3;
   const intptr_t kNumArgsChecked = 1;  // Type-feedback.
   compiler->EmitInstanceCall(cid(),
                              token_index(),
                              try_index(),
                              function_name,
                              kNumArguments,
                              Array::ZoneHandle(),  // No optional arguments.
                              kNumArgsChecked);
 }
 
 
 LocationSummary* InstanceSetterComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
-  return MakeSimpleLocationSummary(kNumInputs, Location::RequiresRegister());
+  return LocationSummary::Make(kNumInputs, Location::RequiresRegister());
   return NULL;
 }
 
 
 void InstanceSetterComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register receiver = locs()->in(0).reg();
   Register value = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   // Preserve the value (second argument) under the arguments as the result
@@ skipping 12 matching lines @@
                              function_name,
                              2,
                              Array::ZoneHandle(),
                              1);
   __ popq(result);
 }
 
 
 LocationSummary* StaticSetterComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
-  return MakeSimpleLocationSummary(kNumInputs, Location::RequiresRegister());
+  return LocationSummary::Make(kNumInputs, Location::RequiresRegister());
 }
 
 
 void StaticSetterComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   // Preserve the argument as the result of the computation,
   // then call the setter.
 
   // Duplicate the argument.
   // TODO(fschneider): Avoid preserving the value if the result is not used.
   __ pushq(value);
   __ pushq(value);
   compiler->EmitStaticCall(token_index(),
                            try_index(),
                            setter_function(),
                            1,
                            Array::ZoneHandle());
   __ popq(result);
 }
 
 
 LocationSummary* LoadInstanceFieldComp::MakeLocationSummary() const {
   // TODO(fschneider): For this instruction the input register may be
   // reused for the result (but is not required to) because the input
   // is not used after the result is defined.  We should consider adding
   // this information to the input policy.
-  return MakeSimpleLocationSummary(1, Location::RequiresRegister());
+  return LocationSummary::Make(1, Location::RequiresRegister());
 }
 
 
 void LoadInstanceFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register instance = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ movq(result, FieldAddress(instance, field().Offset()));
 }
 
 
 LocationSummary* StoreInstanceFieldComp::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(2, Location::RequiresRegister());
+  return LocationSummary::Make(2, Location::RequiresRegister());
 }
 
 
 void StoreInstanceFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(VerifyValues(instance(), value()));
   Register instance = locs()->in(0).reg();
   Register value = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   __ StoreIntoObject(instance, FieldAddress(instance, field().Offset()),
                      value);
   // TODO(fschneider): Consider eliminating this move by specifying a
   // SameAsSecondInput for the result.
   if (result != value) {
     __ movq(result, value);
   }
 }
 
 
 LocationSummary* LoadStaticFieldComp::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(0, Location::RequiresRegister());
+  return LocationSummary::Make(0, Location::RequiresRegister());
 }
 
 
 void LoadStaticFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out().reg();
   __ LoadObject(result, field());
   __ movq(result, FieldAddress(result, Field::value_offset()));
 }
 
 
@@ skipping 10 matching lines @@
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   ASSERT(locs()->out().reg() == value);
 
   __ LoadObject(temp, field());
   __ StoreIntoObject(temp, FieldAddress(temp, Field::value_offset()), value);
 }
 
 
 LocationSummary* BooleanNegateComp::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(1, Location::RequiresRegister());
+  return LocationSummary::Make(1, Location::RequiresRegister());
 }
 
 
 void BooleanNegateComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   Label done;
@@ skipping 103 matching lines @@
   compiler->GenerateCall(token_index(),
                          try_index(),
                          &label,
                          PcDescriptors::kOther);
   __ Drop(arguments().length());  // Discard arguments.
 }
 
 
 LocationSummary* AllocateObjectWithBoundsCheckComp::
     MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(2, Location::RequiresRegister());
+  return LocationSummary::Make(2, Location::RequiresRegister());
 }
 
 
 void AllocateObjectWithBoundsCheckComp::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   const Class& cls = Class::ZoneHandle(constructor().owner());
   Register type_arguments = locs()->in(0).reg();
   Register instantiator_type_arguments = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   __ pushq(Immediate(Smi::RawValue(token_index())));
   __ PushObject(cls);
   __ pushq(type_arguments);
   __ pushq(instantiator_type_arguments);
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kAllocateObjectWithBoundsCheckRuntimeEntry);
   // Pop instantiator type arguments, type arguments, class, and
   // source location.
   __ Drop(4);
   __ popq(result);  // Pop new instance.
 }
 
 
 LocationSummary* LoadVMFieldComp::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(1, Location::RequiresRegister());
+  return LocationSummary::Make(1, Location::RequiresRegister());
 }
 
 
 void LoadVMFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register obj = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ movq(result, FieldAddress(obj, offset_in_bytes()));
 }
 
 
 LocationSummary* StoreVMFieldComp::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(2, Location::SameAsFirstInput());
+  return LocationSummary::Make(2, Location::SameAsFirstInput());
 }
 
 
 void StoreVMFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value_reg = locs()->in(0).reg();
   Register dest_reg = locs()->in(1).reg();
   ASSERT(value_reg == locs()->out().reg());
 
   __ StoreIntoObject(dest_reg, FieldAddress(dest_reg, offset_in_bytes()),
                      value_reg);
@@ skipping 207 matching lines @@
   const ExternalLabel label("alloc_context",
                             StubCode::AllocateContextEntryPoint());
   compiler->GenerateCall(token_index(),
                          try_index(),
                          &label,
                          PcDescriptors::kOther);
 }
 
 
 LocationSummary* ChainContextComp::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(1, Location::NoLocation());
+  return LocationSummary::Make(1, Location::NoLocation());
 }
 
 
 void ChainContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register context_value = locs()->in(0).reg();
 
   // Chain the new context in context_value to its parent in CTX.
   __ StoreIntoObject(context_value,
                      FieldAddress(context_value, Context::parent_offset()),
                      CTX);
   // Set new context as current context.
   __ movq(CTX, context_value);
 }
 
 
 LocationSummary* CloneContextComp::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(1, Location::RequiresRegister());
+  return LocationSummary::Make(1, Location::RequiresRegister());
 }
 
 
 void CloneContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register context_value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ pushq(context_value);
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kCloneContextRuntimeEntry);
   __ popq(result);  // Remove argument.
   __ popq(result);  // Get result (cloned context).
 }
 
 
 LocationSummary* CatchEntryComp::MakeLocationSummary() const {
-  return MakeSimpleLocationSummary(0, Location::NoLocation());
+  return LocationSummary::Make(0, Location::NoLocation());
 }
 
 
 // Restore stack and initialize the two exception variables:
 // exception and stack trace variables.
 void CatchEntryComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Restore RSP from RBP as we are coming from a throw and the code for
   // popping arguments has not been run.
   const intptr_t locals_space_size = compiler->StackSize() * kWordSize;
   ASSERT(locals_space_size >= 0);
@@ skipping 214 matching lines @@
   if (locs()->out().reg() != RAX) {
     __ movq(locs()->out().reg(), RAX);
   }
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64