Remove TLS access for current Zone.

src/safepoint-table.cc

 // Copyright 2011 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 98 matching lines @@
 
 
 void SafepointTable::PrintBits(uint8_t byte, int digits) {
   ASSERT(digits >= 0 && digits <= kBitsPerByte);
   for (int i = 0; i < digits; i++) {
     PrintF("%c", ((byte & (1 << i)) == 0) ? '0' : '1');
   }
 }
 
 
-void Safepoint::DefinePointerRegister(Register reg) {
-  registers_->Add(reg.code());
+void Safepoint::DefinePointerRegister(Register reg, Zone* zone) {
+  registers_->Add(reg.code(), zone);
 }
 
 
 Safepoint SafepointTableBuilder::DefineSafepoint(
     Assembler* assembler,
     Safepoint::Kind kind,
     int arguments,
     Safepoint::DeoptMode deopt_mode) {
   ASSERT(arguments >= 0);
   DeoptimizationInfo info;
+  Zone* zone = assembler->zone();
   info.pc = assembler->pc_offset();
   info.arguments = arguments;
   info.has_doubles = (kind & Safepoint::kWithDoubles);
-  deoptimization_info_.Add(info);
-  deopt_index_list_.Add(Safepoint::kNoDeoptimizationIndex);
+  deoptimization_info_.Add(info, zone);
+  deopt_index_list_.Add(Safepoint::kNoDeoptimizationIndex, zone);
   if (deopt_mode == Safepoint::kNoLazyDeopt) {
     last_lazy_safepoint_ = deopt_index_list_.length();
   }
-  indexes_.Add(new ZoneList<int>(8));
+  indexes_.Add(new(zone) ZoneList<int>(8, zone), zone);
   registers_.Add((kind & Safepoint::kWithRegisters)
-      ? new ZoneList<int>(4)
-      : NULL);
+      ? new(zone) ZoneList<int>(4, zone)
+      : NULL,
+      zone);
   return Safepoint(indexes_.last(), registers_.last());
 }
 
 
 void SafepointTableBuilder::RecordLazyDeoptimizationIndex(int index) {
   while (last_lazy_safepoint_ < deopt_index_list_.length()) {
     deopt_index_list_[last_lazy_safepoint_++] = index;
   }
 }
 
 unsigned SafepointTableBuilder::GetCodeOffset() const {
   ASSERT(emitted_);
   return offset_;
 }
 
 
 void SafepointTableBuilder::Emit(Assembler* assembler, int bits_per_entry) {
   // For lazy deoptimization we need space to patch a call after every call.
   // Ensure there is always space for such patching, even if the code ends
   // in a call.
+  Zone* zone = assembler->zone();
   int target_offset = assembler->pc_offset() + Deoptimizer::patch_size();
   while (assembler->pc_offset() < target_offset) {
     assembler->nop();
   }
 
   // Make sure the safepoint table is properly aligned. Pad with nops.
   assembler->Align(kIntSize);
   assembler->RecordComment(";;; Safepoint table.");
   offset_ = assembler->pc_offset();
 
@@ skipping 10 matching lines @@
   assembler->dd(bytes_per_entry);
 
   // Emit sorted table of pc offsets together with deoptimization indexes.
   for (int i = 0; i < length; i++) {
     assembler->dd(deoptimization_info_[i].pc);
     assembler->dd(EncodeExceptPC(deoptimization_info_[i],
                                  deopt_index_list_[i]));
   }
 
   // Emit table of bitmaps.
-  ZoneList<uint8_t> bits(bytes_per_entry);
+  ZoneList<uint8_t> bits(bytes_per_entry, zone);
   for (int i = 0; i < length; i++) {
     ZoneList<int>* indexes = indexes_[i];
     ZoneList<int>* registers = registers_[i];
     bits.Clear();
-    bits.AddBlock(0, bytes_per_entry);
+    bits.AddBlock(0, bytes_per_entry, zone);
 
     // Run through the registers (if any).
     ASSERT(IsAligned(kNumSafepointRegisters, kBitsPerByte));
     if (registers == NULL) {
       const int num_reg_bytes = kNumSafepointRegisters >> kBitsPerByteLog2;
       for (int j = 0; j < num_reg_bytes; j++) {
         bits[j] = SafepointTable::kNoRegisters;
       }
     } else {
       for (int j = 0; j < registers->length(); j++) {
@@ skipping 26 matching lines @@
                                                unsigned index) {
   uint32_t encoding = SafepointEntry::DeoptimizationIndexField::encode(index);
   encoding |= SafepointEntry::ArgumentsField::encode(info.arguments);
   encoding |= SafepointEntry::SaveDoublesField::encode(info.has_doubles);
   return encoding;
 }
 
 
 
 } }  // namespace v8::internal