Remove the default contains_call parameter on location summaries.

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 28 matching lines @@
     // instructions from the graph so we just leave fused comparison in it
     // but change its result location to be NoLocation.
     compiler->frame_register_allocator()->Push(locs()->out().reg(), this);
   }
 }
 
 
 LocationSummary* ReturnInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
-  LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
 }
 
 
 void ReturnInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   ASSERT(result == RAX);
@@ skipping 51 matching lines @@
   compiler->AddCurrentDescriptor(PcDescriptors::kReturn,
                                  cid(),
                                  token_pos(),
                                  CatchClauseNode::kInvalidTryIndex);
 }
 
 
 LocationSummary* ClosureCallComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
-  LocationSummary* result = new LocationSummary(kNumInputs,
-                                                kNumTemps,
-                                                LocationSummary::kCall);
+  LocationSummary* result =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   result->set_out(Location::RegisterLocation(RAX));
   result->set_temp(0, Location::RegisterLocation(R10));  // Arg. descriptor.
   return result;
 }
 
 
 LocationSummary* LoadLocalComp::MakeLocationSummary() const {
-  return LocationSummary::Make(0, Location::RequiresRegister());
+  return LocationSummary::Make(0,
+                               Location::RequiresRegister(),
+                               LocationSummary::kNoCall);
 }
 
 
 void LoadLocalComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out().reg();
   __ movq(result, Address(RBP, local().index() * kWordSize));
 }
 
 
 LocationSummary* StoreLocalComp::MakeLocationSummary() const {
-  return LocationSummary::Make(1, Location::SameAsFirstInput());
+  return LocationSummary::Make(1,
+                               Location::SameAsFirstInput(),
+                               LocationSummary::kNoCall);
 }
 
 
 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 LocationSummary::Make(0, Location::RequiresRegister());
+  return LocationSummary::Make(0,
+                               Location::RequiresRegister(),
+                               LocationSummary::kNoCall);
 }
 
 
 void ConstantVal::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out().reg();
   __ LoadObject(result, value());
 }
 
 
 LocationSummary* AssertAssignableComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 0;
-  LocationSummary* summary = new LocationSummary(kNumInputs,
-                                                 kNumTemps,
-                                                 LocationSummary::kCall);
+  LocationSummary* summary =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   summary->set_in(0, Location::RegisterLocation(RAX));  // Value.
   summary->set_in(1, Location::RegisterLocation(RCX));  // Instantiator.
   summary->set_in(2, Location::RegisterLocation(RDX));  // Type arguments.
   summary->set_out(Location::RegisterLocation(RAX));
   return summary;
 }
 
 
 LocationSummary* AssertBooleanComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
-  LocationSummary* locs = new LocationSummary(kNumInputs,
-                                              kNumTemps,
-                                              LocationSummary::kCall);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void AssertBooleanComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register obj = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
@@ skipping 32 matching lines @@
   }
 }
 
 
 LocationSummary* EqualityCompareComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if (receiver_class_id() != kObject) {
     ASSERT((receiver_class_id() == kSmi) || (receiver_class_id() == kDouble));
     // No temporary register needed for double comparison.
     const intptr_t kNumTemps = (receiver_class_id() == kSmi) ? 1 : 0;
-    LocationSummary* locs = new LocationSummary(kNumInputs,
-                                                kNumTemps,
-                                                LocationSummary::kNoCall);
+    LocationSummary* locs =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     if (receiver_class_id() == kSmi) {
       locs->set_temp(0, Location::RequiresRegister());
     }
     locs->set_out(Location::RequiresRegister());
     return locs;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
     const intptr_t kNumTemps = 1;
-    LocationSummary* locs = new LocationSummary(kNumInputs,
-                                                kNumTemps,
-                                                LocationSummary::kCall);
+    LocationSummary* locs =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
     locs->set_in(0, Location::RegisterLocation(RCX));
     locs->set_in(1, Location::RegisterLocation(RDX));
     locs->set_temp(0, Location::RegisterLocation(RBX));
     locs->set_out(Location::RegisterLocation(RAX));
     return locs;
   }
   const intptr_t kNumTemps = 0;
-  LocationSummary* locs = new LocationSummary(kNumInputs,
-                                              kNumTemps,
-                                              LocationSummary::kCall);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RCX));
   locs->set_in(1, Location::RegisterLocation(RDX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 // Optional integer arguments can often be null. Null is not collected
 // by IC data. TODO(srdjan): Shall we collect null classes in ICData as well?
 static void EmitSmiEqualityCompare(FlowGraphCompiler* compiler,
@@ skipping 233 matching lines @@
     __ pushq(right);
     EmitEqualityAsInstanceCall(compiler, this);
   }
 }
 
 
 LocationSummary* RelationalOpComp::MakeLocationSummary() const {
   if (operands_class_id() == kSmi || operands_class_id() == kDouble) {
     const intptr_t kNumInputs = 2;
     const intptr_t kNumTemps = 1;
-    LocationSummary* summary = new LocationSummary(kNumInputs,
-                                                   kNumTemps);
+    LocationSummary* summary =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RequiresRegister());
     summary->set_out(Location::RequiresRegister());
     summary->set_temp(0, Location::RequiresRegister());
     return summary;
   }
   ASSERT(operands_class_id() == kObject);
   return MakeCallSummary();
 }
 
@@ skipping 134 matching lines @@
                                  kNumArguments,
                                  Array::ZoneHandle(),  // No optional arguments.
                                  kNumArgsChecked);
   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);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   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));
   return locs;
 }
 
 
 void NativeCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == RAX);
@@ skipping 21 matching lines @@
                          &StubCode::CallNativeCFunctionLabel(),
                          PcDescriptors::kOther);
   __ popq(result);
 }
 
 
 LocationSummary* LoadIndexedComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if (receiver_type() == kGrowableObjectArray) {
     const intptr_t kNumTemps = 1;
-    LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+    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 if ((receiver_type() == kArray) ||
              (receiver_type() == kImmutableArray)) {
-    return LocationSummary::Make(kNumInputs, Location::RequiresRegister());
+    return LocationSummary::Make(kNumInputs,
+                                 Location::RequiresRegister(),
+                                 LocationSummary::kNoCall);
   } else {
     ASSERT(receiver_type() == kIllegalObjectKind);
     return MakeCallSummary();
   }
 }
 
 
 static void EmitLoadIndexedPolymorphic(FlowGraphCompiler* compiler,
                                         LoadIndexedComp* comp) {
   Label* deopt = compiler->AddDeoptStub(comp->cid(),
@@ skipping 84 matching lines @@
       UNREACHABLE();
       break;
   }
 }
 
 
 LocationSummary* StoreIndexedComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
   if (receiver_type() == kGrowableObjectArray) {
     const intptr_t kNumTemps = 1;
-    LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+    LocationSummary* locs =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     locs->set_in(2, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::NoLocation());
     return locs;
   } else if (receiver_type() == kArray) {
-    return LocationSummary::Make(kNumInputs, Location::NoLocation());
+    return LocationSummary::Make(kNumInputs,
+                                 Location::NoLocation(),
+                                 LocationSummary::kNoCall);
   } else {
     ASSERT(receiver_type() == kIllegalObjectKind);
     return MakeCallSummary();
   }
 }
 
 
 static void EmitStoreIndexedGeneric(FlowGraphCompiler* compiler,
                                     StoreIndexedComp* comp) {
   const String& function_name =
@@ skipping 161 matching lines @@
                                    function_name,
                                    kArgumentCount,
                                    Array::ZoneHandle(),
                                    kCheckedArgumentCount);
   }
 }
 
 
 LocationSummary* StaticSetterComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
-  return LocationSummary::Make(kNumInputs, Location::RequiresRegister());
+  return LocationSummary::Make(kNumInputs,
+                               Location::RequiresRegister(),
+                               LocationSummary::kNoCall);
 }
 
 
 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->GenerateStaticCall(cid(),
                                token_pos(),
                                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 LocationSummary::Make(1, Location::RequiresRegister());
+  return LocationSummary::Make(1,
+                               Location::RequiresRegister(),
+                               LocationSummary::kNoCall);
 }
 
 
 void LoadInstanceFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register instance_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
 
   if (HasICData()) {
     ASSERT(original() != NULL);
     Label* deopt = compiler->AddDeoptStub(original()->cid(),
                                           original()->token_pos(),
                                           original()->try_index(),
                                           kDeoptInstanceGetterSameTarget,
                                           instance_reg);
     // Smis do not have instance fields (Smi class is always first).
     // Use 'result' as temporary register.
     ASSERT(result_reg != instance_reg);
     ASSERT(ic_data() != NULL);
     compiler->EmitClassChecksNoSmi(*ic_data(), instance_reg, result_reg, deopt);
   }
   __ movq(result_reg, FieldAddress(instance_reg, field().Offset()));
 }
 
 
 LocationSummary* LoadStaticFieldComp::MakeLocationSummary() const {
-  return LocationSummary::Make(0, Location::RequiresRegister());
+  return LocationSummary::Make(0,
+                               Location::RequiresRegister(),
+                               LocationSummary::kNoCall);
 }
 
 
 void LoadStaticFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out().reg();
   __ LoadObject(result, field());
   __ movq(result, FieldAddress(result, Field::value_offset()));
 }
 
 
 LocationSummary* InstanceOfComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 0;
-  LocationSummary* summary = new LocationSummary(kNumInputs,
-                                                 kNumTemps,
-                                                 LocationSummary::kCall);
+  LocationSummary* summary =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   summary->set_in(0, Location::RegisterLocation(RAX));
   summary->set_in(1, Location::RegisterLocation(RCX));
   summary->set_in(2, Location::RegisterLocation(RDX));
   summary->set_out(Location::RegisterLocation(RAX));
   return summary;
 }
 
 
 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(cid(),
                                token_pos(),
                                try_index(),
                                type(),
                                negate_result());
   ASSERT(locs()->out().reg() == RAX);
 }
 
 
 LocationSummary* CreateArrayComp::MakeLocationSummary() const {
   // TODO(regis): The elements of the array could be considered as arguments to
   // CreateArrayComp, thereby making CreateArrayComp a call.
   // For VerifyCallComputation to work, CreateArrayComp would need an
   // ArgumentCount getter and an ArgumentAt getter.
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
-  LocationSummary* locs = new LocationSummary(kNumInputs,
-                                              kNumTemps,
-                                              LocationSummary::kCall);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RBX));
   locs->set_temp(0, Location::RegisterLocation(R10));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void CreateArrayComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register temp_reg = locs()->temp(0).reg();
   Register result_reg = locs()->out().reg();
@@ skipping 14 matching lines @@
     ASSERT(ElementAt(i)->IsUse());
     __ popq(Address(temp_reg, i * kWordSize));
   }
 }
 
 
 LocationSummary*
     AllocateObjectWithBoundsCheckComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
-  LocationSummary* locs = new LocationSummary(kNumInputs,
-                                              kNumTemps,
-                                              LocationSummary::kCall);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_in(1, Location::RegisterLocation(RCX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void AllocateObjectWithBoundsCheckComp::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   const Class& cls = Class::ZoneHandle(constructor().owner());
@@ skipping 10 matching lines @@
                                 token_pos(),
                                 try_index(),
                                 kAllocateObjectWithBoundsCheckRuntimeEntry);
   // 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());
+  return LocationSummary::Make(1,
+                               Location::RequiresRegister(),
+                               LocationSummary::kNoCall);
 }
 
 
 void LoadVMFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register instance_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
   if (HasICData()) {
     ASSERT(original() != NULL);
     Label* deopt = compiler->AddDeoptStub(original()->cid(),
                                           original()->token_pos(),
                                           original()->try_index(),
                                           kDeoptInstanceGetterSameTarget,
                                           instance_reg);
     // Smis do not have instance fields (Smi class is always first).
     // Use 'result' as temporary register.
     ASSERT(result_reg != instance_reg);
     ASSERT(ic_data() != NULL);
     compiler->EmitClassChecksNoSmi(*ic_data(), instance_reg, result_reg, deopt);
   }
 
   __ movq(result_reg, FieldAddress(instance_reg, offset_in_bytes()));
 }
 
 
 LocationSummary* InstantiateTypeArgumentsComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
-  LocationSummary* locs = new LocationSummary(kNumInputs,
-                                              kNumTemps,
-                                              LocationSummary::kCall);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void InstantiateTypeArgumentsComp::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   Register instantiator_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
@@ skipping 39 matching lines @@
   __ Bind(&type_arguments_instantiated);
   ASSERT(instantiator_reg == result_reg);
   // 'result_reg': Instantiated type arguments.
 }
 
 
 LocationSummary*
     ExtractConstructorTypeArgumentsComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
-  LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   return locs;
 }
 
 
 void ExtractConstructorTypeArgumentsComp::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   Register instantiator_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
@@ skipping 34 matching lines @@
   // result_reg: uninstantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   // result_reg: uninstantiated or instantiated type arguments.
 }
 
 
 LocationSummary*
     ExtractConstructorInstantiatorComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
-  LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   return locs;
 }
 
 
 void ExtractConstructorInstantiatorComp::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   ASSERT(instantiator()->IsUse());
   Register instantiator_reg = locs()->in(0).reg();
@@ skipping 43 matching lines @@
             Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   }
   __ Bind(&done);
   // instantiator_reg: instantiator or kNoInstantiator.
 }
 
 
 LocationSummary* AllocateContextComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
-  LocationSummary* locs = new LocationSummary(kNumInputs,
-                                              kNumTemps,
-                                              LocationSummary::kCall);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_temp(0, Location::RegisterLocation(R10));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void AllocateContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   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);
 }
 
 
 LocationSummary* CloneContextComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
-  LocationSummary* locs = new LocationSummary(kNumInputs,
-                                              kNumTemps,
-                                              LocationSummary::kCall);
+  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(cid(),
                                 token_pos(),
                                 try_index(),
                                 kCloneContextRuntimeEntry);
   __ popq(result);  // Remove argument.
   __ popq(result);  // Get result (cloned context).
 }
 
 
 LocationSummary* CatchEntryComp::MakeLocationSummary() const {
-  return LocationSummary::Make(0, Location::NoLocation());
+  return LocationSummary::Make(0,
+                               Location::NoLocation(),
+                               LocationSummary::kNoCall);
 }
 
 
 // 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);
   const intptr_t offset_size =
       -locals_space_size + FlowGraphCompiler::kLocalsOffsetFromFP;
   __ leaq(RSP, Address(RBP, offset_size));
 
   ASSERT(!exception_var().is_captured());
   ASSERT(!stacktrace_var().is_captured());
   __ movq(Address(RBP, exception_var().index() * kWordSize),
           kExceptionObjectReg);
   __ movq(Address(RBP, stacktrace_var().index() * kWordSize),
           kStackTraceObjectReg);
 }
 
 
 LocationSummary* CheckStackOverflowComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   // TODO(vegorov): spilling is required only on an infrequently executed path.
-  LocationSummary* summary = new LocationSummary(kNumInputs,
-                                                 kNumTemps,
-                                                 LocationSummary::kCall);
+  LocationSummary* summary =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   // All registers are blocked for a call.  Instructions marked at calls can use
   // only fixed register temps.
   summary->set_temp(0, Location::RegisterLocation(RAX));
   return summary;
 }
 
 
 void CheckStackOverflowComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register temp = locs()->temp(0).reg();
   // Generate stack overflow check.
@@ skipping 24 matching lines @@
     summary->set_in(0, Location::RegisterLocation(RAX));
     summary->set_in(1, Location::RegisterLocation(RCX));
     summary->set_out(Location::RegisterLocation(RAX));
     return summary;
   }
 
   ASSERT(operands_type() == kSmiOperands);
 
   if (op_kind() == Token::kTRUNCDIV) {
     const intptr_t kNumTemps = 3;
-    LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
+    LocationSummary* summary =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RegisterLocation(RAX));
     summary->set_in(1, Location::RegisterLocation(RCX));
     summary->set_out(Location::SameAsFirstInput());
     summary->set_temp(0, Location::RegisterLocation(RBX));
     // Will be used for for sign extension.
     summary->set_temp(1, Location::RegisterLocation(RDX));
     summary->set_temp(2, Location::RequiresRegister());
     return summary;
   } else if (op_kind() == Token::kSHR) {
     const intptr_t kNumTemps = 1;
-    LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
+    LocationSummary* summary =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RegisterLocation(RCX));
     summary->set_out(Location::SameAsFirstInput());
     summary->set_temp(0, Location::RequiresRegister());
     return summary;
   } else if (op_kind() == Token::kSHL) {
     // Two Smi operands can easily overflow into Mint.
     const intptr_t kNumTemps = 2;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
     summary->set_in(0, Location::RegisterLocation(RAX));
     summary->set_in(1, Location::RegisterLocation(RDX));
     summary->set_out(Location::RegisterLocation(RAX));
     summary->set_temp(0, Location::RegisterLocation(RBX));
     summary->set_temp(1, Location::RegisterLocation(RCX));
     return summary;
   } else {
     const intptr_t kNumTemps = 1;
-    LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
+    LocationSummary* summary =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RequiresRegister());
     summary->set_out(Location::SameAsFirstInput());
     summary->set_temp(0, Location::RequiresRegister());
     return summary;
   }
 }
 
 
 static void EmitSmiBinaryOp(FlowGraphCompiler* compiler, BinaryOpComp* comp) {
@@ skipping 298 matching lines @@
 
     default:
       UNREACHABLE();
   }
 }
 
 
 LocationSummary* UnarySmiOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
-  LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
+  LocationSummary* summary =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_out(Location::SameAsFirstInput());
   return summary;
 }
 
 
 void UnarySmiOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   const ICData& ic_data = *instance_call()->ic_data();
   ASSERT(!ic_data.IsNull());
   ASSERT(ic_data.num_args_tested() == 1);
@@ skipping 28 matching lines @@
     }
   } else {
     UNREACHABLE();
   }
 }
 
 
 LocationSummary* NumberNegateComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;  // Needed for doubles.
-  LocationSummary* summary = new LocationSummary(kNumInputs,
-                                                 kNumTemps,
-                                                 LocationSummary::kCall);
+  LocationSummary* summary =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   summary->set_in(0, Location::RegisterLocation(RAX));
   summary->set_out(Location::RegisterLocation(RAX));
   summary->set_temp(0, Location::RegisterLocation(RCX));
   return summary;
 }
 
 
 void NumberNegateComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   const ICData& ic_data = *instance_call()->ic_data();
   ASSERT(!ic_data.IsNull());
@@ skipping 39 matching lines @@
   } else {
     UNREACHABLE();
   }
 }
 
 
 LocationSummary* ToDoubleComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   if (from() == kDouble) {
     const intptr_t kNumTemps = 0;
-    LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+    LocationSummary* locs =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_out(Location::SameAsFirstInput());
     return locs;
   } else {
     ASSERT(from() == kSmi);
     return MakeCallSummary();  // Calls a stub to allocate result.
   }
 }
 
 
@@ skipping 100 matching lines @@
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   return (class_ids[0] == class_id) && (class_ids[1] == class_id);
 }
 
 
 LocationSummary* BranchInstr::MakeLocationSummary() const {
   if ((kind() == Token::kEQ_STRICT) || (kind() == Token::kNE_STRICT)) {
     const int kNumInputs = 2;
     const int kNumTemps = 0;
-    LocationSummary* locs = new LocationSummary(kNumInputs,
-                                                kNumTemps,
-                                                LocationSummary::kNoCall);
+    LocationSummary* locs =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     return locs;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
     if (ICDataWithBothClassIds(*ic_data(), kSmi) ||
         ICDataWithBothClassIds(*ic_data(), kDouble)) {
       const intptr_t kNumInputs = 2;
       const intptr_t kNumTemps = 1;
-      LocationSummary* summary = new LocationSummary(kNumInputs,
-                                                     kNumTemps,
-                                                     LocationSummary::kNoCall);
+      LocationSummary* summary =
+          new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
       summary->set_in(0, Location::RequiresRegister());
       summary->set_in(1, Location::RequiresRegister());
       summary->set_temp(0, Location::RequiresRegister());
       return summary;
     }
     if ((kind() == Token::kEQ) || (kind() == Token::kNE)) {
       const intptr_t kNumInputs = 2;
       const intptr_t kNumTemps = 1;
-      LocationSummary* locs = new LocationSummary(kNumInputs,
-                                                  kNumTemps,
-                                                  LocationSummary::kCall);
+      LocationSummary* locs =
+          new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
       locs->set_in(0, Location::RegisterLocation(RAX));
       locs->set_in(1, Location::RegisterLocation(RCX));
       locs->set_temp(0, Location::RegisterLocation(RDX));
       return locs;
     }
     // Otherwise polymorphic dispatch.
   }
   // Call.
   LocationSummary* result = new LocationSummary(0, 0, LocationSummary::kCall);
   result->set_out(Location::RegisterLocation(RAX));
@@ skipping 51 matching lines @@
   ASSERT(locs()->out().reg() == RAX);
   __ CompareObject(locs()->out().reg(), compiler->bool_true());
   EmitBranchOnCondition(compiler, branch_condition);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64