Remove TLS access for current Zone.

src/lithium-allocator.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 212 matching lines @@
   while (pos != NULL && !pos->HasHint()) pos = pos->next();
   return pos;
 }
 
 
 LOperand* LiveRange::CreateAssignedOperand(Zone* zone) {
   LOperand* op = NULL;
   if (HasRegisterAssigned()) {
     ASSERT(!IsSpilled());
     if (IsDouble()) {
-      op = LDoubleRegister::Create(assigned_register());
+      op = LDoubleRegister::Create(assigned_register(), zone);
     } else {
-      op = LRegister::Create(assigned_register());
+      op = LRegister::Create(assigned_register(), zone);
     }
   } else if (IsSpilled()) {
     ASSERT(!HasRegisterAssigned());
     op = TopLevel()->GetSpillOperand();
     ASSERT(!op->IsUnallocated());
   } else {
     LUnallocated* unalloc = new(zone) LUnallocated(LUnallocated::NONE);
     unalloc->set_virtual_register(id_);
     op = unalloc;
   }
@@ skipping 280 matching lines @@
       b = b->next();
     }
   }
   return LifetimePosition::Invalid();
 }
 
 
 LAllocator::LAllocator(int num_values, HGraph* graph)
     : zone_(graph->zone()),
       chunk_(NULL),
-      live_in_sets_(graph->blocks()->length()),
-      live_ranges_(num_values * 2),
+      live_in_sets_(graph->blocks()->length(), zone_),
+      live_ranges_(num_values * 2, zone_),
       fixed_live_ranges_(NULL),
       fixed_double_live_ranges_(NULL),
-      unhandled_live_ranges_(num_values * 2),
-      active_live_ranges_(8),
-      inactive_live_ranges_(8),
-      reusable_slots_(8),
+      unhandled_live_ranges_(num_values * 2, zone_),
+      active_live_ranges_(8, zone_),
+      inactive_live_ranges_(8, zone_),
+      reusable_slots_(8, zone_),
       next_virtual_register_(num_values),
       first_artificial_register_(num_values),
       mode_(GENERAL_REGISTERS),
       num_registers_(-1),
       graph_(graph),
       has_osr_entry_(false),
       allocation_ok_(true) { }
 
 
 void LAllocator::InitializeLivenessAnalysis() {
   // Initialize the live_in sets for each block to NULL.
   int block_count = graph_->blocks()->length();
-  live_in_sets_.Initialize(block_count);
-  live_in_sets_.AddBlock(NULL, block_count);
+  live_in_sets_.Initialize(block_count, zone());
+  live_in_sets_.AddBlock(NULL, block_count, zone());
 }
 
 
 BitVector* LAllocator::ComputeLiveOut(HBasicBlock* block) {
   // Compute live out for the given block, except not including backward
   // successor edges.
   BitVector* live_out = new(zone_) BitVector(next_virtual_register_, zone_);
 
   // Process all successor blocks.
   for (HSuccessorIterator it(block->end()); !it.Done(); it.Advance()) {
@@ skipping 55 matching lines @@
   } else if (operand->policy() == LUnallocated::FIXED_DOUBLE_REGISTER) {
     int reg_index = operand->fixed_index();
     operand->ConvertTo(LOperand::DOUBLE_REGISTER, reg_index);
   } else {
     UNREACHABLE();
   }
   if (is_tagged) {
     TraceAlloc("Fixed reg is tagged at %d\n", pos);
     LInstruction* instr = InstructionAt(pos);
     if (instr->HasPointerMap()) {
-      instr->pointer_map()->RecordPointer(operand);
+      instr->pointer_map()->RecordPointer(operand, zone());
     }
   }
   return operand;
 }
 
 
 LiveRange* LAllocator::FixedLiveRangeFor(int index) {
   ASSERT(index < Register::kNumAllocatableRegisters);
   LiveRange* result = fixed_live_ranges_[index];
   if (result == NULL) {
@@ skipping 14 matching lines @@
     ASSERT(result->IsFixed());
     result->set_assigned_register(index, DOUBLE_REGISTERS, zone_);
     fixed_double_live_ranges_[index] = result;
   }
   return result;
 }
 
 
 LiveRange* LAllocator::LiveRangeFor(int index) {
   if (index >= live_ranges_.length()) {
-    live_ranges_.AddBlock(NULL, index - live_ranges_.length() + 1);
+    live_ranges_.AddBlock(NULL, index - live_ranges_.length() + 1, zone());
   }
   LiveRange* result = live_ranges_[index];
   if (result == NULL) {
     result = new(zone_) LiveRange(index, zone_);
     live_ranges_[index] = result;
   }
   return result;
 }
 
 
@@ skipping 60 matching lines @@
     range->AddUsePosition(position, unalloc_operand, zone_)->set_hint(hint);
   }
   range->AddUseInterval(block_start, position, zone_);
 }
 
 
 void LAllocator::AddConstraintsGapMove(int index,
                                        LOperand* from,
                                        LOperand* to) {
   LGap* gap = GapAt(index);
-  LParallelMove* move = gap->GetOrCreateParallelMove(LGap::START);
+  LParallelMove* move = gap->GetOrCreateParallelMove(LGap::START, zone());
   if (from->IsUnallocated()) {
     const ZoneList<LMoveOperands>* move_operands = move->move_operands();
     for (int i = 0; i < move_operands->length(); ++i) {
       LMoveOperands cur = move_operands->at(i);
       LOperand* cur_to = cur.destination();
       if (cur_to->IsUnallocated()) {
         if (LUnallocated::cast(cur_to)->virtual_register() ==
             LUnallocated::cast(from)->virtual_register()) {
-          move->AddMove(cur.source(), to);
+          move->AddMove(cur.source(), to, zone());
           return;
         }
       }
     }
   }
-  move->AddMove(from, to);
+  move->AddMove(from, to, zone());
 }
 
 
 void LAllocator::MeetRegisterConstraints(HBasicBlock* block) {
   int start = block->first_instruction_index();
   int end = block->last_instruction_index();
   for (int i = start; i <= end; ++i) {
     if (IsGapAt(i)) {
       LInstruction* instr = NULL;
       LInstruction* prev_instr = NULL;
@@ skipping 18 matching lines @@
       }
     }
   }
 
   // Handle fixed output operand.
   if (first != NULL && first->Output() != NULL) {
     LUnallocated* first_output = LUnallocated::cast(first->Output());
     LiveRange* range = LiveRangeFor(first_output->virtual_register());
     bool assigned = false;
     if (first_output->HasFixedPolicy()) {
-      LUnallocated* output_copy = first_output->CopyUnconstrained();
+      LUnallocated* output_copy = first_output->CopyUnconstrained(zone());
       bool is_tagged = HasTaggedValue(first_output->virtual_register());
       AllocateFixed(first_output, gap_index, is_tagged);
 
       // This value is produced on the stack, we never need to spill it.
       if (first_output->IsStackSlot()) {
         range->SetSpillOperand(first_output);
         range->SetSpillStartIndex(gap_index - 1);
         assigned = true;
       }
       chunk_->AddGapMove(gap_index, first_output, output_copy);
     }
 
     if (!assigned) {
       range->SetSpillStartIndex(gap_index);
 
       // This move to spill operand is not a real use. Liveness analysis
       // and splitting of live ranges do not account for it.
       // Thus it should be inserted to a lifetime position corresponding to
       // the instruction end.
       LGap* gap = GapAt(gap_index);
-      LParallelMove* move = gap->GetOrCreateParallelMove(LGap::BEFORE);
-      move->AddMove(first_output, range->GetSpillOperand());
+      LParallelMove* move = gap->GetOrCreateParallelMove(LGap::BEFORE, zone());
+      move->AddMove(first_output, range->GetSpillOperand(), zone());
     }
   }
 
   // Handle fixed input operands of second instruction.
   if (second != NULL) {
     for (UseIterator it(second); !it.Done(); it.Advance()) {
       LUnallocated* cur_input = LUnallocated::cast(it.Current());
       if (cur_input->HasFixedPolicy()) {
-        LUnallocated* input_copy = cur_input->CopyUnconstrained();
+        LUnallocated* input_copy = cur_input->CopyUnconstrained(zone());
         bool is_tagged = HasTaggedValue(cur_input->virtual_register());
         AllocateFixed(cur_input, gap_index + 1, is_tagged);
         AddConstraintsGapMove(gap_index, input_copy, cur_input);
       } else if (cur_input->policy() == LUnallocated::WRITABLE_REGISTER) {
         // The live range of writable input registers always goes until the end
         // of the instruction.
         ASSERT(!cur_input->IsUsedAtStart());
 
-        LUnallocated* input_copy = cur_input->CopyUnconstrained();
+        LUnallocated* input_copy = cur_input->CopyUnconstrained(zone());
         cur_input->set_virtual_register(GetVirtualRegister());
         if (!AllocationOk()) return;
 
         if (RequiredRegisterKind(input_copy->virtual_register()) ==
             DOUBLE_REGISTERS) {
           double_artificial_registers_.Add(
               cur_input->virtual_register() - first_artificial_register_,
               zone_);
         }
 
         AddConstraintsGapMove(gap_index, input_copy, cur_input);
       }
     }
   }
 
   // Handle "output same as input" for second instruction.
   if (second != NULL && second->Output() != NULL) {
     LUnallocated* second_output = LUnallocated::cast(second->Output());
     if (second_output->HasSameAsInputPolicy()) {
       LUnallocated* cur_input = LUnallocated::cast(second->FirstInput());
       int output_vreg = second_output->virtual_register();
       int input_vreg = cur_input->virtual_register();
 
-      LUnallocated* input_copy = cur_input->CopyUnconstrained();
+      LUnallocated* input_copy = cur_input->CopyUnconstrained(zone());
       cur_input->set_virtual_register(second_output->virtual_register());
       AddConstraintsGapMove(gap_index, input_copy, cur_input);
 
       if (HasTaggedValue(input_vreg) && !HasTaggedValue(output_vreg)) {
         int index = gap_index + 1;
         LInstruction* instr = InstructionAt(index);
         if (instr->HasPointerMap()) {
-          instr->pointer_map()->RecordPointer(input_copy);
+          instr->pointer_map()->RecordPointer(input_copy, zone());
         }
       } else if (!HasTaggedValue(input_vreg) && HasTaggedValue(output_vreg)) {
         // The input is assumed to immediately have a tagged representation,
         // before the pointer map can be used. I.e. the pointer map at the
         // instruction will include the output operand (whose value at the
         // beginning of the instruction is equal to the input operand). If
         // this is not desired, then the pointer map at this instruction needs
         // to be adjusted manually.
       }
     }
   }
 }
 
 
 void LAllocator::ProcessInstructions(HBasicBlock* block, BitVector* live) {
   int block_start = block->first_instruction_index();
   int index = block->last_instruction_index();
 
   LifetimePosition block_start_position =
       LifetimePosition::FromInstructionIndex(block_start);
 
   while (index >= block_start) {
     LifetimePosition curr_position =
         LifetimePosition::FromInstructionIndex(index);
 
     if (IsGapAt(index)) {
       // We have a gap at this position.
       LGap* gap = GapAt(index);
-      LParallelMove* move = gap->GetOrCreateParallelMove(LGap::START);
+      LParallelMove* move = gap->GetOrCreateParallelMove(LGap::START, zone());
       const ZoneList<LMoveOperands>* move_operands = move->move_operands();
       for (int i = 0; i < move_operands->length(); ++i) {
         LMoveOperands* cur = &move_operands->at(i);
         if (cur->IsIgnored()) continue;
         LOperand* from = cur->source();
         LOperand* to = cur->destination();
         HPhi* phi = LookupPhi(to);
         LOperand* hint = to;
         if (phi != NULL) {
           // This is a phi resolving move.
@@ skipping 124 matching lines @@
       // can potentially cause a GC so they have a pointer map.
       // By inserting a move we essentially create a copy of a
       // value which is invisible to PopulatePointerMaps(), because we store
       // it into a location different from the operand of a live range
       // covering a branch instruction.
       // Thus we need to manually record a pointer.
       LInstruction* branch =
           InstructionAt(cur_block->last_instruction_index());
       if (branch->HasPointerMap()) {
         if (phi->representation().IsTagged()) {
-          branch->pointer_map()->RecordPointer(phi_operand);
+          branch->pointer_map()->RecordPointer(phi_operand, zone());
         } else if (!phi->representation().IsDouble()) {
-          branch->pointer_map()->RecordUntagged(phi_operand);
+          branch->pointer_map()->RecordUntagged(phi_operand, zone());
         }
       }
     }
 
     LiveRange* live_range = LiveRangeFor(phi->id());
     LLabel* label = chunk_->GetLabel(phi->block()->block_id());
-    label->GetOrCreateParallelMove(LGap::START)->
-        AddMove(phi_operand, live_range->GetSpillOperand());
+    label->GetOrCreateParallelMove(LGap::START, zone())->
+        AddMove(phi_operand, live_range->GetSpillOperand(), zone());
     live_range->SetSpillStartIndex(phi->block()->first_instruction_index());
   }
 }
 
 
 bool LAllocator::Allocate(LChunk* chunk) {
   ASSERT(chunk_ == NULL);
   chunk_ = chunk;
   MeetRegisterConstraints();
   if (!AllocationOk()) return false;
@@ skipping 74 matching lines @@
         // Some branch instructions (e.g. loops' back edges)
         // can potentially cause a GC so they have a pointer map.
         // By inserting a move we essentially create a copy of a
         // value which is invisible to PopulatePointerMaps(), because we store
         // it into a location different from the operand of a live range
         // covering a branch instruction.
         // Thus we need to manually record a pointer.
         LInstruction* branch = InstructionAt(pred->last_instruction_index());
         if (branch->HasPointerMap()) {
           if (HasTaggedValue(range->id())) {
-            branch->pointer_map()->RecordPointer(cur_op);
+            branch->pointer_map()->RecordPointer(cur_op, zone());
           } else if (!cur_op->IsDoubleStackSlot() &&
                      !cur_op->IsDoubleRegister()) {
             branch->pointer_map()->RemovePointer(cur_op);
           }
         }
       }
-      gap->GetOrCreateParallelMove(LGap::START)->AddMove(pred_op, cur_op);
+      gap->GetOrCreateParallelMove(
+          LGap::START, zone())->AddMove(pred_op, cur_op, zone());
     }
   }
 }
 
 
 LParallelMove* LAllocator::GetConnectingParallelMove(LifetimePosition pos) {
   int index = pos.InstructionIndex();
   if (IsGapAt(index)) {
     LGap* gap = GapAt(index);
     return gap->GetOrCreateParallelMove(
-        pos.IsInstructionStart() ? LGap::START : LGap::END);
+        pos.IsInstructionStart() ? LGap::START : LGap::END, zone());
   }
   int gap_pos = pos.IsInstructionStart() ? (index - 1) : (index + 1);
   return GapAt(gap_pos)->GetOrCreateParallelMove(
-      (gap_pos < index) ? LGap::AFTER : LGap::BEFORE);
+      (gap_pos < index) ? LGap::AFTER : LGap::BEFORE, zone());
 }
 
 
 HBasicBlock* LAllocator::GetBlock(LifetimePosition pos) {
   LGap* gap = GapAt(chunk_->NearestGapPos(pos.InstructionIndex()));
   return gap->block();
 }
 
 
 void LAllocator::ConnectRanges() {
@@ skipping 11 matching lines @@
         // boundary.
         if (first_range->End().Value() == pos.Value()) {
           bool should_insert = true;
           if (IsBlockBoundary(pos)) {
             should_insert = CanEagerlyResolveControlFlow(GetBlock(pos));
           }
           if (should_insert) {
             LParallelMove* move = GetConnectingParallelMove(pos);
             LOperand* prev_operand = first_range->CreateAssignedOperand(zone_);
             LOperand* cur_operand = second_range->CreateAssignedOperand(zone_);
-            move->AddMove(prev_operand, cur_operand);
+            move->AddMove(prev_operand, cur_operand, zone());
           }
         }
       }
 
       first_range = second_range;
       second_range = second_range->next();
     }
   }
 }
 
@@ skipping 44 matching lines @@
     const ZoneList<HPhi*>* phis = block->phis();
     for (int i = 0; i < phis->length(); ++i) {
       // The live range interval already ends at the first instruction of the
       // block.
       HPhi* phi = phis->at(i);
       live->Remove(phi->id());
 
       LOperand* hint = NULL;
       LOperand* phi_operand = NULL;
       LGap* gap = GetLastGap(phi->block()->predecessors()->at(0));
-      LParallelMove* move = gap->GetOrCreateParallelMove(LGap::START);
+      LParallelMove* move = gap->GetOrCreateParallelMove(LGap::START, zone());
       for (int j = 0; j < move->move_operands()->length(); ++j) {
         LOperand* to = move->move_operands()->at(j).destination();
         if (to->IsUnallocated() &&
             LUnallocated::cast(to)->virtual_register() == phi->id()) {
           hint = move->move_operands()->at(j).source();
           phi_operand = to;
           break;
         }
       }
       ASSERT(hint != NULL);
@@ skipping 130 matching lines @@
         cur = cur->next();
       }
       if (cur == NULL) continue;
 
       // Check if the live range is spilled and the safe point is after
       // the spill position.
       if (range->HasAllocatedSpillOperand() &&
           safe_point >= range->spill_start_index()) {
         TraceAlloc("Pointer for range %d (spilled at %d) at safe point %d\n",
                    range->id(), range->spill_start_index(), safe_point);
-        map->RecordPointer(range->GetSpillOperand());
+        map->RecordPointer(range->GetSpillOperand(), zone());
       }
 
       if (!cur->IsSpilled()) {
         TraceAlloc("Pointer in register for range %d (start at %d) "
                    "at safe point %d\n",
                    cur->id(), cur->Start().Value(), safe_point);
         LOperand* operand = cur->CreateAssignedOperand(zone_);
         ASSERT(!operand->IsStackSlot());
-        map->RecordPointer(operand);
+        map->RecordPointer(operand, zone());
       }
     }
   }
 }
 
 
 void LAllocator::ProcessOsrEntry() {
   const ZoneList<LInstruction*>* instrs = chunk_->instructions();
 
   // Linear search for the OSR entry instruction in the chunk.
@@ skipping 181 matching lines @@
       virtual_register - first_artificial_register_)) {
     return DOUBLE_REGISTERS;
   }
 
   return GENERAL_REGISTERS;
 }
 
 
 void LAllocator::AddToActive(LiveRange* range) {
   TraceAlloc("Add live range %d to active\n", range->id());
-  active_live_ranges_.Add(range);
+  active_live_ranges_.Add(range, zone());
 }
 
 
 void LAllocator::AddToInactive(LiveRange* range) {
   TraceAlloc("Add live range %d to inactive\n", range->id());
-  inactive_live_ranges_.Add(range);
+  inactive_live_ranges_.Add(range, zone());
 }
 
 
 void LAllocator::AddToUnhandledSorted(LiveRange* range) {
   if (range == NULL || range->IsEmpty()) return;
   ASSERT(!range->HasRegisterAssigned() && !range->IsSpilled());
   for (int i = unhandled_live_ranges_.length() - 1; i >= 0; --i) {
     LiveRange* cur_range = unhandled_live_ranges_.at(i);
     if (range->ShouldBeAllocatedBefore(cur_range)) {
       TraceAlloc("Add live range %d to unhandled at %d\n", range->id(), i + 1);
-      unhandled_live_ranges_.InsertAt(i + 1, range);
+      unhandled_live_ranges_.InsertAt(i + 1, range, zone());
       ASSERT(UnhandledIsSorted());
       return;
     }
   }
   TraceAlloc("Add live range %d to unhandled at start\n", range->id());
-  unhandled_live_ranges_.InsertAt(0, range);
+  unhandled_live_ranges_.InsertAt(0, range, zone());
   ASSERT(UnhandledIsSorted());
 }
 
 
 void LAllocator::AddToUnhandledUnsorted(LiveRange* range) {
   if (range == NULL || range->IsEmpty()) return;
   ASSERT(!range->HasRegisterAssigned() && !range->IsSpilled());
   TraceAlloc("Add live range %d to unhandled unsorted at end\n", range->id());
-  unhandled_live_ranges_.Add(range);
+  unhandled_live_ranges_.Add(range, zone());
 }
 
 
 static int UnhandledSortHelper(LiveRange* const* a, LiveRange* const* b) {
   ASSERT(!(*a)->ShouldBeAllocatedBefore(*b) ||
          !(*b)->ShouldBeAllocatedBefore(*a));
   if ((*a)->ShouldBeAllocatedBefore(*b)) return 1;
   if ((*b)->ShouldBeAllocatedBefore(*a)) return -1;
   return (*a)->id() - (*b)->id();
 }
@@ skipping 20 matching lines @@
 
 
 void LAllocator::FreeSpillSlot(LiveRange* range) {
   // Check that we are the last range.
   if (range->next() != NULL) return;
 
   if (!range->TopLevel()->HasAllocatedSpillOperand()) return;
 
   int index = range->TopLevel()->GetSpillOperand()->index();
   if (index >= 0) {
-    reusable_slots_.Add(range);
+    reusable_slots_.Add(range, zone());
   }
 }
 
 
 LOperand* LAllocator::TryReuseSpillSlot(LiveRange* range) {
   if (reusable_slots_.is_empty()) return NULL;
   if (reusable_slots_.first()->End().Value() >
       range->TopLevel()->Start().Value()) {
     return NULL;
   }
   LOperand* result = reusable_slots_.first()->TopLevel()->GetSpillOperand();
   reusable_slots_.Remove(0);
   return result;
 }
 
 
 void LAllocator::ActiveToHandled(LiveRange* range) {
   ASSERT(active_live_ranges_.Contains(range));
   active_live_ranges_.RemoveElement(range);
   TraceAlloc("Moving live range %d from active to handled\n", range->id());
   FreeSpillSlot(range);
 }
 
 
 void LAllocator::ActiveToInactive(LiveRange* range) {
   ASSERT(active_live_ranges_.Contains(range));
   active_live_ranges_.RemoveElement(range);
-  inactive_live_ranges_.Add(range);
+  inactive_live_ranges_.Add(range, zone());
   TraceAlloc("Moving live range %d from active to inactive\n", range->id());
 }
 
 
 void LAllocator::InactiveToHandled(LiveRange* range) {
   ASSERT(inactive_live_ranges_.Contains(range));
   inactive_live_ranges_.RemoveElement(range);
   TraceAlloc("Moving live range %d from inactive to handled\n", range->id());
   FreeSpillSlot(range);
 }
 
 
 void LAllocator::InactiveToActive(LiveRange* range) {
   ASSERT(inactive_live_ranges_.Contains(range));
   inactive_live_ranges_.RemoveElement(range);
-  active_live_ranges_.Add(range);
+  active_live_ranges_.Add(range, zone());
   TraceAlloc("Moving live range %d from inactive to active\n", range->id());
 }
 
 
 // TryAllocateFreeReg and AllocateBlockedReg assume this
 // when allocating local arrays.
 STATIC_ASSERT(DoubleRegister::kNumAllocatableRegisters >=
               Register::kNumAllocatableRegisters);
 
 
@@ skipping 346 matching lines @@
     LiveRange* current = live_ranges()->at(i);
     if (current != NULL) current->Verify();
   }
 }
 
 
 #endif
 
 
 } }  // namespace v8::internal