Build and use stack maps in the SSA compiler.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 834 matching lines @@
 LocationSummary* ThrowInstr::MakeLocationSummary() const {
   return new LocationSummary(0, 0, LocationSummary::kCall);
 }
 
 
 
 void ThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
-                                kThrowRuntimeEntry);
+                                kThrowRuntimeEntry,
+                                locs()->stack_bitmap());
   __ int3();
 }
 
 
 LocationSummary* ReThrowInstr::MakeLocationSummary() const {
   return new LocationSummary(0, 0, LocationSummary::kCall);
 }
 
 
 void ReThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
-                                kReThrowRuntimeEntry);
+                                kReThrowRuntimeEntry,
+                                locs()->stack_bitmap());
   __ int3();
 }
 
 
 LocationSummary* GotoInstr::MakeLocationSummary() const {
   return new LocationSummary(0, 0, LocationSummary::kNoCall);
 }
 
 
 void GotoInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 105 matching lines @@
   Register temp_reg = locs()->temp(0).reg();
   int argument_count = ArgumentCount();
   const Array& arguments_descriptor =
       DartEntry::ArgumentsDescriptor(argument_count - 1,
                                          argument_names());
   __ LoadObject(temp_reg, arguments_descriptor);
 
   compiler->GenerateCall(token_pos(),
                          try_index(),
                          &StubCode::CallClosureFunctionLabel(),
-                         PcDescriptors::kOther);
+                         PcDescriptors::kOther,
+                         locs()->stack_bitmap());
   __ Drop(argument_count);
 }
 
 
 LocationSummary* InstanceCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void InstanceCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                  deopt_id(),
                                  token_pos(),
                                  try_index());
   compiler->GenerateInstanceCall(deopt_id(),
                                  token_pos(),
                                  try_index(),
                                  function_name(),
                                  ArgumentCount(),
                                  argument_names(),
-                                 checked_argument_count());
+                                 checked_argument_count(),
+                                 locs()->stack_bitmap());
 }
 
 
 LocationSummary* StaticCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void StaticCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label done;
   if (recognized() == MethodRecognizer::kMathSqrt) {
     compiler->GenerateInlinedMathSqrt(&done);
     // Falls through to static call when operand type is not double or smi.
   }
   compiler->GenerateStaticCall(deopt_id(),
                                token_pos(),
                                try_index(),
                                function(),
                                ArgumentCount(),
-                               argument_names());
+                               argument_names(),
+                               locs()->stack_bitmap());
   __ Bind(&done);
 }
 
 
 LocationSummary* UseVal::MakeLocationSummary() const {
   return NULL;
 }
 
 
 void UseVal::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 
 void AssertAssignableComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (!IsEliminated()) {
     compiler->GenerateAssertAssignable(deopt_id(),
                                        token_pos(),
                                        try_index(),
                                        dst_type(),
-                                       dst_name());
+                                       dst_name(),
+                                       locs()->stack_bitmap());
   }
   ASSERT(locs()->in(0).reg() == locs()->out().reg());
 }
 
 
 LocationSummary* StoreStaticFieldComp::MakeLocationSummary() const {
   LocationSummary* locs = new LocationSummary(1, 1, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
@@ skipping 72 matching lines @@
 }
 
 
 void AllocateObjectComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Class& cls = Class::ZoneHandle(constructor().owner());
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
   const ExternalLabel label(cls.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_pos(),
                          try_index(),
                          &label,
-                         PcDescriptors::kOther);
+                         PcDescriptors::kOther,
+                         locs()->stack_bitmap());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 
 LocationSummary* CreateClosureComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void CreateClosureComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Function& closure_function = function();
   const Code& stub = Code::Handle(
       StubCode::GetAllocationStubForClosure(closure_function));
   const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_pos(), try_index(), &label,
-                         PcDescriptors::kOther);
+                         PcDescriptors::kOther,
+                         locs()->stack_bitmap());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 
 LocationSummary* PushArgumentInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps= 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   // TODO(fschneider): Use Any() once it is supported by all code generators.
@@ skipping 43 matching lines @@
         locations_[i] = Location::NoLocation();
       }
     }
   }
 }
 
 
 #undef __
 
 }  // namespace dart