Remove support for optimized dart leaf functions.

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 "lib/error.h"
@@ skipping 25 matching lines @@
   // Calls do not need stubs, they share a deoptimization trampoline.
   ASSERT(reason() != kDeoptAtCall);
   Assembler* assem = compiler->assembler();
 #define __ assem->
   __ Comment("Deopt stub for id %"Pd"", deopt_id());
   __ Bind(entry_label());
   if (FLAG_trap_on_deoptimization) __ int3();
 
   ASSERT(deoptimization_env() != NULL);
 
-  if (compiler->IsLeaf()) {
-    __ Comment("Leaf method, lazy PC marker setup");
-    // TODO(srdjan): Can we use TMP instead of RAX? We must guarantee that
-    // TMP is never part of deoptimization environment.
-    __ pushq(RAX);  // Preserve RAX.
-    Label L;
-    __ call(&L);
-    const intptr_t offset = assem->CodeSize();
-    __ Bind(&L);
-    __ popq(RAX);
-    __ subq(RAX,
-        Immediate(offset - AssemblerMacros::kOffsetOfSavedPCfromEntrypoint));
-    __ movq(Address(RBP, -kWordSize), RAX);
-    __ popq(RAX);  // Restore RAX.
-  }
   __ call(&StubCode::DeoptimizeLabel());
   set_pc_offset(assem->CodeSize());
   __ int3();
 #undef __
 }
 
 
 #define __ assembler()->
 
 
@@ skipping 753 matching lines @@
   // dropped the spill slots.
   BitmapBuilder* empty_stack_bitmap = new BitmapBuilder();
   if (function.IsClosureFunction()) {
     // We do not use GenerateCallRuntime because of the non-standard (empty)
     // stackmap used here.
     __ CallRuntime(kClosureArgumentMismatchRuntimeEntry);
     AddCurrentDescriptor(PcDescriptors::kOther,
                          Isolate::kNoDeoptId,
                          0);  // No token position.
   } else {
-    ASSERT(!IsLeaf());
     // Invoke noSuchMethod function.
     const int kNumArgsChecked = 1;
     ICData& ic_data = ICData::ZoneHandle();
     ic_data = ICData::New(function,
                           String::Handle(function.name()),
                           Isolate::kNoDeoptId,
                           kNumArgsChecked);
     __ LoadObject(RBX, ic_data);
     // RBP - 8 : PC marker, allows easy identification of RawInstruction obj.
     // RBP : points to previous frame pointer.
@@ skipping 88 matching lines @@
     __ jmp(&StubCode::FixCallersTargetLabel());
     return;
   }
   // Specialized version of entry code from CodeGenerator::GenerateEntryCode.
   const Function& function = parsed_function().function();
 
   const int num_fixed_params = function.num_fixed_parameters();
   const int num_copied_params = parsed_function().num_copied_params();
   const int num_locals = parsed_function().num_stack_locals();
   __ Comment("Enter frame");
-  if (IsLeaf()) {
-    AssemblerMacros::EnterDartLeafFrame(assembler(), (StackSize() * kWordSize));
-  } else {
-    AssemblerMacros::EnterDartFrame(assembler(), (StackSize() * kWordSize));
-  }
+  AssemblerMacros::EnterDartFrame(assembler(), (StackSize() * kWordSize));
 
   // For optimized code, keep a bitmap of the frame in order to build
   // stackmaps for GC safepoints in the prologue.
   LocationSummary* prologue_locs = NULL;
   if (is_optimizing()) {
     // Spill slots are allocated but not initialized.
     prologue_locs = new LocationSummary(0, 0, LocationSummary::kCall);
     prologue_locs->stack_bitmap()->SetLength(StackSize());
   }
 
@@ skipping 84 matching lines @@
                        Isolate::kNoDeoptId,
                        0);  // No token position.
   __ jmp(&StubCode::DeoptimizeLazyLabel());
 }
 
 
 void FlowGraphCompiler::GenerateCall(intptr_t token_pos,
                                      const ExternalLabel* label,
                                      PcDescriptors::Kind kind,
                                      LocationSummary* locs) {
-  ASSERT(!IsLeaf());
   __ call(label);
   AddCurrentDescriptor(kind, Isolate::kNoDeoptId, token_pos);
   RecordSafepoint(locs);
 }
 
 
 void FlowGraphCompiler::GenerateDartCall(intptr_t deopt_id,
                                          intptr_t token_pos,
                                          const ExternalLabel* label,
                                          PcDescriptors::Kind kind,
                                          LocationSummary* locs) {
-  ASSERT(!IsLeaf());
   __ call(label);
   AddCurrentDescriptor(kind, deopt_id, token_pos);
   RecordSafepoint(locs);
   // Marks either the continuation point in unoptimized code or the
   // deoptimization point in optimized code, after call.
   if (is_optimizing()) {
     AddDeoptIndexAtCall(deopt_id, token_pos);
   } else {
     // Add deoptimization continuation point after the call and before the
     // arguments are removed.
     AddCurrentDescriptor(PcDescriptors::kDeoptAfter,
                          deopt_id,
                          token_pos);
   }
 }
 
 
 void FlowGraphCompiler::GenerateCallRuntime(intptr_t token_pos,
                                             const RuntimeEntry& entry,
                                             LocationSummary* locs) {
-  ASSERT(!IsLeaf());
   __ CallRuntime(entry);
   AddCurrentDescriptor(PcDescriptors::kOther, Isolate::kNoDeoptId, token_pos);
   RecordSafepoint(locs);
 }
 
 
 void FlowGraphCompiler::EmitInstanceCall(ExternalLabel* target_label,
                                          const ICData& ic_data,
                                          const Array& arguments_descriptor,
                                          intptr_t argument_count,
                                          intptr_t deopt_id,
                                          intptr_t token_pos,
                                          LocationSummary* locs) {
-  ASSERT(!IsLeaf());
   __ LoadObject(RBX, ic_data);
   __ LoadObject(R10, arguments_descriptor);
   GenerateDartCall(deopt_id,
                    token_pos,
                    target_label,
                    PcDescriptors::kIcCall,
                    locs);
   __ Drop(argument_count);
 }
 
 
 void FlowGraphCompiler::EmitStaticCall(const Function& function,
                                        const Array& arguments_descriptor,
                                        intptr_t argument_count,
                                        intptr_t deopt_id,
                                        intptr_t token_pos,
                                        LocationSummary* locs) {
-  ASSERT(!IsLeaf());
   __ LoadObject(RBX, function);
   __ LoadObject(R10, arguments_descriptor);
   if (function.HasCode()) {
     const Code& code = Code::Handle(function.CurrentCode());
     ExternalLabel target_label(function.ToFullyQualifiedCString(),
                                code.EntryPoint());
     GenerateDartCall(deopt_id,
                      token_pos,
                      &target_label,
                      PcDescriptors::kFuncCall,
@@ skipping 235 matching lines @@
 void ParallelMoveResolver::Exchange(const Address& mem1, const Address& mem2) {
   __ Exchange(mem1, mem2);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64