Remove the default contains_call parameter on location summaries.

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"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 #define __ compiler->assembler()->
 
 namespace dart {
 
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, trace_functions);
 
 // Generic summary for call instructions that have all arguments pushed
 // on the stack and return the result in a fixed register EAX.
 LocationSummary* Computation::MakeCallSummary() {
-  LocationSummary* result = new LocationSummary(0, 0, LocationSummary::kCall);
+  LocationSummary* result = new LocationSummary(0, 0, Location::kCall);
   result->set_out(Location::RegisterLocation(EAX));
   return result;
 }
 
 
 void BindInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   computation()->EmitNativeCode(compiler);
   if (is_used() && locs()->out().IsRegister()) {
     // TODO(vegorov): this should really happen only for comparisons fused
     // with branches.  Currrently IR does not provide an easy way to remove
     // 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, Location::kNoCall);
   locs->set_in(0, Location::RegisterLocation(EAX));
   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 == EAX);
@@ skipping 43 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, Location::kCall);
   result->set_out(Location::RegisterLocation(EAX));
   result->set_temp(0, Location::RegisterLocation(EDX));  // Arg. descriptor.
   return result;
 }
 
 
 LocationSummary* LoadLocalComp::MakeLocationSummary() const {
-  return LocationSummary::Make(0, Location::RequiresRegister());
+  return LocationSummary::Make(0,
+                               Location::RequiresRegister(),
+                               Location::kNoCall);
 }
 
 
 void LoadLocalComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out().reg();
   __ movl(result, Address(EBP, local().index() * kWordSize));
 }
 
 
 LocationSummary* StoreLocalComp::MakeLocationSummary() const {
-  return LocationSummary::Make(1, Location::SameAsFirstInput());
+  return LocationSummary::Make(1,
+                               Location::SameAsFirstInput(),
+                               Location::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.
   __ movl(Address(EBP, local().index() * kWordSize), value);
 }
 
 
 LocationSummary* ConstantVal::MakeLocationSummary() const {
-  return LocationSummary::Make(0, Location::RequiresRegister());
+  return LocationSummary::Make(0,
+                               Location::RequiresRegister(),
+                               Location::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, Location::kCall);
   summary->set_in(0, Location::RegisterLocation(EAX));  // Value.
   summary->set_in(1, Location::RegisterLocation(ECX));  // Instantiator.
   summary->set_in(2, Location::RegisterLocation(EDX));  // Type arguments.
   summary->set_out(Location::RegisterLocation(EAX));
   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, Location::kCall);
   locs->set_in(0, Location::RegisterLocation(EAX));
   locs->set_out(Location::RegisterLocation(EAX));
   return locs;
 }
 
 
 void AssertBooleanComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register obj = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
@@ skipping 31 matching lines @@
       return OVERFLOW;
   }
 }
 
 
 LocationSummary* EqualityCompareComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if (receiver_class_id() != kObject) {
     ASSERT((receiver_class_id() == kSmi) || (receiver_class_id() == kDouble));
     const intptr_t kNumTemps = 1;
-    LocationSummary* locs = new LocationSummary(kNumInputs,
-                                                kNumTemps,
-                                                LocationSummary::kNoCall);
+    LocationSummary* locs =
+        new LocationSummary(kNumInputs, kNumTemps, Location::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;
   }
   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, Location::kCall);
     locs->set_in(0, Location::RegisterLocation(ECX));
     locs->set_in(1, Location::RegisterLocation(EDX));
     locs->set_temp(0, Location::RegisterLocation(EBX));
     locs->set_out(Location::RegisterLocation(EAX));
     return locs;
   }
   const intptr_t kNumTemps = 0;
-  LocationSummary* locs = new LocationSummary(kNumInputs,
-                                              kNumTemps,
-                                              LocationSummary::kCall);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, Location::kCall);
   locs->set_in(0, Location::RegisterLocation(ECX));
   locs->set_in(1, Location::RegisterLocation(EDX));
   locs->set_out(Location::RegisterLocation(EAX));
   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 235 matching lines @@
     __ pushl(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::kNoCall);
+    LocationSummary* summary =
+        new LocationSummary(kNumInputs, kNumTemps, Location::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() == EAX);
 }
 
 
 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, Location::kCall);
   locs->set_temp(0, Location::RegisterLocation(EAX));
   locs->set_temp(1, Location::RegisterLocation(ECX));
   locs->set_temp(2, Location::RegisterLocation(EDX));
   locs->set_out(Location::RegisterLocation(EAX));
   return locs;
 }
 
 
 void NativeCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == EAX);
@@ skipping 23 matching lines @@
   __ popl(result);
 }
 
 
 LocationSummary* LoadIndexedComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if ((receiver_type() == kGrowableObjectArray) ||
       (receiver_type() == kArray) ||
       (receiver_type() == kImmutableArray)) {
     const intptr_t kNumTemps = 1;
-    LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+    LocationSummary* locs =
+        new LocationSummary(kNumInputs, kNumTemps, Location::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() == kIllegalObjectKind);
     return MakeCallSummary();
   }
 }
@@ skipping 91 matching lines @@
       break;
   }
 }
 
 
 LocationSummary* StoreIndexedComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
   if ((receiver_type() == kGrowableObjectArray) ||
       (receiver_type() == kArray)) {
     const intptr_t kNumTemps = 1;
-    LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+    LocationSummary* locs =
+        new LocationSummary(kNumInputs, kNumTemps, Location::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 {
     ASSERT(receiver_type() == kIllegalObjectKind);
     return MakeCallSummary();
   }
@@ skipping 167 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(),
+                               Location::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.
   __ pushl(value);
   __ pushl(value);
   compiler->GenerateStaticCall(cid(),
                                token_pos(),
                                try_index(),
                                setter_function(),
                                1,
                                Array::ZoneHandle());
   __ popl(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(),
+                               Location::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);
   }
   __ movl(result_reg, FieldAddress(instance_reg, field().Offset()));
 }
 
 
 LocationSummary* LoadStaticFieldComp::MakeLocationSummary() const {
-  return LocationSummary::Make(0, Location::RequiresRegister());
+  return LocationSummary::Make(0,
+                               Location::RequiresRegister(),
+                               Location::kNoCall);
 }
 
 
 void LoadStaticFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out().reg();
   __ LoadObject(result, field());
   __ movl(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, Location::kCall);
   summary->set_in(0, Location::RegisterLocation(EAX));
   summary->set_in(1, Location::RegisterLocation(ECX));
   summary->set_in(2, Location::RegisterLocation(EDX));
   summary->set_out(Location::RegisterLocation(EAX));
   return summary;
 }
 
 
 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(cid(),
                                token_pos(),
                                try_index(),
                                type(),
                                negate_result());
   ASSERT(locs()->out().reg() == EAX);
 }
 
 
 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, Location::kCall);
   locs->set_in(0, Location::RegisterLocation(ECX));
   locs->set_temp(0, Location::RegisterLocation(EDX));
   locs->set_out(Location::RegisterLocation(EAX));
   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());
     __ popl(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, Location::kCall);
   locs->set_in(0, Location::RegisterLocation(EAX));
   locs->set_in(1, Location::RegisterLocation(ECX));
   locs->set_out(Location::RegisterLocation(EAX));
   return locs;
 }
 
 
 void AllocateObjectWithBoundsCheckComp::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   const Class& cls = Class::ZoneHandle(constructor().owner());
@@ skipping 11 matching lines @@
                                 try_index(),
                                 kAllocateObjectWithBoundsCheckRuntimeEntry);
   // 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());
+  return LocationSummary::Make(1,
+                               Location::RequiresRegister(),
+                               Location::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);
   }
 
   __ movl(result_reg, FieldAddress(instance_reg, offset_in_bytes()));
 }
 
 
 LocationSummary* InstantiateTypeArgumentsComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
-  LocationSummary* locs = new LocationSummary(kNumInputs,
-                                              kNumTemps,
-                                              LocationSummary::kCall);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, Location::kCall);
   locs->set_in(0, Location::RegisterLocation(EAX));
   locs->set_temp(0, Location::RegisterLocation(ECX));
   locs->set_out(Location::RegisterLocation(EAX));
   return locs;
 }
 
 
 void InstantiateTypeArgumentsComp::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   Register instantiator_reg = locs()->in(0).reg();
@@ skipping 41 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 = 1;
-  LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, Location::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
 }
 
 
 void ExtractConstructorTypeArgumentsComp::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   Register instantiator_reg = locs()->in(0).reg();
@@ skipping 36 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 = 1;
-  LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, Location::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
 }
 
 
 void ExtractConstructorInstantiatorComp::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   ASSERT(instantiator()->IsUse());
@@ skipping 45 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, Location::kCall);
   locs->set_temp(0, Location::RegisterLocation(EDX));
   locs->set_out(Location::RegisterLocation(EAX));
   return locs;
 }
 
 
 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);
 }
 
 
 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, Location::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(cid(),
                                 token_pos(),
                                 try_index(),
                                 kCloneContextRuntimeEntry);
   __ popl(result);  // Remove argument.
   __ popl(result);  // Get result (cloned context).
 }
 
 
 LocationSummary* CatchEntryComp::MakeLocationSummary() const {
-  return LocationSummary::Make(0, Location::NoLocation());
+  return LocationSummary::Make(0, Location::NoLocation(), Location::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;
   __ leal(ESP, Address(EBP, offset_size));
 
   ASSERT(!exception_var().is_captured());
   ASSERT(!stacktrace_var().is_captured());
   __ movl(Address(EBP, exception_var().index() * kWordSize),
           kExceptionObjectReg);
   __ movl(Address(EBP, stacktrace_var().index() * kWordSize),
           kStackTraceObjectReg);
 }
 
 
 LocationSummary* CheckStackOverflowComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 0;
   // 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, Location::kCall);
   return summary;
 }
 
 
 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(cid(),
                                 token_pos(),
                                 try_index(),
                                 kStackOverflowRuntimeEntry);
   __ Bind(&no_stack_overflow);
 }
 
 
 LocationSummary* BinaryOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
 
   if (operands_type() == kDoubleOperands) {
     return MakeCallSummary();  // Calls into a stub for allocation.
   }
 
   if (operands_type() == kMintOperands) {
     ASSERT(op_kind() == Token::kBIT_AND);
     const intptr_t kNumTemps = 1;
     LocationSummary* summary =
-        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
+        new LocationSummary(kNumInputs, kNumTemps, Location::kCall);
     summary->set_in(0, Location::RegisterLocation(EAX));
     summary->set_in(1, Location::RegisterLocation(ECX));
     summary->set_temp(0, Location::RegisterLocation(EDX));
     summary->set_out(Location::RegisterLocation(EAX));
     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, Location::kNoCall);
     summary->set_in(0, Location::RegisterLocation(EAX));
     summary->set_in(1, Location::RegisterLocation(ECX));
     summary->set_out(Location::SameAsFirstInput());
     summary->set_temp(0, Location::RegisterLocation(EBX));
     // Will be used for for sign extension.
     summary->set_temp(1, Location::RegisterLocation(EDX));
     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, Location::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RegisterLocation(ECX));
     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);
+        new LocationSummary(kNumInputs, kNumTemps, Location::kCall);
     summary->set_in(0, Location::RegisterLocation(EAX));
     summary->set_in(1, Location::RegisterLocation(EDX));
     summary->set_temp(0, Location::RegisterLocation(EBX));
     summary->set_temp(1, Location::RegisterLocation(ECX));
     summary->set_out(Location::RegisterLocation(EAX));
     return summary;
   } else {
     const intptr_t kNumTemps = 1;
-    LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
+    LocationSummary* summary =
+        new LocationSummary(kNumInputs, kNumTemps, Location::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 299 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, Location::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, Location::kCall);
   summary->set_in(0, Location::RegisterLocation(EAX));
   summary->set_temp(0, Location::RegisterLocation(ECX));
   summary->set_out(Location::RegisterLocation(EAX));
   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 = 1;
-    LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+    LocationSummary* locs =
+        new LocationSummary(kNumInputs, kNumTemps, Location::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::SameAsFirstInput());
     locs->set_temp(0, Location::RequiresRegister());
     return locs;
   } else {
     ASSERT(from() == kSmi);
     return MakeCallSummary();  // Calls a stub to allocate result.
   }
 }
@@ skipping 103 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, Location::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, Location::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, Location::kCall);
       locs->set_in(0, Location::RegisterLocation(EAX));
       locs->set_in(1, Location::RegisterLocation(ECX));
       locs->set_temp(0, Location::RegisterLocation(EDX));
       return locs;
     }
     // Otherwise polymorphic dispatch.
   }
   // Call.
-  LocationSummary* result = new LocationSummary(0, 0, LocationSummary::kCall);
+  LocationSummary* result = new LocationSummary(0, 0, Location::kCall);
   result->set_out(Location::RegisterLocation(EAX));
   return result;
 }
 
 
 void BranchInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if ((kind() == Token::kEQ_STRICT) || (kind() == Token::kNE_STRICT)) {
     Register left = locs()->in(0).reg();
     Register right = locs()->in(1).reg();
     __ cmpl(left, right);
@@ skipping 42 matching lines @@
   ASSERT(locs()->out().reg() == EAX);
   __ CompareObject(locs()->out().reg(), compiler->bool_true());
   EmitBranchOnCondition(compiler, branch_condition);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64