Make CTX allocatable by the register allocator.

runtime/vm/intermediate_language_ia32.cc

 // Copyright (c) 2013, 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 "vm/dart_entry.h"
@@ skipping 12 matching lines @@
 namespace dart {
 
 DECLARE_FLAG(bool, emit_edge_counters);
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, propagate_ic_data);
 DECLARE_FLAG(bool, use_osr);
 DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
 
 // Generic summary for call instructions that have all arguments pushed
 // on the stack and return the result in a fixed register EAX.
-LocationSummary* Instruction::MakeCallSummary() {
-  Isolate* isolate = Isolate::Current();
+LocationSummary* Instruction::MakeCallSummary(Isolate* isolate) {
+  const intptr_t kNumInputs = 0;
+  const intptr_t kNumTemps= 0;
   LocationSummary* result = new(isolate) LocationSummary(
-      isolate, 0, 0, LocationSummary::kCall);
+      isolate, kNumInputs, kNumTemps, LocationSummary::kCall);
   result->set_out(0, Location::RegisterLocation(EAX));
   return result;
 }
 
 
 LocationSummary* PushArgumentInstr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps= 0;
   LocationSummary* locs = new(isolate) LocationSummary(
@@ skipping 749 matching lines @@
 void RelationalOpInstr::EmitBranchCode(FlowGraphCompiler* compiler,
                                        BranchInstr* branch) {
   BranchLabels labels = compiler->CreateBranchLabels(branch);
   Condition true_condition = EmitComparisonCode(compiler, labels);
   EmitBranchOnCondition(compiler, true_condition, labels);
 }
 
 
 LocationSummary* NativeCallInstr::MakeLocationSummary(Isolate* isolate,
                                                       bool opt) const {
-  const intptr_t kNumInputs = 0;
-  const intptr_t kNumTemps = 3;
-  LocationSummary* locs = new(isolate) LocationSummary(
-      isolate, kNumInputs, kNumTemps, LocationSummary::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(0, Location::RegisterLocation(EAX));
-  return locs;
+  return MakeCallSummary(isolate);
 }
 
 
 void NativeCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  ASSERT(locs()->temp(0).reg() == EAX);
-  ASSERT(locs()->temp(1).reg() == ECX);
-  ASSERT(locs()->temp(2).reg() == EDX);
   Register result = locs()->out(0).reg();
   const intptr_t argc_tag = NativeArguments::ComputeArgcTag(function());
   const bool is_leaf_call =
       (argc_tag & NativeArguments::AutoSetupScopeMask()) == 0;
   StubCode* stub_code = compiler->isolate()->stub_code();
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::null_object());
   // Pass a pointer to the first argument in EAX.
   if (!function().HasOptionalParameters()) {
@@ skipping 4556 matching lines @@
     __ addl(ESP, Immediate(2 * kWordSize));
     return;
   }
 
   UNIMPLEMENTED();
 }
 
 
 LocationSummary* PolymorphicInstanceCallInstr::MakeLocationSummary(
     Isolate* isolate, bool opt) const {
-  return MakeCallSummary();
+  return MakeCallSummary(isolate);
 }
 
 
 void PolymorphicInstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(ic_data().NumArgsTested() == 1);
   if (!with_checks()) {
     ASSERT(ic_data().HasOneTarget());
     const Function& target = Function::ZoneHandle(ic_data().GetTargetAt(0));
     compiler->GenerateStaticCall(deopt_id(),
                                  instance_call()->token_pos(),
@@ skipping 1252 matching lines @@
         Smi::RawValue(true_value) - Smi::RawValue(false_value)));
     if (false_value != 0) {
       __ addl(EDX, Immediate(Smi::RawValue(false_value)));
     }
   }
 }
 
 
 LocationSummary* ClosureCallInstr::MakeLocationSummary(Isolate* isolate,
                                                        bool opt) const {
-  const intptr_t kNumInputs = 1;
+  const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kCall);
-  summary->set_in(0, Location::RegisterLocation(EAX));  // Function.
+  summary->set_in(kFunctionPos, Location::RegisterLocation(EAX));  // Function.
+  summary->set_in(kContextPos, Location::RegisterLocation(CTX));  // Context.
   summary->set_out(0, Location::RegisterLocation(EAX));
   return summary;
 }
 
 
 void ClosureCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Load arguments descriptors.
   intptr_t argument_count = ArgumentCount();
   const Array& arguments_descriptor =
       Array::ZoneHandle(ArgumentsDescriptor::New(argument_count,
@@ skipping 47 matching lines @@
   __ LoadObject(result, Bool::True());
   __ CompareRegisters(result, value);
   __ j(NOT_EQUAL, &done, Assembler::kNearJump);
   __ LoadObject(result, Bool::False());
   __ Bind(&done);
 }
 
 
 LocationSummary* AllocateObjectInstr::MakeLocationSummary(Isolate* isolate,
                                                           bool opt) const {
-  return MakeCallSummary();
+  return MakeCallSummary(isolate);
 }
 
 
 void AllocateObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Isolate* isolate = compiler->isolate();
   StubCode* stub_code = isolate->stub_code();
   const Code& stub = Code::Handle(isolate,
                                   stub_code->GetAllocationStubForClass(cls()));
   const ExternalLabel label(stub.EntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          RawPcDescriptors::kOther,
                          locs());
   compiler->AddStubCallTarget(stub);
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 
 void DebugStepCheckInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(!compiler->is_optimizing());
   StubCode* stub_code = compiler->isolate()->stub_code();
   const ExternalLabel label(stub_code->DebugStepCheckEntryPoint());
   compiler->GenerateCall(token_pos(), &label, stub_kind_, locs());
 #if defined(DEBUG)
   __ movl(EDX, Immediate(kInvalidObjectPointer));
-  __ movl(EDX, Immediate(kInvalidObjectPointer));
 #endif
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_IA32