Remove the default contains_call parameter on location summaries.

runtime/vm/intermediate_language.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 949 matching lines @@
   if (HasTryIndex()) {
     compiler->AddExceptionHandler(try_index(),
                                   compiler->assembler()->CodeSize());
   }
 }
 
 
 LocationSummary* StoreInstanceFieldComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t num_temps = HasICData() ? 1 : 0;
-  LocationSummary* summary = new LocationSummary(kNumInputs, num_temps);
+  LocationSummary* summary =
+      new LocationSummary(kNumInputs, num_temps, Location::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_in(1, Location::RequiresRegister());
   if (HasICData()) {
     summary->set_temp(0, Location::RequiresRegister());
   }
   return summary;
 }
 
 
 void StoreInstanceFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 16 matching lines @@
     compiler->EmitClassChecksNoSmi(*ic_data(), instance_reg, temp_reg, deopt);
   }
   __ StoreIntoObject(instance_reg, FieldAddress(instance_reg, field().Offset()),
                      value_reg);
 }
 
 
 LocationSummary* ThrowInstr::MakeLocationSummary() const {
   const int kNumInputs = 0;
   const int kNumTemps = 0;
-  return new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
+  return new LocationSummary(kNumInputs, kNumTemps, Location::kCall);
 }
 
 
 
 void ThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(exception()->IsUse());
   compiler->GenerateCallRuntime(cid(),
                                 token_pos(),
                                 try_index(),
                                 kThrowRuntimeEntry);
   __ int3();
 }
 
 
 LocationSummary* ReThrowInstr::MakeLocationSummary() const {
   const int kNumInputs = 0;
   const int kNumTemps = 0;
-  return new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
+  return new LocationSummary(kNumInputs, kNumTemps, Location::kCall);
 }
 
 
 void ReThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(exception()->IsUse());
   ASSERT(stack_trace()->IsUse());
   compiler->GenerateCallRuntime(cid(),
                                 token_pos(),
                                 try_index(),
                                 kReThrowRuntimeEntry);
   __ int3();
 }
 
 
 LocationSummary* GotoInstr::MakeLocationSummary() const {
-  return new LocationSummary(0, 0);
+  return new LocationSummary(0, 0, Location::kNoCall);
 }
 
 
 void GotoInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // We can fall through if the successor is the next block in the list.
   // Otherwise, we need a jump.
   if (!compiler->IsNextBlock(successor())) {
     __ jmp(compiler->GetBlockLabel(successor()));
   }
 }
@@ skipping 28 matching lines @@
     // If the next block is the true successor we negate comparison and fall
     // through to it.
     ASSERT(compiler->IsNextBlock(true_successor()));
     Condition false_condition = NegateCondition(true_condition);
     __ j(false_condition, compiler->GetBlockLabel(false_successor()));
   }
 }
 
 
 LocationSummary* CurrentContextComp::MakeLocationSummary() const {
-  return LocationSummary::Make(0, Location::RequiresRegister());
+  return LocationSummary::Make(0,
+                               Location::RequiresRegister(),
+                               Location::kNoCall);
 }
 
 
 void CurrentContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ MoveRegister(locs()->out().reg(), CTX);
 }
 
 
 LocationSummary* StoreContextComp::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::RegisterLocation(CTX));
   return summary;
 }
 
 
 void StoreContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Nothing to do.  Context register were loaded by register allocator.
   ASSERT(locs()->in(0).reg() == CTX);
 }
 
 
 LocationSummary* StrictCompareComp::MakeLocationSummary() const {
-  return LocationSummary::Make(2, Location::SameAsFirstInput());
+  return LocationSummary::Make(2,
+                               Location::SameAsFirstInput(),
+                               Location::kNoCall);
 }
 
 
 void StrictCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
 
   ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
   Condition true_condition = (kind() == Token::kEQ_STRICT) ? EQUAL : NOT_EQUAL;
   __ CompareRegisters(left, right);
@@ skipping 83 matching lines @@
   compiler->GenerateAssertAssignable(cid(),
                                      token_pos(),
                                      try_index(),
                                      dst_type(),
                                      dst_name());
   ASSERT(locs()->in(0).reg() == locs()->out().reg());
 }
 
 
 LocationSummary* StoreStaticFieldComp::MakeLocationSummary() const {
-  LocationSummary* locs = new LocationSummary(1, 1);
+  LocationSummary* locs = new LocationSummary(1, 1, Location::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   return locs;
 }
 
 
 void StoreStaticFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   ASSERT(locs()->out().reg() == value);
 
   __ LoadObject(temp, field());
   __ StoreIntoObject(temp, FieldAddress(temp, Field::value_offset()), value);
 }
 
 
 LocationSummary* BooleanNegateComp::MakeLocationSummary() const {
-  return LocationSummary::Make(1, Location::RequiresRegister());
+  return LocationSummary::Make(1,
+                               Location::RequiresRegister(),
+                               Location::kNoCall);
 }
 
 
 void BooleanNegateComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   Label done;
   __ LoadObject(result, compiler->bool_true());
   __ CompareRegisters(result, value);
   __ j(NOT_EQUAL, &done, Assembler::kNearJump);
   __ LoadObject(result, compiler->bool_false());
   __ Bind(&done);
 }
 
 
 LocationSummary* ChainContextComp::MakeLocationSummary() const {
-  return LocationSummary::Make(1, Location::NoLocation());
+  return LocationSummary::Make(1, Location::NoLocation(), Location::kNoCall);
 }
 
 
 void ChainContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register context_value = locs()->in(0).reg();
 
   // Chain the new context in context_value to its parent in CTX.
   __ StoreIntoObject(context_value,
                      FieldAddress(context_value, Context::parent_offset()),
                      CTX);
   // Set new context as current context.
   __ MoveRegister(CTX, context_value);
 }
 
 
 LocationSummary* StoreVMFieldComp::MakeLocationSummary() const {
-  return LocationSummary::Make(2, Location::SameAsFirstInput());
+  return LocationSummary::Make(2,
+                               Location::SameAsFirstInput(),
+                               Location::kNoCall);
 }
 
 
 void StoreVMFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value_reg = locs()->in(0).reg();
   Register dest_reg = locs()->in(1).reg();
   ASSERT(value_reg == locs()->out().reg());
 
   __ StoreIntoObject(dest_reg, FieldAddress(dest_reg, offset_in_bytes()),
                      value_reg);
@@ skipping 29 matching lines @@
   const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_pos(), try_index(), &label,
                          PcDescriptors::kOther);
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 
 LocationSummary* PushArgumentInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps= 0;
-  LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, Location::kNoCall);
   // TODO(fschneider): Use Any() once it is supported by all code generators.
   locs->set_in(0, Location::RequiresRegister());
   return locs;
 }
 
 
 void PushArgumentInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // In SSA mode, we need an explicit push. Nothing to do in non-SSA mode
   // where PushArgument is handled in FrameRegisterAllocator::AllocateRegisters.
   // Instead of popping the value it is left alone on the simulated frame
   // and materialized on the physical stack before the call.
   // TODO(fschneider): Avoid special-casing for SSA mode here.
   if (compiler->is_ssa()) {
     ASSERT(locs()->in(0).IsRegister());
     __ PushRegister(locs()->in(0).reg());
   }
 }
 
 
 #undef __
 
 }  // namespace dart