Build and use stack maps in the SSA compiler.

runtime/vm/intermediate_language_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 73 matching lines @@
   }
   if (FLAG_trace_functions) {
     const Function& function =
         Function::ZoneHandle(compiler->parsed_function().function().raw());
     __ LoadObject(temp, function);
     __ pushl(result);  // Preserve result.
     __ pushl(temp);
     compiler->GenerateCallRuntime(Isolate::kNoDeoptId,
                                   0,
                                   CatchClauseNode::kInvalidTryIndex,
-                                  kTraceFunctionExitRuntimeEntry);
+                                  kTraceFunctionExitRuntimeEntry,
+                                  locs()->stack_bitmap());

[Vyacheslav Egorov (Google), 2012/08/13 12:54:46]

ReturnInstr is marked as NoCall. This code is suspicious.

[Kevin Millikin (Google), 2012/08/13 15:10:37]

I know.  We really don't want it to be a call because it's pointless to do any
work spilling before return.  Let's see if we can defer the call in the same way
as we plan to do with the stack check.

     __ popl(temp);  // Remove argument.
     __ popl(result);  // Restore result.
   }
 #if defined(DEBUG)
   // TODO(srdjan): Fix for functions with finally clause.
   // A finally clause may leave a previously pushed return value if it
   // has its own return instruction. Method that have finally are currently
   // not optimized.
   if (!compiler->HasFinally()) {
     Label done;
@@ skipping 104 matching lines @@
   Label done;
   __ CompareObject(obj, compiler->bool_true());
   __ j(EQUAL, &done, Assembler::kNearJump);
   __ CompareObject(obj, compiler->bool_false());
   __ j(EQUAL, &done, Assembler::kNearJump);
 
   __ pushl(obj);  // Push the source object.
   compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
-                                kConditionTypeErrorRuntimeEntry);
+                                kConditionTypeErrorRuntimeEntry,
+                                locs()->stack_bitmap());
   // We should never return here.
   __ int3();
 
   __ Bind(&done);
   ASSERT(obj == result);
 }
 
 
 static Condition TokenKindToSmiCondition(Token::Kind kind) {
   switch (kind) {
@@ skipping 54 matching lines @@
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 2;
 
   compiler->GenerateInstanceCall(comp->deopt_id(),
                                  comp->token_pos(),
                                  comp->try_index(),
                                  operator_name,
                                  kNumberOfArguments,
                                  kNoArgumentNames,
-                                 kNumArgumentsChecked);
+                                 kNumArgumentsChecked,
+                                 comp->locs()->stack_bitmap());
   ASSERT(comp->locs()->out().reg() == EAX);
   if (comp->kind() == Token::kNE) {
     Label done, false_label;
     __ CompareObject(EAX, compiler->bool_true());
     __ j(EQUAL, &false_label, Assembler::kNearJump);
     __ LoadObject(EAX, compiler->bool_true());
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&false_label);
     __ LoadObject(EAX, compiler->bool_false());
     __ Bind(&done);
   }
 }
 
 
 static void EmitEqualityAsPolymorphicCall(FlowGraphCompiler* compiler,
                                           const ICData& orig_ic_data,
                                           const LocationSummary& locs,
                                           BranchInstr* branch,
                                           Token::Kind kind,
                                           intptr_t deopt_id,
                                           intptr_t token_pos,
-                                          intptr_t try_index) {
+                                          intptr_t try_index,
+                                          BitmapBuilder* stack_bitmap) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   const ICData& ic_data = ICData::Handle(orig_ic_data.AsUnaryClassChecks());
   ASSERT(ic_data.NumberOfChecks() > 0);
   ASSERT(ic_data.num_args_tested() == 1);
   Label* deopt = compiler->AddDeoptStub(deopt_id, try_index, kDeoptEquality);
   Register left = locs.in(0).reg();
   Register right = locs.in(1).reg();
   __ testl(left, Immediate(kSmiTagMask));
   Register temp = locs.temp(0).reg();
   if (ic_data.GetReceiverClassIdAt(0) == kSmiCid) {
@@ skipping 34 matching lines @@
         __ LoadObject(result, compiler->bool_true());
       }
     } else {
       const int kNumberOfArguments = 2;
       const Array& kNoArgumentNames = Array::Handle();
       compiler->GenerateStaticCall(deopt_id,
                                    token_pos,
                                    try_index,
                                    target,
                                    kNumberOfArguments,
-                                   kNoArgumentNames);
+                                   kNoArgumentNames,
+                                   stack_bitmap);
       if (branch == NULL) {
         if (kind == Token::kNE) {
           Label false_label;
           __ CompareObject(EAX, compiler->bool_true());
           __ j(EQUAL, &false_label, Assembler::kNearJump);
           __ LoadObject(EAX, compiler->bool_true());
           __ jmp(&done);
           __ Bind(&false_label);
           __ LoadObject(EAX, compiler->bool_false());
           __ jmp(&done);
@@ skipping 44 matching lines @@
     __ LoadObject(result, compiler->bool_false());
     __ jmp(&done);
     __ Bind(&load_true);
     __ LoadObject(result, compiler->bool_true());
   }
   __ jmp(&done);
   __ Bind(&non_null_compare);  // Receiver is not null.
   __ pushl(left);
   __ pushl(right);
   EmitEqualityAsPolymorphicCall(compiler, ic_data, locs, branch, kind,
-                                deopt_id, token_pos, try_index);
+                                deopt_id, token_pos, try_index,
+                                locs.stack_bitmap());
   __ Bind(&done);
 }
 
 
 static void EmitSmiComparisonOp(FlowGraphCompiler* compiler,
                                 const LocationSummary& locs,
                                 Token::Kind kind,
                                 BranchInstr* branch,
                                 intptr_t deopt_id,
                                 intptr_t token_pos,
@@ skipping 140 matching lines @@
     __ LoadClassId(EDI, EAX);
     __ Bind(&done);
     compiler->EmitTestAndCall(ICData::Handle(ic_data()->AsUnaryClassChecks()),
                               EDI,  // Class id register.
                               kNumArguments,
                               Array::Handle(),  // No named arguments.
                               deopt,  // Deoptimize target.
                               NULL,   // Fallthrough when done.
                               deopt_id(),
                               token_pos(),
-                              try_index());
+                              try_index(),
+                              locs()->stack_bitmap());
     return;
   }
   const String& function_name =
       String::ZoneHandle(Symbols::New(Token::Str(kind())));
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                  deopt_id(),
                                  token_pos(),
                                  try_index());
   const intptr_t kNumArguments = 2;
   const intptr_t kNumArgsChecked = 2;  // Type-feedback.
   compiler->GenerateInstanceCall(deopt_id(),
                                  token_pos(),
                                  try_index(),
                                  function_name,
                                  kNumArguments,
                                  Array::ZoneHandle(),  // No optional arguments.
-                                 kNumArgsChecked);
+                                 kNumArgsChecked,
+                                 locs()->stack_bitmap());
   ASSERT(locs()->out().reg() == EAX);
 }
 
 
 LocationSummary* NativeCallComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 3;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_temp(0, Location::RegisterLocation(EAX));
@@ skipping 21 matching lines @@
     __ leal(EAX, Address(EBP, (1 + arg_count) * kWordSize));
   } else {
     __ leal(EAX,
             Address(EBP, ParsedFunction::kFirstLocalSlotIndex * kWordSize));
   }
   __ movl(ECX, Immediate(reinterpret_cast<uword>(native_c_function())));
   __ movl(EDX, Immediate(arg_count));
   compiler->GenerateCall(token_pos(),
                          try_index(),
                          &StubCode::CallNativeCFunctionLabel(),
-                         PcDescriptors::kOther);
+                         PcDescriptors::kOther,
+                         locs()->stack_bitmap());
   __ popl(result);
 }
 
 
 LocationSummary* LoadIndexedComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if ((receiver_type() == kGrowableObjectArrayCid) ||
       (receiver_type() == kArrayCid) ||
       (receiver_type() == kImmutableArrayCid)) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
   } else {
     ASSERT(receiver_type() == kIllegalCid);
     return MakeCallSummary();
   }
 }
 
 
 static void EmitLoadIndexedPolymorphic(FlowGraphCompiler* compiler,
-                                        LoadIndexedComp* comp) {
+                                       LoadIndexedComp* comp) {
   Label* deopt = compiler->AddDeoptStub(comp->deopt_id(),
                                         comp->try_index(),
                                         kDeoptLoadIndexedPolymorphic);
   ASSERT(comp->ic_data()->NumberOfChecks() > 0);
   ASSERT(comp->HasICData());
   const ICData& ic_data = *comp->ic_data();
   ASSERT(ic_data.num_args_tested() == 1);
   // No indexed access on Smi.
   ASSERT(ic_data.GetReceiverClassIdAt(0) != kSmiCid);
   // Load receiver into EAX.
   const intptr_t kNumArguments = 2;
   __ movl(EAX, Address(ESP, (kNumArguments - 1) * kWordSize));
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
   __ LoadClassId(EDI, EAX);
   compiler->EmitTestAndCall(ic_data,
                             EDI,  // Class id register.
                             kNumArguments,
                             Array::Handle(),  // No named arguments.
                             deopt,  // Deoptimize target.
                             NULL,   // Fallthrough when done.
                             comp->deopt_id(),
                             comp->token_pos(),
-                            comp->try_index());
+                            comp->try_index(),
+                            comp->locs()->stack_bitmap());
 }
 
 
 void LoadIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (receiver_type() == kIllegalCid) {
     if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
       EmitLoadIndexedPolymorphic(compiler, this);
     } else {
       compiler->EmitLoadIndexedGeneric(this);
     }
@@ skipping 85 matching lines @@
                                  comp->try_index());
 
   const intptr_t kNumArguments = 3;
   const intptr_t kNumArgsChecked = 1;  // Type-feedback.
   compiler->GenerateInstanceCall(comp->deopt_id(),
                                  comp->token_pos(),
                                  comp->try_index(),
                                  function_name,
                                  kNumArguments,
                                  Array::ZoneHandle(),  // No named arguments.
-                                 kNumArgsChecked);
+                                 kNumArgsChecked,
+                                 comp->locs()->stack_bitmap());
 }
 
 
 static void EmitStoreIndexedPolymorphic(FlowGraphCompiler* compiler,
                                         StoreIndexedComp* comp) {
   Label* deopt = compiler->AddDeoptStub(comp->deopt_id(),
                                         comp->try_index(),
                                         kDeoptStoreIndexedPolymorphic);
   ASSERT(comp->ic_data()->NumberOfChecks() > 0);
   ASSERT(comp->HasICData());
   const ICData& ic_data = *comp->ic_data();
   ASSERT(ic_data.num_args_tested() == 1);
   // No indexed access on Smi.
   ASSERT(ic_data.GetReceiverClassIdAt(0) != kSmiCid);
   // Load receiver into EAX.
   const intptr_t kNumArguments = 3;
   __ movl(EAX, Address(ESP, (kNumArguments - 1) * kWordSize));
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
   __ LoadClassId(EDI, EAX);
   compiler->EmitTestAndCall(ic_data,
                             EDI,  // Class id register.
                             kNumArguments,
                             Array::Handle(),  // No named arguments.
                             deopt,  // Deoptimize target.
                             NULL,   // Fallthrough when done.
                             comp->deopt_id(),
                             comp->token_pos(),
-                            comp->try_index());
+                            comp->try_index(),
+                            comp->locs()->stack_bitmap());
 }
 
 
 void StoreIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (receiver_type() == kIllegalCid) {
     if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
       EmitStoreIndexedPolymorphic(compiler, this);
     } else {
       EmitStoreIndexedGeneric(compiler, this);
     }
@@ skipping 112 matching lines @@
 
 void InstanceOfComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->in(0).reg() == EAX);  // Value.
   ASSERT(locs()->in(1).reg() == ECX);  // Instantiator.
   ASSERT(locs()->in(2).reg() == EDX);  // Instantiator type arguments.
 
   compiler->GenerateInstanceOf(deopt_id(),
                                token_pos(),
                                try_index(),
                                type(),
-                               negate_result());
+                               negate_result(),
+                               locs()->stack_bitmap());
   ASSERT(locs()->out().reg() == EAX);
 }
 
 
 LocationSummary* CreateArrayComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(ECX));
   locs->set_out(Location::RegisterLocation(EAX));
   return locs;
 }
 
 
 void CreateArrayComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Allocate the array.  EDX = length, ECX = element type.
   ASSERT(locs()->in(0).reg() == ECX);
   __ movl(EDX,  Immediate(Smi::RawValue(ElementCount())));
   compiler->GenerateCall(token_pos(),
                          try_index(),
                          &StubCode::AllocateArrayLabel(),
-                         PcDescriptors::kOther);
+                         PcDescriptors::kOther,
+                         locs()->stack_bitmap());
   ASSERT(locs()->out().reg() == EAX);
 
   // Pop the element values from the stack into the array.
   __ leal(EDX, FieldAddress(EAX, Array::data_offset()));
   for (int i = ElementCount() - 1; i >= 0; --i) {
     ASSERT(ElementAt(i)->IsUse());
     __ popl(Address(EDX, i * kWordSize));
   }
 }
 
@@ skipping 19 matching lines @@
   Register result = locs()->out().reg();
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   __ PushObject(cls);
   __ pushl(type_arguments);
   __ pushl(instantiator_type_arguments);
   compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
-                                kAllocateObjectWithBoundsCheckRuntimeEntry);
+                                kAllocateObjectWithBoundsCheckRuntimeEntry,
+                                locs()->stack_bitmap());
   // Pop instantiator type arguments, type arguments, and class.
   // source location.
   __ Drop(3);
   __ popl(result);  // Pop new instance.
 }
 
 
 LocationSummary* LoadVMFieldComp::MakeLocationSummary() const {
   return LocationSummary::Make(1,
                                Location::RequiresRegister(),
@@ skipping 67 matching lines @@
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
     __ Bind(&type_arguments_uninstantiated);
   }
   // A runtime call to instantiate the type arguments is required.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ PushObject(type_arguments());
   __ pushl(instantiator_reg);  // Push instantiator type arguments.
   compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
-                                kInstantiateTypeArgumentsRuntimeEntry);
+                                kInstantiateTypeArgumentsRuntimeEntry,
+                                locs()->stack_bitmap());
   __ Drop(2);  // Drop instantiator and uninstantiated type arguments.
   __ popl(result_reg);  // Pop instantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   ASSERT(instantiator_reg == result_reg);
   // 'result_reg': Instantiated type arguments.
 }
 
 
 LocationSummary*
     ExtractConstructorTypeArgumentsComp::MakeLocationSummary() const {
@@ skipping 135 matching lines @@
 void AllocateContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == EDX);
   ASSERT(locs()->out().reg() == EAX);
 
   __ movl(EDX, Immediate(num_context_variables()));
   const ExternalLabel label("alloc_context",
                             StubCode::AllocateContextEntryPoint());
   compiler->GenerateCall(token_pos(),
                          try_index(),
                          &label,
-                         PcDescriptors::kOther);
+                         PcDescriptors::kOther,
+                         locs()->stack_bitmap());
 }
 
 
 LocationSummary* CloneContextComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(EAX));
   locs->set_out(Location::RegisterLocation(EAX));
   return locs;
 }
 
 
 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.
   __ pushl(context_value);
   compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
-                                kCloneContextRuntimeEntry);
+                                kCloneContextRuntimeEntry,
+                                locs()->stack_bitmap());
   __ popl(result);  // Remove argument.
   __ popl(result);  // Get result (cloned context).
 }
 
 
 LocationSummary* CatchEntryComp::MakeLocationSummary() const {
   return LocationSummary::Make(0,
                                Location::NoLocation(),
                                LocationSummary::kNoCall);
 }
@@ skipping 30 matching lines @@
 
 
 void CheckStackOverflowComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ cmpl(ESP,
           Address::Absolute(Isolate::Current()->stack_limit_address()));
   Label no_stack_overflow;
   __ j(ABOVE, &no_stack_overflow);
   compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
-                                kStackOverflowRuntimeEntry);
+                                kStackOverflowRuntimeEntry,
+                                locs()->stack_bitmap());
   __ Bind(&no_stack_overflow);
 }
 
 
 LocationSummary* BinaryOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
 
   // Double operation are handled in DoubleBinaryOpComp.
   ASSERT(operands_type() != kDoubleOperands);
 
@@ skipping 165 matching lines @@
       __ shll(left, right_temp);
       __ jmp(&done);
       {
         __ Bind(&call_method);
         Function& target = Function::ZoneHandle(
             comp->ic_data()->GetTargetForReceiverClassId(kSmiCid));
         ASSERT(!target.IsNull());
         const intptr_t kArgumentCount = 2;
         __ pushl(temp);
         __ pushl(right);
-        compiler->GenerateStaticCall(comp->instance_call()->deopt_id(),
-                                     comp->instance_call()->token_pos(),
-                                     comp->instance_call()->try_index(),
-                                     target,
-                                     kArgumentCount,
-                                     Array::Handle());  // No argument names.
+        compiler->GenerateStaticCall(
+            comp->instance_call()->deopt_id(),
+            comp->instance_call()->token_pos(),
+            comp->instance_call()->try_index(),
+            target,
+            kArgumentCount,
+            Array::Handle(),  // No argument names.
+            comp->locs()->stack_bitmap());
         ASSERT(result == EAX);
       }
       __ Bind(&done);
       break;
     }
     case Token::kDIV: {
       // Dispatches to 'Double./'.
       // TODO(srdjan): Implement as conversion to double and double division.
       UNREACHABLE();
       break;
@@ skipping 68 matching lines @@
 
   __ Bind(&smi_static_call);
   {
     Function& target = Function::ZoneHandle(
         comp->ic_data()->GetTargetForReceiverClassId(kSmiCid));
     if (target.IsNull()) {
       __ jmp(deopt);
     } else {
       __ pushl(left);
       __ pushl(right);
-      compiler->GenerateStaticCall(comp->instance_call()->deopt_id(),
-                                   comp->instance_call()->token_pos(),
-                                   comp->instance_call()->try_index(),
-                                   target,
-                                   comp->instance_call()->ArgumentCount(),
-                                   comp->instance_call()->argument_names());
+      compiler->GenerateStaticCall(
+          comp->instance_call()->deopt_id(),
+          comp->instance_call()->token_pos(),
+          comp->instance_call()->try_index(),
+          target,
+          comp->instance_call()->ArgumentCount(),
+          comp->instance_call()->argument_names(),
+          comp->locs()->stack_bitmap());
       ASSERT(result == EAX);
       __ jmp(&done);
     }
   }
 
   __ Bind(&mint_static_call);
   {
     Function& target = Function::ZoneHandle(
         comp->ic_data()->GetTargetForReceiverClassId(kMintCid));
     if (target.IsNull()) {
       __ jmp(deopt);
     } else {
       __ pushl(left);
       __ pushl(right);
-      compiler->GenerateStaticCall(comp->instance_call()->deopt_id(),
-                                   comp->instance_call()->token_pos(),
-                                   comp->instance_call()->try_index(),
-                                   target,
-                                   comp->instance_call()->ArgumentCount(),
-                                   comp->instance_call()->argument_names());
+      compiler->GenerateStaticCall(
+          comp->instance_call()->deopt_id(),
+          comp->instance_call()->token_pos(),
+          comp->instance_call()->try_index(),
+          target,
+          comp->instance_call()->ArgumentCount(),
+          comp->instance_call()->argument_names(),
+          comp->locs()->stack_bitmap());
       ASSERT(result == EAX);
     }
   }
   __ Bind(&done);
 }
 
 
 void BinaryOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   switch (operands_type()) {
     case kSmiOperands:
@@ skipping 21 matching lines @@
   Register temp = EDX;
   Register result = locs()->out().reg();
 
   const Class& double_class = compiler->double_class();
   const Code& stub =
     Code::Handle(StubCode::GetAllocationStubForClass(double_class));
   const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(instance_call()->token_pos(),
                          instance_call()->try_index(),
                          &label,
-                         PcDescriptors::kOther);
+                         PcDescriptors::kOther,
+                         locs()->stack_bitmap());
   // Newly allocated object is now in the result register (RAX).
   ASSERT(result == EAX);
   __ popl(right);
   __ popl(left);
 
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                         instance_call()->try_index(),
                                         kDeoptDoubleBinaryOp,
                                         left,
                                         right);
@@ skipping 106 matching lines @@
     __ j(NOT_EQUAL, deopt);
     // Allocate result object.
     const Class& double_class = compiler->double_class();
     const Code& stub =
         Code::Handle(StubCode::GetAllocationStubForClass(double_class));
     const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
     __ pushl(value);
     compiler->GenerateCall(instance_call()->token_pos(),
                            instance_call()->try_index(),
                            &label,
-                           PcDescriptors::kOther);
+                           PcDescriptors::kOther,
+                           locs()->stack_bitmap());
     // Result is in EAX.
     ASSERT(result != temp);
     __ movl(result, EAX);
     __ popl(temp);
     __ movsd(XMM0, FieldAddress(temp, Double::value_offset()));
     __ DoubleNegate(XMM0);
     __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
   } else {
     UNREACHABLE();
   }
@@ skipping 43 matching lines @@
 
   const Class& double_class = compiler->double_class();
   const Code& stub =
     Code::Handle(StubCode::GetAllocationStubForClass(double_class));
   const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
 
   // TODO(vegorov): allocate box in the driver loop to avoid spilling.
   compiler->GenerateCall(instance_call()->token_pos(),
                          instance_call()->try_index(),
                          &label,
-                         PcDescriptors::kOther);
+                         PcDescriptors::kOther,
+                         locs()->stack_bitmap());
   ASSERT(result == EAX);
   __ popl(value);
 
   __ testl(value, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);  // Deoptimize if not Smi.
   __ SmiUntag(value);
   __ cvtsi2sd(XMM0, value);
   __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
 }
 
@@ skipping 25 matching lines @@
   Label done;
   __ LoadClassId(EDI, EAX);
   compiler->EmitTestAndCall(*ic_data(),
                             EDI,  // Class id register.
                             instance_call()->ArgumentCount(),
                             instance_call()->argument_names(),
                             deopt,
                             (is_smi_label == &handle_smi) ? &done : NULL,
                             instance_call()->deopt_id(),
                             instance_call()->token_pos(),
-                            instance_call()->try_index());
+                            instance_call()->try_index(),
+                            locs()->stack_bitmap());
   if (is_smi_label == &handle_smi) {
     __ Bind(&handle_smi);
     ASSERT(ic_data()->GetReceiverClassIdAt(0) == kSmiCid);
     const Function& target = Function::ZoneHandle(ic_data()->GetTargetAt(0));
     compiler->GenerateStaticCall(instance_call()->deopt_id(),
                                  instance_call()->token_pos(),
                                  instance_call()->try_index(),
                                  target,
                                  instance_call()->ArgumentCount(),
-                                 instance_call()->argument_names());
+                                 instance_call()->argument_names(),
+                                 locs()->stack_bitmap());
   }
   __ Bind(&done);
 }
 
 
 // TODO(srdjan): Move to shared.
 static bool ICDataWithBothClassIds(const ICData& ic_data, intptr_t class_id) {
   if (ic_data.num_args_tested() != 2) return false;
   if (ic_data.NumberOfChecks() != 1) return false;
   Function& target = Function::Handle();
@@ skipping 81 matching lines @@
                                  token_pos(),
                                  try_index());
   const intptr_t kNumArguments = 2;
   const intptr_t kNumArgsChecked = 2;  // Type-feedback.
   compiler->GenerateInstanceCall(deopt_id(),
                                  token_pos(),
                                  try_index(),
                                  function_name,
                                  kNumArguments,
                                  Array::ZoneHandle(),  // No optional arguments.
-                                 kNumArgsChecked);
+                                 kNumArgsChecked,
+                                 locs()->stack_bitmap());
   ASSERT(locs()->out().reg() == EAX);
   __ CompareObject(locs()->out().reg(), compiler->bool_true());
   EmitBranchOnCondition(compiler, branch_condition);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64