Use the location summary to represent safepoint information.

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 "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 206 matching lines @@
     __ CompareObject(obj, compiler->bool_true());
     __ j(EQUAL, &done, Assembler::kNearJump);
     __ CompareObject(obj, compiler->bool_false());
     __ j(EQUAL, &done, Assembler::kNearJump);
 
     __ pushq(obj);  // Push the source object.
     compiler->GenerateCallRuntime(deopt_id(),
                                   token_pos(),
                                   try_index(),
                                   kConditionTypeErrorRuntimeEntry,
-                                  locs()->stack_bitmap());
+                                  locs());
     // We should never return here.
     __ int3();
     __ Bind(&done);
   }
   ASSERT(obj == result);
 }
 
 
 static Condition TokenKindToSmiCondition(Token::Kind kind) {
   switch (kind) {
@@ skipping 44 matching lines @@
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 static void EmitEqualityAsInstanceCall(FlowGraphCompiler* compiler,
                                        intptr_t deopt_id,
                                        intptr_t token_pos,
                                        intptr_t try_index,
                                        Token::Kind kind,
-                                       const LocationSummary& locs) {
+                                       LocationSummary* locs) {
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                  deopt_id,
                                  token_pos,
                                  try_index);
   const String& operator_name = String::ZoneHandle(Symbols::New("=="));
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 2;
 
   Label done, false_label, true_label;
-  Register left = locs.in(0).reg();
-  Register right = locs.in(1).reg();
+  Register left = locs->in(0).reg();
+  Register right = locs->in(1).reg();
   __ popq(right);
   __ popq(left);
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label check_identity, instance_call;
   __ cmpq(right, raw_null);
   __ j(EQUAL, &check_identity, Assembler::kNearJump);
   __ cmpq(left, raw_null);
   __ j(NOT_EQUAL, &instance_call, Assembler::kNearJump);
 
@@ skipping 14 matching lines @@
   __ Bind(&instance_call);
   __ pushq(left);
   __ pushq(right);
   compiler->GenerateInstanceCall(deopt_id,
                                  token_pos,
                                  try_index,
                                  operator_name,
                                  kNumberOfArguments,
                                  kNoArgumentNames,
                                  kNumArgumentsChecked,
-                                 locs.stack_bitmap());
+                                 locs);
   if (kind == Token::kNE) {
     // Negate the condition: true label returns false and vice versa.
     __ CompareObject(RAX, compiler->bool_true());
     __ j(EQUAL, &true_label, Assembler::kNearJump);
     __ Bind(&false_label);
     __ LoadObject(RAX, compiler->bool_true());
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&true_label);
     __ LoadObject(RAX, compiler->bool_false());
   }
   __ Bind(&done);
 }
 
 
 static void EmitEqualityAsPolymorphicCall(FlowGraphCompiler* compiler,
                                           const ICData& orig_ic_data,
-                                          const LocationSummary& locs,
+                                          LocationSummary* locs,
                                           BranchInstr* branch,
                                           Token::Kind kind,
                                           intptr_t deopt_id,
                                           intptr_t token_pos,
-                                          intptr_t try_index,
-                                          BitmapBuilder* stack_bitmap) {
+                                          intptr_t try_index) {
   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();
+  Register left = locs->in(0).reg();
+  Register right = locs->in(1).reg();
   __ testq(left, Immediate(kSmiTagMask));
-  Register temp = locs.temp(0).reg();
+  Register temp = locs->temp(0).reg();
   if (ic_data.GetReceiverClassIdAt(0) == kSmiCid) {
     Label done, load_class_id;
     __ j(NOT_ZERO, &load_class_id, Assembler::kNearJump);
     __ movq(temp, Immediate(kSmiCid));
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&load_class_id);
     __ LoadClassId(temp, left);
     __ Bind(&done);
   } else {
     __ j(ZERO, deopt);  // Smi deopts.
@@ skipping 11 matching lines @@
     __ j(NOT_EQUAL, &next_test);
     const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(i));
     if (target.Owner() == object_store->object_class()) {
       // Object.== is same as ===.
       __ Drop(2);
       __ cmpq(left, right);
       if (branch != NULL) {
         branch->EmitBranchOnCondition(compiler, cond);
       } else {
         // This case should be rare.
-        Register result = locs.out().reg();
+        Register result = locs->out().reg();
         Label load_true;
         __ j(cond, &load_true, Assembler::kNearJump);
         __ LoadObject(result, compiler->bool_false());
         __ jmp(&done);
         __ Bind(&load_true);
         __ 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,
-                                   stack_bitmap);
+                                   locs);
       if (branch == NULL) {
         if (kind == Token::kNE) {
           Label false_label;
           __ CompareObject(RAX, compiler->bool_true());
           __ j(EQUAL, &false_label, Assembler::kNearJump);
           __ LoadObject(RAX, compiler->bool_true());
           __ jmp(&done);
           __ Bind(&false_label);
           __ LoadObject(RAX, compiler->bool_false());
           __ jmp(&done);
@@ skipping 66 matching lines @@
     Condition cond = TokenKindToSmiCondition(kind);
     branch->EmitBranchOnCondition(compiler, cond);
   }
 }
 
 
 // First test if receiver is NULL, in which case === is applied.
 // If type feedback was provided (lists of <class-id, target>), do a
 // type by type check (either === or static call to the operator.
 static void EmitGenericEqualityCompare(FlowGraphCompiler* compiler,
-                                       const LocationSummary& locs,
+                                       LocationSummary* locs,
                                        Token::Kind kind,
                                        BranchInstr* branch,
                                        const ICData& ic_data,
                                        intptr_t deopt_id,
                                        intptr_t token_pos,
                                        intptr_t try_index) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   ASSERT(!ic_data.IsNull() && (ic_data.NumberOfChecks() > 0));
-  Register left = locs.in(0).reg();
-  Register right = locs.in(1).reg();
+  Register left = locs->in(0).reg();
+  Register right = locs->in(1).reg();
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label done, identity_compare, non_null_compare;
   __ cmpq(right, raw_null);
   __ j(EQUAL, &identity_compare, Assembler::kNearJump);
   __ cmpq(left, raw_null);
   __ j(NOT_EQUAL, &non_null_compare, Assembler::kNearJump);
   // Comparison with NULL is "===".
   __ Bind(&identity_compare);
   __ cmpq(left, right);
   Condition cond = TokenKindToSmiCondition(kind);
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, cond);
   } else {
-    Register result = locs.out().reg();
+    Register result = locs->out().reg();
     Label load_true;
     __ j(cond, &load_true, Assembler::kNearJump);
     __ 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.
   __ pushq(left);
   __ pushq(right);
   EmitEqualityAsPolymorphicCall(compiler, ic_data, locs, branch, kind,
-                                deopt_id, token_pos, try_index,
-                                locs.stack_bitmap());
+                                deopt_id, token_pos, try_index);
   __ Bind(&done);
 }
 
 
 static void EmitSmiComparisonOp(FlowGraphCompiler* compiler,
                                 const LocationSummary& locs,
                                 Token::Kind kind,
                                 BranchInstr* branch,
                                 intptr_t deopt_id,
                                 intptr_t token_pos,
@@ skipping 90 matching lines @@
     return;
   }
   const bool is_checked_strict_equal =
       HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid);
   if (is_checked_strict_equal) {
     EmitCheckedStrictEqual(compiler, *ic_data(), *locs(), kind(), NULL,
                            deopt_id(), token_pos(), try_index());
     return;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
-    EmitGenericEqualityCompare(compiler, *locs(), kind(), NULL, *ic_data(),
+    EmitGenericEqualityCompare(compiler, locs(), kind(), NULL, *ic_data(),
                                deopt_id(), token_pos(), try_index());
   } else {
     Register left = locs()->in(0).reg();
     Register right = locs()->in(1).reg();
     __ pushq(left);
     __ pushq(right);
     EmitEqualityAsInstanceCall(compiler,
                                deopt_id(),
                                token_pos(),
                                try_index(),
                                kind(),
-                               *locs());
+                               locs());
     ASSERT(locs()->out().reg() == RAX);
   }
 }
 
 
 LocationSummary* RelationalOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if (operands_class_id() == kSmiCid || operands_class_id() == kDoubleCid) {
     const intptr_t kNumTemps = 1;
     LocationSummary* summary =
@@ skipping 51 matching lines @@
     const intptr_t kNumArguments = 2;
     compiler->EmitTestAndCall(ICData::Handle(ic_data()->AsUnaryClassChecks()),
                               RDI,  // Class id register.
                               kNumArguments,
                               Array::Handle(),  // No named arguments.
                               deopt,  // Deoptimize target.
                               NULL,   // Fallthrough when done.
                               deopt_id(),
                               token_pos(),
                               try_index(),
-                              locs()->stack_bitmap());
+                              locs());
     ASSERT(locs()->out().reg() == RAX);
     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,
-                                 locs()->stack_bitmap());
+                                 locs());
   ASSERT(locs()->out().reg() == RAX);
 }
 
 
 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(RAX));
@@ skipping 22 matching lines @@
   } else {
     __ leaq(RAX,
             Address(RBP, ParsedFunction::kFirstLocalSlotIndex * kWordSize));
   }
   __ movq(RBX, Immediate(reinterpret_cast<uword>(native_c_function())));
   __ movq(R10, Immediate(arg_count));
   compiler->GenerateCall(token_pos(),
                          try_index(),
                          &StubCode::CallNativeCFunctionLabel(),
                          PcDescriptors::kOther,
-                         locs()->stack_bitmap());
+                         locs());
   __ popq(result);
 }
 
 
 LocationSummary* LoadIndexedComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if (receiver_type() == kGrowableObjectArrayCid) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 194 matching lines @@
 void InstanceOfComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->in(0).reg() == RAX);  // Value.
   ASSERT(locs()->in(1).reg() == RCX);  // Instantiator.
   ASSERT(locs()->in(2).reg() == RDX);  // Instantiator type arguments.
 
   compiler->GenerateInstanceOf(deopt_id(),
                                token_pos(),
                                try_index(),
                                type(),
                                negate_result(),
-                               locs()->stack_bitmap());
+                               locs());
   ASSERT(locs()->out().reg() == RAX);
 }
 
 
 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(RBX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void CreateArrayComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Allocate the array.  R10 = length, RBX = element type.
   ASSERT(locs()->in(0).reg() == RBX);
   __ movq(R10, Immediate(Smi::RawValue(ArgumentCount())));
   compiler->GenerateCall(token_pos(),
                          try_index(),
                          &StubCode::AllocateArrayLabel(),
                          PcDescriptors::kOther,
-                         locs()->stack_bitmap());
+                         locs());
   ASSERT(locs()->out().reg() == RAX);
 
   // Pop the element values from the stack into the array.
   __ leaq(R10, FieldAddress(RAX, Array::data_offset()));
   for (int i = ArgumentCount() - 1; i >= 0; --i) {
     ASSERT(ArgumentAt(i)->value()->IsUse());
     __ popq(Address(R10, i * kWordSize));
   }
 }
 
@@ skipping 20 matching lines @@
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   __ PushObject(cls);
   __ pushq(type_arguments);
   __ pushq(instantiator_type_arguments);
   compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
                                 kAllocateObjectWithBoundsCheckRuntimeEntry,
-                                locs()->stack_bitmap());
+                                locs());
   // Pop instantiator type arguments, type arguments, and class.
   __ Drop(3);
   __ popq(result);  // Pop new instance.
 }
 
 
 LocationSummary* LoadVMFieldComp::MakeLocationSummary() const {
   return LocationSummary::Make(1,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
@@ skipping 64 matching lines @@
     __ 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());
   __ pushq(instantiator_reg);  // Push instantiator type arguments.
   compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
                                 kInstantiateTypeArgumentsRuntimeEntry,
-                                locs()->stack_bitmap());
+                                locs());
   __ Drop(2);  // Drop instantiator and uninstantiated type arguments.
   __ popq(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 132 matching lines @@
   ASSERT(locs()->temp(0).reg() == R10);
   ASSERT(locs()->out().reg() == RAX);
 
   __ movq(R10, Immediate(num_context_variables()));
   const ExternalLabel label("alloc_context",
                             StubCode::AllocateContextEntryPoint());
   compiler->GenerateCall(token_pos(),
                          try_index(),
                          &label,
                          PcDescriptors::kOther,
-                         locs()->stack_bitmap());
+                         locs());
 }
 
 
 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(RAX));
   locs->set_out(Location::RegisterLocation(RAX));
   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.
   __ pushq(context_value);
   compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
                                 kCloneContextRuntimeEntry,
-                                locs()->stack_bitmap());
+                                locs());
   __ popq(result);  // Remove argument.
   __ popq(result);  // Get result (cloned context).
 }
 
 
 LocationSummary* CatchEntryComp::MakeLocationSummary() const {
   return LocationSummary::Make(0,
                                Location::NoLocation(),
                                LocationSummary::kNoCall);
 }
@@ skipping 36 matching lines @@
   explicit CheckStackOverflowSlowPath(CheckStackOverflowComp* computation)
       : computation_(computation) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Bind(entry_label());
     compiler->SaveLiveRegisters(computation_->locs());
     compiler->GenerateCallRuntime(computation_->deopt_id(),
                                   computation_->token_pos(),
                                   computation_->try_index(),
                                   kStackOverflowRuntimeEntry,
-                                  computation_->locs()->stack_bitmap());
+                                  computation_->locs());
     compiler->RestoreLiveRegisters(computation_->locs());
     __ jmp(exit_label());
   }
 
  private:
   CheckStackOverflowComp* computation_;
 };
 
 
 void CheckStackOverflowComp::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 172 matching lines @@
         const intptr_t kArgumentCount = 2;
         __ pushq(temp);
         __ pushq(right);
         compiler->GenerateStaticCall(
             instance_call()->deopt_id(),
             instance_call()->token_pos(),
             instance_call()->try_index(),
             target,
             kArgumentCount,
             Array::Handle(),  // No argument names.
-            locs()->stack_bitmap());
+            locs());
         ASSERT(result == RAX);
       }
       __ Bind(&done);
       break;
     }
     case Token::kDIV: {
       // Dispatches to 'Double./'.
       // TODO(srdjan): Implement as conversion to double and double division.
       UNREACHABLE();
       break;
@@ skipping 85 matching lines @@
     } else {
       __ pushq(left);
       __ pushq(right);
       compiler->GenerateStaticCall(
           instance_call()->deopt_id(),
           instance_call()->token_pos(),
           instance_call()->try_index(),
           target,
           instance_call()->ArgumentCount(),
           instance_call()->argument_names(),
-          locs()->stack_bitmap());
+          locs());
       ASSERT(result == RAX);
       __ jmp(&done);
     }
   }
 
   __ Bind(&mint_static_call);
   {
     Function& target = Function::ZoneHandle(
         ic_data()->GetTargetForReceiverClassId(kMintCid));
     if (target.IsNull()) {
       __ jmp(deopt);
     } else {
       __ pushq(left);
       __ pushq(right);
       compiler->GenerateStaticCall(
           instance_call()->deopt_id(),
           instance_call()->token_pos(),
           instance_call()->try_index(),
           target,
           instance_call()->ArgumentCount(),
           instance_call()->argument_names(),
-          locs()->stack_bitmap());
+          locs());
       ASSERT(result == RAX);
     }
   }
   __ Bind(&done);
 }
 
 
 LocationSummary* BinaryDoubleOpComp::MakeLocationSummary() const {
   return MakeCallSummary();  // Calls into a stub for allocation.
 }
 
 
 void BinaryDoubleOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register left = RBX;
   Register right = RCX;
   Register temp = RDX;
   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,
-                         locs()->stack_bitmap());
+                         locs());
   // Newly allocated object is now in the result register (RAX).
   ASSERT(result == RAX);
   __ movq(right, Address(RSP, 0));
   __ movq(left, Address(RSP, kWordSize));
 
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                         instance_call()->try_index(),
                                         kDeoptBinaryDoubleOp);
 
   // Binary operation of two Smi's produces a Smi not a double.
@@ skipping 105 matching lines @@
     // 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());
     __ pushq(value);
     compiler->GenerateCall(instance_call()->token_pos(),
                            instance_call()->try_index(),
                            &label,
                            PcDescriptors::kOther,
-                           instance_call()->locs()->stack_bitmap());
+                           instance_call()->locs());
     // Result is in RAX.
     ASSERT(result != temp);
     __ movq(result, RAX);
     __ popq(temp);
     __ movsd(XMM0, FieldAddress(temp, Double::value_offset()));
     __ DoubleNegate(XMM0);
     __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
   } else {
     UNREACHABLE();
   }
@@ skipping 44 matching lines @@
   const Code& stub =
     Code::Handle(StubCode::GetAllocationStubForClass(double_class));
   const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
 
   // TODO(fschneider): Inline new-space allocation and move the call into
   // deferred code.
   compiler->GenerateCall(instance_call()->token_pos(),
                          instance_call()->try_index(),
                          &label,
                          PcDescriptors::kOther,
-                         locs()->stack_bitmap());
+                         locs());
   ASSERT(result == RAX);
   Register value = RBX;
   // Preserve argument on the stack until after the deoptimization point.
   __ movq(value, Address(RSP, 0));
 
   __ testq(value, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);  // Deoptimize if not Smi.
   __ SmiUntag(value);
   __ cvtsi2sd(XMM0, value);
   __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
@@ skipping 29 matching lines @@
   __ LoadClassId(RDI, RAX);
   compiler->EmitTestAndCall(*ic_data(),
                             RDI,  // 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(),
-                            locs()->stack_bitmap());
+                            locs());
   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(),
-                                 locs()->stack_bitmap());
+                                 locs());
   }
   __ 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 78 matching lines @@
                              deopt_id(), token_pos(), try_index());
       return;
     }
     if (IsCheckedStrictEquals(*ic_data(), kind())) {
       EmitCheckedStrictEqual(compiler, *ic_data(), *locs(), kind(), this,
                              deopt_id(), token_pos(), try_index());
       return;
     }
     // TODO(srdjan): Add Smi/Double, Double/Smi comparisons.
     if ((kind() == Token::kEQ) || (kind() == Token::kNE)) {
-      EmitGenericEqualityCompare(compiler, *locs(), kind(), this, *ic_data(),
+      EmitGenericEqualityCompare(compiler, locs(), kind(), this, *ic_data(),
                                  deopt_id(), token_pos(), try_index());
       return;
     }
     // Otherwise polymorphic dispatch?
   }
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   __ pushq(left);
   __ pushq(right);
   if ((kind() == Token::kNE) || (kind() == Token::kEQ)) {
     EmitEqualityAsInstanceCall(compiler,
                                deopt_id(),
                                token_pos(),
                                try_index(),
                                Token::kEQ,  // kNE reverse occurs at branch.
-                               *locs());
+                               locs());
   } else {
     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 args.
                                    kNumArgsChecked,
-                                   locs()->stack_bitmap());
+                                   locs());
   }
   Condition branch_condition = (kind() == Token::kNE) ? NOT_EQUAL : EQUAL;
   __ CompareObject(RAX, compiler->bool_true());
   EmitBranchOnCondition(compiler, branch_condition);
 }
 
 
 LocationSummary* CheckClassComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
@@ skipping 59 matching lines @@
   __ testq(value, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64