- Use isolate where it is appropriate.

runtime/vm/intermediate_language_x64.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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 171 matching lines @@
   }
 }
 
 
 LocationSummary* LoadLocalInstr::MakeLocationSummary(Isolate* isolate,
                                                      bool opt) const {
   const intptr_t kNumInputs = 0;
   const intptr_t stack_index = (local().index() < 0)
       ? kFirstLocalSlotFromFp - local().index()
       : kParamEndSlotFromFp - local().index();
-  return LocationSummary::Make(kNumInputs,
+  return LocationSummary::Make(isolate,
+                               kNumInputs,
                                Location::StackSlot(stack_index),
                                LocationSummary::kNoCall);
 }
 
 
 void LoadLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(!compiler->is_optimizing());
   // Nothing to do.
 }
 
 
 LocationSummary* StoreLocalInstr::MakeLocationSummary(Isolate* isolate,
                                                       bool opt) const {
   const intptr_t kNumInputs = 1;
-  return LocationSummary::Make(kNumInputs,
+  return LocationSummary::Make(isolate,
+                               kNumInputs,
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
 
 
 void StoreLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   ASSERT(result == value);  // Assert that register assignment is correct.
   __ movq(Address(RBP, local().index() * kWordSize), value);
 }
 
 
 LocationSummary* ConstantInstr::MakeLocationSummary(Isolate* isolate,
                                                     bool opt) const {
   const intptr_t kNumInputs = 0;
-  return LocationSummary::Make(kNumInputs,
+  return LocationSummary::Make(isolate,
+                               kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void ConstantInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // The register allocator drops constant definitions that have no uses.
   if (!locs()->out(0).IsInvalid()) {
     Register result = locs()->out(0).reg();
     __ LoadObject(result, value(), PP);
@@ skipping 520 matching lines @@
   const intptr_t data_offset = Instance::DataOffsetFor(cid);
   const int64_t disp = smi_const.AsInt64Value() * scale + data_offset;
   return Utils::IsInt(32, disp);
 }
 
 
 LocationSummary* StringFromCharCodeInstr::MakeLocationSummary(Isolate* isolate,
                                                               bool opt) const {
   const intptr_t kNumInputs = 1;
   // TODO(fschneider): Allow immediate operands for the char code.
-  return LocationSummary::Make(kNumInputs,
+  return LocationSummary::Make(isolate,
+                               kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void StringFromCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register char_code = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   __ LoadImmediate(result,
       Immediate(reinterpret_cast<uword>(Symbols::PredefinedAddress())), PP);
   __ movq(result, Address(result,
                           char_code,
                           TIMES_HALF_WORD_SIZE,  // Char code is a smi.
                           Symbols::kNullCharCodeSymbolOffset * kWordSize));
 }
 
 
 LocationSummary* StringToCharCodeInstr::MakeLocationSummary(Isolate* isolate,
                                                             bool opt) const {
   const intptr_t kNumInputs = 1;
-  return LocationSummary::Make(kNumInputs,
+  return LocationSummary::Make(isolate,
+                               kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void StringToCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(cid_ == kOneByteStringCid);
   Register str = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   Label is_one, done;
@@ skipping 32 matching lines @@
                                kNumberOfArguments,
                                kNoArgumentNames,
                                locs());
   ASSERT(locs()->out(0).reg() == RAX);
 }
 
 
 LocationSummary* LoadUntaggedInstr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
   const intptr_t kNumInputs = 1;
-  return LocationSummary::Make(kNumInputs,
+  return LocationSummary::Make(isolate,
+                               kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void LoadUntaggedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register object = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   __ movq(result, FieldAddress(object, offset()));
 }
 
 
 LocationSummary* LoadClassIdInstr::MakeLocationSummary(Isolate* isolate,
                                                        bool opt) const {
   const intptr_t kNumInputs = 1;
-  return LocationSummary::Make(kNumInputs,
+  return LocationSummary::Make(isolate,
+                               kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void LoadClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register object = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   Label load, done;
   __ testq(object, Immediate(kSmiTagMask));
@@ skipping 776 matching lines @@
  public:
   StoreInstanceFieldSlowPath(StoreInstanceFieldInstr* instruction,
                              const Class& cls)
       : instruction_(instruction), cls_(cls) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("StoreInstanceFieldSlowPath");
     __ Bind(entry_label());
     const Code& stub =
         Code::Handle(StubCode::GetAllocationStubForClass(cls_));
-    const ExternalLabel label(cls_.ToCString(), stub.EntryPoint());
+    const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
     __ MoveRegister(locs->temp(0).reg(), RAX);
@@ skipping 462 matching lines @@
  public:
   explicit BoxDoubleSlowPath(Instruction* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("BoxDoubleSlowPath");
     __ Bind(entry_label());
     const Class& double_class = compiler->double_class();
     const Code& stub =
         Code::Handle(StubCode::GetAllocationStubForClass(double_class));
-    const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
+    const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
     __ MoveRegister(locs->out(0).reg(), RAX);
@@ skipping 11 matching lines @@
  public:
   explicit BoxFloat32x4SlowPath(Instruction* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("BoxFloat32x4SlowPath");
     __ Bind(entry_label());
     const Class& float32x4_class = compiler->float32x4_class();
     const Code& stub =
         Code::Handle(StubCode::GetAllocationStubForClass(float32x4_class));
-    const ExternalLabel label(float32x4_class.ToCString(), stub.EntryPoint());
+    const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
     __ MoveRegister(locs->out(0).reg(), RAX);
@@ skipping 11 matching lines @@
  public:
   explicit BoxFloat64x2SlowPath(Instruction* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("BoxFloat64x2SlowPath");
     __ Bind(entry_label());
     const Class& float64x2_class = compiler->float64x2_class();
     const Code& stub =
         Code::Handle(StubCode::GetAllocationStubForClass(float64x2_class));
-    const ExternalLabel label(float64x2_class.ToCString(), stub.EntryPoint());
+    const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
     __ MoveRegister(locs->out(0).reg(), RAX);
@@ skipping 265 matching lines @@
   locs->set_out(0, Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void AllocateContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == R10);
   ASSERT(locs()->out(0).reg() == RAX);
 
   __ LoadImmediate(R10, Immediate(num_context_variables()), PP);
-  const ExternalLabel label("alloc_context",
-                            StubCode::AllocateContextEntryPoint());
+  const ExternalLabel label(StubCode::AllocateContextEntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
 }
 
 
 LocationSummary* CloneContextInstr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
   const intptr_t kNumInputs = 1;
@@ skipping 915 matching lines @@
                  out_reg,
                  PP);
   __ Bind(slow_path->exit_label());
   __ movups(FieldAddress(out_reg, Float32x4::value_offset()), value);
 }
 
 
 LocationSummary* UnboxFloat32x4Instr::MakeLocationSummary(Isolate* isolate,
                                                           bool opt) const {
   const intptr_t kNumInputs = 1;
-  return LocationSummary::Make(kNumInputs,
+  return LocationSummary::Make(isolate,
+                               kNumInputs,
                                Location::RequiresFpuRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void UnboxFloat32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register value = locs()->in(0).reg();
   const XmmRegister result = locs()->out(0).fpu_reg();
 
@@ skipping 86 matching lines @@
  public:
   explicit BoxInt32x4SlowPath(BoxInt32x4Instr* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("BoxInt32x4SlowPath");
     __ Bind(entry_label());
     const Class& int32x4_class = compiler->int32x4_class();
     const Code& stub =
         Code::Handle(StubCode::GetAllocationStubForClass(int32x4_class));
-    const ExternalLabel label(int32x4_class.ToCString(), stub.EntryPoint());
+    const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
     __ MoveRegister(locs->out(0).reg(), RAX);
@@ skipping 1132 matching lines @@
     __ movaps(locs()->out(0).fpu_reg(), XMM0);
     // Restore RSP.
     __ movq(RSP, locs()->temp(0).reg());
   }
 }
 
 
 LocationSummary* UnarySmiOpInstr::MakeLocationSummary(Isolate* isolate,
                                                       bool opt) const {
   const intptr_t kNumInputs = 1;
-  return LocationSummary::Make(kNumInputs,
+  return LocationSummary::Make(isolate,
+                               kNumInputs,
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
 
 
 void UnarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   ASSERT(value == locs()->out(0).reg());
   switch (op_kind()) {
     case Token::kNEGATE: {
@@ skipping 1033 matching lines @@
   // We can fall through if the successor is the next block in the list.
   // Otherwise, we need a jump.
   if (!compiler->CanFallThroughTo(successor())) {
     __ jmp(compiler->GetJumpLabel(successor()));
   }
 }
 
 
 LocationSummary* CurrentContextInstr::MakeLocationSummary(Isolate* isolate,
                                                           bool opt) const {
-  return LocationSummary::Make(0,
+  return LocationSummary::Make(isolate,
+                               0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void CurrentContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ MoveRegister(locs()->out(0).reg(), CTX);
 }
 
 
@@ skipping 125 matching lines @@
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    deopt_id_after,
                                    token_pos());
   }
   __ Drop(argument_count);
 }
 
 
 LocationSummary* BooleanNegateInstr::MakeLocationSummary(Isolate* isolate,
                                                          bool opt) const {
-  return LocationSummary::Make(1,
+  return LocationSummary::Make(isolate,
+                               1,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void BooleanNegateInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
 
   Label done;
   __ LoadObject(result, Bool::True(), PP);
   __ CompareRegisters(result, value);
   __ j(NOT_EQUAL, &done, Assembler::kNearJump);
   __ LoadObject(result, Bool::False(), PP);
   __ Bind(&done);
 }
 
 
 LocationSummary* AllocateObjectInstr::MakeLocationSummary(Isolate* isolate,
                                                           bool opt) const {
   return MakeCallSummary();
 }
 
 
 void AllocateObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls()));
-  const ExternalLabel label(cls().ToCString(), stub.EntryPoint());
+  const ExternalLabel label(stub.EntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64