Remove TLS access for current Zone.

src/small-pointer-list.h

 // 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 26 matching lines @@
 
 // SmallPointerList is a list optimized for storing no or just a
 // single value. When more values are given it falls back to ZoneList.
 //
 // The interface tries to be as close to List from list.h as possible.
 template <typename T>
 class SmallPointerList {
  public:
   SmallPointerList() : data_(kEmptyTag) {}
 
-  explicit SmallPointerList(int capacity) : data_(kEmptyTag) {
-    Reserve(capacity);
+  SmallPointerList(int capacity, Zone* zone) : data_(kEmptyTag) {
+    Reserve(capacity, zone);
   }
 
-  void Reserve(int capacity) {
+  void Reserve(int capacity, Zone* zone) {
     if (capacity < 2) return;
     if ((data_ & kTagMask) == kListTag) {
       if (list()->capacity() >= capacity) return;
       int old_length = list()->length();
-      list()->AddBlock(NULL, capacity - list()->capacity());
+      list()->AddBlock(NULL, capacity - list()->capacity(), zone);
       list()->Rewind(old_length);
       return;
     }
-    PointerList* list = new PointerList(capacity);
+    PointerList* list = new(zone) PointerList(capacity, zone);
     if ((data_ & kTagMask) == kSingletonTag) {
-      list->Add(single_value());
+      list->Add(single_value(), zone);
     }
     ASSERT(IsAligned(reinterpret_cast<intptr_t>(list), kPointerAlignment));
     data_ = reinterpret_cast<intptr_t>(list) | kListTag;
   }
 
   void Clear() {
     data_ = kEmptyTag;
   }
 
   void Sort() {
     if ((data_ & kTagMask) == kListTag) {
       list()->Sort(compare_value);
     }
   }
 
   bool is_empty() const { return length() == 0; }
 
   int length() const {
     if ((data_ & kTagMask) == kEmptyTag) return 0;
     if ((data_ & kTagMask) == kSingletonTag) return 1;
     return list()->length();
   }
 
-  void Add(T* pointer) {
+  void Add(T* pointer, Zone* zone) {
     ASSERT(IsAligned(reinterpret_cast<intptr_t>(pointer), kPointerAlignment));
     if ((data_ & kTagMask) == kEmptyTag) {
       data_ = reinterpret_cast<intptr_t>(pointer) | kSingletonTag;
       return;
     }
     if ((data_ & kTagMask) == kSingletonTag) {
-      PointerList* list = new PointerList(2);
-      list->Add(single_value());
-      list->Add(pointer);
+      PointerList* list = new(zone) PointerList(2, zone);
+      list->Add(single_value(), zone);
+      list->Add(pointer, zone);
       ASSERT(IsAligned(reinterpret_cast<intptr_t>(list), kPointerAlignment));
       data_ = reinterpret_cast<intptr_t>(list) | kListTag;
       return;
     }
-    list()->Add(pointer);
+    list()->Add(pointer, zone);
   }
 
   // Note: returns T* and not T*& (unlike List from list.h).
   // This makes the implementation simpler and more const correct.
   T* at(int i) const {
     ASSERT((data_ & kTagMask) != kEmptyTag);
     if ((data_ & kTagMask) == kSingletonTag) {
       ASSERT(i == 0);
       return single_value();
     }
@@ skipping 78 matching lines @@
   }
 
   intptr_t data_;
 
   DISALLOW_COPY_AND_ASSIGN(SmallPointerList);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SMALL_POINTER_LIST_H_