More reduction of accessing TLS by caching/passing isolate value.

runtime/vm/deopt_instructions.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/deopt_instructions.h"
 
 #include "vm/assembler.h"
 #include "vm/code_patcher.h"
 #include "vm/intermediate_language.h"
 #include "vm/locations.h"
@@ skipping 1374 matching lines @@
   }
 
  private:
   const DeoptInstr* instruction_;  // Instruction that was written.
   const intptr_t info_number_;  // Index of the deopt info it was written to.
 
   GrowableArray<TrieNode*> children_;
 };
 
 
-DeoptInfoBuilder::DeoptInfoBuilder(const intptr_t num_args)
-    : instructions_(),
+DeoptInfoBuilder::DeoptInfoBuilder(Isolate* isolate, const intptr_t num_args)
+    : isolate_(isolate),
+      instructions_(),
       object_table_(GrowableObjectArray::Handle(
           GrowableObjectArray::New(Heap::kOld))),
       num_args_(num_args),
-      trie_root_(new TrieNode()),
+      trie_root_(new(isolate) TrieNode()),
       current_info_number_(0),
       frame_start_(-1),
       materializations_() {
 }
 
 
 intptr_t DeoptInfoBuilder::FindOrAddObjectInTable(const Object& obj) const {
   for (intptr_t i = 0; i < object_table_.Length(); i++) {
     if (object_table_.At(i) == obj.raw()) {
       return i;
@@ skipping 18 matching lines @@
                                         intptr_t deopt_id,
                                         intptr_t dest_index) {
   // Check that deopt_id exists.
   // TODO(vegorov): verify after deoptimization targets as well.
 #ifdef DEBUG
   ASSERT(Isolate::IsDeoptAfter(deopt_id) ||
          (code.GetPcForDeoptId(deopt_id, PcDescriptors::kDeopt) != 0));
 #endif
   const intptr_t object_table_index = FindOrAddObjectInTable(code);
   ASSERT(dest_index == FrameSize());
-  instructions_.Add(new DeoptRetAddressInstr(object_table_index, deopt_id));
+  instructions_.Add(
+      new(isolate()) DeoptRetAddressInstr(object_table_index, deopt_id));
 }
 
 
 void DeoptInfoBuilder::AddPcMarker(const Code& code,
                                    intptr_t dest_index) {
   intptr_t object_table_index = FindOrAddObjectInTable(code);
   ASSERT(dest_index == FrameSize());
-  instructions_.Add(new DeoptPcMarkerInstr(object_table_index));
+  instructions_.Add(new(isolate()) DeoptPcMarkerInstr(object_table_index));
 }
 
 
 void DeoptInfoBuilder::AddPp(const Code& code,
                              intptr_t dest_index) {
   intptr_t object_table_index = FindOrAddObjectInTable(code);
   ASSERT(dest_index == FrameSize());
-  instructions_.Add(new DeoptPpInstr(object_table_index));
+  instructions_.Add(new(isolate()) DeoptPpInstr(object_table_index));
 }
 
 
 void DeoptInfoBuilder::AddCopy(Value* value,
                                const Location& source_loc,
                                const intptr_t dest_index) {
   DeoptInstr* deopt_instr = NULL;
   if (source_loc.IsConstant()) {
     intptr_t object_table_index = FindOrAddObjectInTable(source_loc.constant());
-    deopt_instr = new DeoptConstantInstr(object_table_index);
+    deopt_instr = new(isolate()) DeoptConstantInstr(object_table_index);
   } else if (source_loc.IsRegister()) {
     ASSERT(value->definition()->representation() == kTagged);
-    deopt_instr = new DeoptRegisterInstr(source_loc.reg());
+    deopt_instr = new(isolate()) DeoptRegisterInstr(source_loc.reg());
   } else if (source_loc.IsFpuRegister()) {
     if (value->definition()->representation() == kUnboxedDouble) {
-      deopt_instr = new DeoptFpuRegisterInstr(source_loc.fpu_reg());
+      deopt_instr = new(isolate()) DeoptFpuRegisterInstr(source_loc.fpu_reg());
     } else if (value->definition()->representation() == kUnboxedFloat32x4) {
-      deopt_instr = new DeoptFloat32x4FpuRegisterInstr(source_loc.fpu_reg());
+      deopt_instr =
+          new(isolate()) DeoptFloat32x4FpuRegisterInstr(source_loc.fpu_reg());
     } else if (value->definition()->representation() == kUnboxedInt32x4) {
-      deopt_instr = new DeoptInt32x4FpuRegisterInstr(source_loc.fpu_reg());
+      deopt_instr =
+          new(isolate()) DeoptInt32x4FpuRegisterInstr(source_loc.fpu_reg());
     } else {
       ASSERT(value->definition()->representation() == kUnboxedFloat64x2);
-      deopt_instr = new DeoptFloat64x2FpuRegisterInstr(source_loc.fpu_reg());
+      deopt_instr =
+          new(isolate()) DeoptFloat64x2FpuRegisterInstr(source_loc.fpu_reg());
     }
   } else if (source_loc.IsStackSlot()) {
     ASSERT(value->definition()->representation() == kTagged);
     intptr_t source_index = CalculateStackIndex(source_loc);
-    deopt_instr = new DeoptStackSlotInstr(source_index);
+    deopt_instr = new(isolate()) DeoptStackSlotInstr(source_index);
   } else if (source_loc.IsDoubleStackSlot()) {
     intptr_t source_index = CalculateStackIndex(source_loc);
     if (value->definition()->representation() == kUnboxedDouble) {
-      deopt_instr = new DeoptDoubleStackSlotInstr(source_index);
+      deopt_instr = new(isolate()) DeoptDoubleStackSlotInstr(source_index);
     } else {
       ASSERT(value->definition()->representation() == kUnboxedMint);
-      deopt_instr = new DeoptInt64StackSlotInstr(source_index);
+      deopt_instr = new(isolate()) DeoptInt64StackSlotInstr(source_index);
     }
   } else if (source_loc.IsQuadStackSlot()) {
     intptr_t source_index = CalculateStackIndex(source_loc);
     if (value->definition()->representation() == kUnboxedFloat32x4) {
-      deopt_instr = new DeoptFloat32x4StackSlotInstr(source_index);
+      deopt_instr = new(isolate()) DeoptFloat32x4StackSlotInstr(source_index);
     } else if (value->definition()->representation() == kUnboxedInt32x4) {
-      deopt_instr = new DeoptInt32x4StackSlotInstr(source_index);
+      deopt_instr = new(isolate()) DeoptInt32x4StackSlotInstr(source_index);
     } else {
       ASSERT(value->definition()->representation() == kUnboxedFloat64x2);
-      deopt_instr = new DeoptFloat64x2StackSlotInstr(source_index);
+      deopt_instr = new(isolate()) DeoptFloat64x2StackSlotInstr(source_index);
     }
   } else if (source_loc.IsPairLocation()) {
     ASSERT(value->definition()->representation() == kUnboxedMint);
     // There are four cases to consider here:
     // (R = Register, S = Stack slot).
     // 1) R, R.
     // 2) S, S.
     // 3) R, S.
     // 4) S, R.
     PairLocation* pair = source_loc.AsPairLocation();
     if (pair->At(0).IsRegister() && pair->At(1).IsRegister()) {
-      deopt_instr = new DeoptInt64RegisterPairInstr(pair->At(0).reg(),
-                                                    pair->At(1).reg());
+      deopt_instr =
+          new(isolate()) DeoptInt64RegisterPairInstr(pair->At(0).reg(),
+                                                     pair->At(1).reg());
     } else if (pair->At(0).IsStackSlot() && pair->At(1).IsStackSlot()) {
-      deopt_instr = new DeoptInt64StackSlotPairInstr(
+      deopt_instr = new(isolate()) DeoptInt64StackSlotPairInstr(
           CalculateStackIndex(pair->At(0)),
           CalculateStackIndex(pair->At(1)));
     } else if (pair->At(0).IsRegister() && pair->At(1).IsStackSlot()) {
-      deopt_instr = new DeoptInt64StackSlotRegisterInstr(
+      deopt_instr = new(isolate()) DeoptInt64StackSlotRegisterInstr(
           CalculateStackIndex(pair->At(1)),
           pair->At(0).reg(),
           true);
     } else {
       ASSERT(pair->At(0).IsStackSlot() && pair->At(1).IsRegister());
-      deopt_instr = new DeoptInt64StackSlotRegisterInstr(
+      deopt_instr = new(isolate()) DeoptInt64StackSlotRegisterInstr(
           CalculateStackIndex(pair->At(0)),
           pair->At(1).reg(),
           false);
     }
   } else if (source_loc.IsInvalid() &&
              value->definition()->IsMaterializeObject()) {
     const intptr_t index = FindMaterialization(
         value->definition()->AsMaterializeObject());
     ASSERT(index >= 0);
-    deopt_instr = new DeoptMaterializedObjectRefInstr(index);
+    deopt_instr = new(isolate()) DeoptMaterializedObjectRefInstr(index);
   } else {
     UNREACHABLE();
   }
   ASSERT(dest_index == FrameSize());
   ASSERT(deopt_instr != NULL);
   instructions_.Add(deopt_instr);
 }
 
 
 void DeoptInfoBuilder::AddCallerFp(intptr_t dest_index) {
   ASSERT(dest_index == FrameSize());
-  instructions_.Add(new DeoptCallerFpInstr());
+  instructions_.Add(new(isolate()) DeoptCallerFpInstr());
 }
 
 
 void DeoptInfoBuilder::AddCallerPp(intptr_t dest_index) {
   ASSERT(dest_index == FrameSize());
-  instructions_.Add(new DeoptCallerPpInstr());
+  instructions_.Add(new(isolate()) DeoptCallerPpInstr());
 }
 
 
 void DeoptInfoBuilder::AddCallerPc(intptr_t dest_index) {
   ASSERT(dest_index == FrameSize());
-  instructions_.Add(new DeoptCallerPcInstr());
+  instructions_.Add(new(isolate()) DeoptCallerPcInstr());
 }
 
 
 void DeoptInfoBuilder::AddConstant(const Object& obj, intptr_t dest_index) {
   ASSERT(dest_index == FrameSize());
   intptr_t object_table_index = FindOrAddObjectInTable(obj);
-  instructions_.Add(new DeoptConstantInstr(object_table_index));
+  instructions_.Add(new(isolate()) DeoptConstantInstr(object_table_index));
 }
 
 
 void DeoptInfoBuilder::AddMaterialization(MaterializeObjectInstr* mat) {
   const intptr_t index = FindMaterialization(mat);
   if (index >= 0) {
     return;  // Already added.
   }
   materializations_.Add(mat);
 
   // Count initialized fields and emit kMaterializeObject instruction.
   // There is no need to write nulls into fields because object is null
   // initialized by default.
   intptr_t non_null_fields = 0;
   for (intptr_t i = 0; i < mat->InputCount(); i++) {
     if (!mat->InputAt(i)->BindsToConstantNull()) {
       non_null_fields++;
     }
   }
 
-  instructions_.Add(new DeoptMaterializeObjectInstr(non_null_fields));
+  instructions_.Add(
+      new(isolate()) DeoptMaterializeObjectInstr(non_null_fields));
 }
 
 
 intptr_t DeoptInfoBuilder::EmitMaterializationArguments(intptr_t dest_index) {
   ASSERT(dest_index == kDartFrameFixedSize);
   for (intptr_t i = 0; i < materializations_.length(); i++) {
     MaterializeObjectInstr* mat = materializations_[i];
     // Class of the instance to allocate.
     AddConstant(mat->cls(), dest_index++);
     for (intptr_t i = 0; i < mat->InputCount(); i++) {
@@ skipping 37 matching lines @@
       TrieNode* node = suffix->FindChild(*instructions_[i]);
       if (node == NULL) break;
       suffix = node;
       ++suffix_length;
     }
   }
 
   // Allocate space for the translation.  If the shared suffix is longer
   // than one instruction, we replace it with a single suffix instruction.
   if (suffix_length > 1) length -= (suffix_length - 1);
-  const DeoptInfo& deopt_info = DeoptInfo::Handle(DeoptInfo::New(length));
+  const DeoptInfo& deopt_info =
+      DeoptInfo::Handle(isolate(), DeoptInfo::New(length));
 
   // Write the unshared instructions and build their sub-tree.
   TrieNode* node = NULL;
   intptr_t write_count = (suffix_length > 1) ? length - 1 : length;
   for (intptr_t i = 0; i < write_count; ++i) {
     DeoptInstr* instr = instructions_[i];
     deopt_info.SetAt(i, instr->kind(), instr->source_index());
     TrieNode* child = node;
-    node = new TrieNode(instr, current_info_number_);
+    node = new(isolate()) TrieNode(instr, current_info_number_);
     node->AddChild(child);
   }
 
   if (suffix_length > 1) {
     suffix->AddChild(node);
     DeoptInstr* instr =
-        new DeoptSuffixInstr(suffix->info_number(), suffix_length);
+        new(isolate()) DeoptSuffixInstr(suffix->info_number(), suffix_length);
     deopt_info.SetAt(length - 1, instr->kind(), instr->source_index());
   } else {
     trie_root_->AddChild(node);
   }
 
   ASSERT(deopt_info.VerifyDecompression(instructions_, deopt_table));
   instructions_.Clear();
   materializations_.Clear();
   frame_start_ = -1;
 
@@ skipping 30 matching lines @@
                           Smi* offset,
                           DeoptInfo* info,
                           Smi* reason) {
   intptr_t i = index * kEntrySize;
   *offset ^= table.At(i);
   *info ^= table.At(i + 1);
   *reason ^= table.At(i + 2);
 }
 
 }  // namespace dart