fixed-array.h 21.8 KB
Newer Older
1 2 3 4 5 6 7
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_OBJECTS_FIXED_ARRAY_H_
#define V8_OBJECTS_FIXED_ARRAY_H_

8
#include "src/handles/maybe-handles.h"
9
#include "src/objects/instance-type.h"
10
#include "src/objects/objects.h"
11
#include "src/objects/smi.h"
12
#include "torque-generated/class-definitions-tq.h"
13 14 15 16 17 18

// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"

namespace v8 {
namespace internal {
19

20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
#define FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(V)    \
  V(BYTECODE_ARRAY_CONSTANT_POOL_SUB_TYPE)       \
  V(BYTECODE_ARRAY_HANDLER_TABLE_SUB_TYPE)       \
  V(CODE_STUBS_TABLE_SUB_TYPE)                   \
  V(COMPILATION_CACHE_TABLE_SUB_TYPE)            \
  V(CONTEXT_SUB_TYPE)                            \
  V(COPY_ON_WRITE_SUB_TYPE)                      \
  V(DEOPTIMIZATION_DATA_SUB_TYPE)                \
  V(DESCRIPTOR_ARRAY_SUB_TYPE)                   \
  V(EMBEDDED_OBJECT_SUB_TYPE)                    \
  V(ENUM_CACHE_SUB_TYPE)                         \
  V(ENUM_INDICES_CACHE_SUB_TYPE)                 \
  V(DEPENDENT_CODE_SUB_TYPE)                     \
  V(DICTIONARY_ELEMENTS_SUB_TYPE)                \
  V(DICTIONARY_PROPERTIES_SUB_TYPE)              \
  V(EMPTY_PROPERTIES_DICTIONARY_SUB_TYPE)        \
  V(PACKED_ELEMENTS_SUB_TYPE)                    \
  V(FAST_PROPERTIES_SUB_TYPE)                    \
  V(FAST_TEMPLATE_INSTANTIATIONS_CACHE_SUB_TYPE) \
  V(HANDLER_TABLE_SUB_TYPE)                      \
  V(JS_COLLECTION_SUB_TYPE)                      \
  V(JS_WEAK_COLLECTION_SUB_TYPE)                 \
  V(NOSCRIPT_SHARED_FUNCTION_INFOS_SUB_TYPE)     \
  V(NUMBER_STRING_CACHE_SUB_TYPE)                \
  V(OBJECT_TO_CODE_SUB_TYPE)                     \
  V(OPTIMIZED_CODE_LITERALS_SUB_TYPE)            \
  V(OPTIMIZED_CODE_MAP_SUB_TYPE)                 \
  V(PROTOTYPE_USERS_SUB_TYPE)                    \
  V(REGEXP_MULTIPLE_CACHE_SUB_TYPE)              \
  V(RETAINED_MAPS_SUB_TYPE)                      \
  V(SCOPE_INFO_SUB_TYPE)                         \
  V(SCRIPT_LIST_SUB_TYPE)                        \
52
  V(SERIALIZED_OBJECTS_SUB_TYPE)                 \
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
  V(SHARED_FUNCTION_INFOS_SUB_TYPE)              \
  V(SINGLE_CHARACTER_STRING_CACHE_SUB_TYPE)      \
  V(SLOW_TEMPLATE_INSTANTIATIONS_CACHE_SUB_TYPE) \
  V(STRING_SPLIT_CACHE_SUB_TYPE)                 \
  V(TEMPLATE_INFO_SUB_TYPE)                      \
  V(FEEDBACK_METADATA_SUB_TYPE)                  \
  V(WEAK_NEW_SPACE_OBJECT_TO_CODE_SUB_TYPE)

enum FixedArraySubInstanceType {
#define DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE(name) name,
  FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE)
#undef DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE
      LAST_FIXED_ARRAY_SUB_TYPE = WEAK_NEW_SPACE_OBJECT_TO_CODE_SUB_TYPE
};

// Common superclass for FixedArrays that allow implementations to share
// common accessors and some code paths.
70 71
class FixedArrayBase
    : public TorqueGeneratedFixedArrayBase<FixedArrayBase, HeapObject> {
72 73
 public:
  // Get and set the length using acquire loads and release stores.
74
  DECL_SYNCHRONIZED_INT_ACCESSORS(length)
75

76
  inline Object unchecked_synchronized_length() const;
77

78 79
  static int GetMaxLengthForNewSpaceAllocation(ElementsKind kind);

80
  V8_EXPORT_PRIVATE bool IsCowArray() const;
81

82 83 84 85 86 87 88 89
  // Maximal allowed size, in bytes, of a single FixedArrayBase.
  // Prevents overflowing size computations, as well as extreme memory
  // consumption. It's either (512Mb - kTaggedSize) or (1024Mb - kTaggedSize).
  // -kTaggedSize is here to ensure that this max size always fits into Smi
  // which is necessary for being able to create a free space filler for the
  // whole array of kMaxSize.
  static const int kMaxSize = 128 * kTaggedSize * MB - kTaggedSize;
  STATIC_ASSERT(Smi::IsValid(kMaxSize));
90

91
 protected:
92 93 94
  TQ_OBJECT_CONSTRUCTORS(FixedArrayBase)
  inline FixedArrayBase(Address ptr,
                        HeapObject::AllowInlineSmiStorage allow_smi);
95 96
};

97
// FixedArray describes fixed-sized arrays with element type Object.
98 99
class FixedArray
    : public TorqueGeneratedFixedArray<FixedArray, FixedArrayBase> {
100 101
 public:
  // Setter and getter for elements.
102
  inline Object get(int index) const;
103
  inline Object get(const Isolate* isolate, int index) const;
104

105
  static inline Handle<Object> get(FixedArray array, int index,
106 107 108
                                   Isolate* isolate);

  // Return a grown copy if the index is bigger than the array's length.
109
  V8_EXPORT_PRIVATE static Handle<FixedArray> SetAndGrow(
110
      Isolate* isolate, Handle<FixedArray> array, int index,
111
      Handle<Object> value);
112

113 114 115 116 117 118 119
  // Synchronized setters and getters.
  inline Object synchronized_get(int index) const;
  inline Object synchronized_get(const Isolate* isolate, int index) const;
  // Currently only Smis are written with release semantics, hence we can avoid
  // a write barrier.
  inline void synchronized_set(int index, Smi value);

120
  // Setter that uses write barrier.
121
  inline void set(int index, Object value);
122 123 124
  inline bool is_the_hole(Isolate* isolate, int index);

  // Setter that doesn't need write barrier.
125
  inline void set(int index, Smi value);
126
  // Setter with explicit barrier mode.
127
  inline void set(int index, Object value, WriteBarrierMode mode);
128 129 130 131 132 133 134 135 136

  // Setters for frequently used oddballs located in old space.
  inline void set_undefined(int index);
  inline void set_undefined(Isolate* isolate, int index);
  inline void set_null(int index);
  inline void set_null(Isolate* isolate, int index);
  inline void set_the_hole(int index);
  inline void set_the_hole(Isolate* isolate, int index);

137
  inline ObjectSlot GetFirstElementAddress();
138 139 140
  inline bool ContainsOnlySmisOrHoles();

  // Gives access to raw memory which stores the array's data.
141 142
  inline ObjectSlot data_start();

143 144
  inline void MoveElements(Isolate* isolate, int dst_index, int src_index,
                           int len, WriteBarrierMode mode);
145

146
  inline void CopyElements(Isolate* isolate, int dst_index, FixedArray src,
147 148
                           int src_index, int len, WriteBarrierMode mode);

149 150
  inline void FillWithHoles(int from, int to);

151
  // Shrink the array and insert filler objects. {new_length} must be > 0.
152
  V8_EXPORT_PRIVATE void Shrink(Isolate* isolate, int new_length);
153 154
  // If {new_length} is 0, return the canonical empty FixedArray. Otherwise
  // like above.
155 156
  static Handle<FixedArray> ShrinkOrEmpty(Isolate* isolate,
                                          Handle<FixedArray> array,
157
                                          int new_length);
158 159

  // Copy a sub array from the receiver to dest.
160 161
  V8_EXPORT_PRIVATE void CopyTo(int pos, FixedArray dest, int dest_pos,
                                int len) const;
162 163 164

  // Garbage collection support.
  static constexpr int SizeFor(int length) {
165
    return kHeaderSize + length * kTaggedSize;
166 167 168
  }

  // Code Generation support.
169 170 171 172
  static constexpr int OffsetOfElementAt(int index) {
    STATIC_ASSERT(kObjectsOffset == SizeFor(0));
    return SizeFor(index);
  }
173 174

  // Garbage collection support.
175
  inline ObjectSlot RawFieldOfElementAt(int index);
176 177

  // Maximally allowed length of a FixedArray.
178
  static const int kMaxLength = (kMaxSize - kHeaderSize) / kTaggedSize;
179 180 181
  static_assert(Internals::IsValidSmi(kMaxLength),
                "FixedArray maxLength not a Smi");

182 183 184
  // Maximally allowed length for regular (non large object space) object.
  STATIC_ASSERT(kMaxRegularHeapObjectSize < kMaxSize);
  static const int kMaxRegularLength =
185
      (kMaxRegularHeapObjectSize - kHeaderSize) / kTaggedSize;
186 187 188 189

  // Dispatched behavior.
  DECL_PRINTER(FixedArray)

190 191 192
  int AllocatedSize();

  class BodyDescriptor;
193

194 195
  static constexpr int kObjectsOffset = kHeaderSize;

196 197 198
 protected:
  // Set operation on FixedArray without using write barriers. Can
  // only be used for storing old space objects or smis.
199
  static inline void NoWriteBarrierSet(FixedArray array, int index,
200
                                       Object value);
201 202 203 204

 private:
  STATIC_ASSERT(kHeaderSize == Internals::kFixedArrayHeaderSize);

205 206 207 208
  inline void set_undefined(ReadOnlyRoots ro_roots, int index);
  inline void set_null(ReadOnlyRoots ro_roots, int index);
  inline void set_the_hole(ReadOnlyRoots ro_roots, int index);

209
  TQ_OBJECT_CONSTRUCTORS(FixedArray)
210 211
};

212 213 214
// FixedArray alias added only because of IsFixedArrayExact() predicate, which
// checks for the exact instance type FIXED_ARRAY_TYPE instead of a range
// check: [FIRST_FIXED_ARRAY_TYPE, LAST_FIXED_ARRAY_TYPE].
215
class FixedArrayExact final : public FixedArray {};
216 217

// FixedDoubleArray describes fixed-sized arrays with element type double.
218 219
class FixedDoubleArray
    : public TorqueGeneratedFixedDoubleArray<FixedDoubleArray, FixedArrayBase> {
220 221 222 223
 public:
  // Setter and getter for elements.
  inline double get_scalar(int index);
  inline uint64_t get_representation(int index);
224
  static inline Handle<Object> get(FixedDoubleArray array, int index,
225 226 227 228 229 230 231 232 233 234 235 236 237 238
                                   Isolate* isolate);
  inline void set(int index, double value);
  inline void set_the_hole(Isolate* isolate, int index);
  inline void set_the_hole(int index);

  // Checking for the hole.
  inline bool is_the_hole(Isolate* isolate, int index);
  inline bool is_the_hole(int index);

  // Garbage collection support.
  inline static int SizeFor(int length) {
    return kHeaderSize + length * kDoubleSize;
  }

239 240
  inline void MoveElements(Isolate* isolate, int dst_index, int src_index,
                           int len, WriteBarrierMode mode);
241 242 243 244 245 246

  inline void FillWithHoles(int from, int to);

  // Code Generation support.
  static int OffsetOfElementAt(int index) { return SizeFor(index); }

247 248 249
  // Start offset of elements.
  static constexpr int kFloatsOffset = kHeaderSize;

250
  // Maximally allowed length of a FixedDoubleArray.
251
  static const int kMaxLength = (kMaxSize - kHeaderSize) / kDoubleSize;
252 253
  static_assert(Internals::IsValidSmi(kMaxLength),
                "FixedDoubleArray maxLength not a Smi");
254 255 256 257 258 259 260

  // Dispatched behavior.
  DECL_PRINTER(FixedDoubleArray)
  DECL_VERIFIER(FixedDoubleArray)

  class BodyDescriptor;

261
  TQ_OBJECT_CONSTRUCTORS(FixedDoubleArray)
262 263
};

264
// WeakFixedArray describes fixed-sized arrays with element type
265
// MaybeObject.
266 267
class WeakFixedArray
    : public TorqueGeneratedWeakFixedArray<WeakFixedArray, HeapObject> {
268
 public:
269
  inline MaybeObject Get(int index) const;
270
  inline MaybeObject Get(const Isolate* isolate, int index) const;
271

272 273 274
  inline void Set(
      int index, MaybeObject value,
      WriteBarrierMode mode = WriteBarrierMode::UPDATE_WRITE_BARRIER);
275 276

  // Get and set the length using acquire loads and release stores.
277
  DECL_SYNCHRONIZED_INT_ACCESSORS(length)
278 279

  // Gives access to raw memory which stores the array's data.
280
  inline MaybeObjectSlot data_start();
281

282
  inline MaybeObjectSlot RawFieldOfElementAt(int index);
283

284 285 286
  inline void CopyElements(Isolate* isolate, int dst_index, WeakFixedArray src,
                           int src_index, int len, WriteBarrierMode mode);

287
  DECL_PRINTER(WeakFixedArray)
288 289
  DECL_VERIFIER(WeakFixedArray)

290
  class BodyDescriptor;
291 292

  static const int kMaxLength =
293
      (FixedArray::kMaxSize - kHeaderSize) / kTaggedSize;
294 295
  static_assert(Internals::IsValidSmi(kMaxLength),
                "WeakFixedArray maxLength not a Smi");
296

297 298
  int AllocatedSize();

299
  static int OffsetOfElementAt(int index) {
300 301
    STATIC_ASSERT(kObjectsOffset == SizeFor(0));
    return SizeFor(index);
302 303
  }

304
 private:
305 306 307 308
  friend class Heap;

  static const int kFirstIndex = 1;

309
  TQ_OBJECT_CONSTRUCTORS(WeakFixedArray)
310 311
};

312 313 314 315 316
// WeakArrayList is like a WeakFixedArray with static convenience methods for
// adding more elements. length() returns the number of elements in the list and
// capacity() returns the allocated size. The number of elements is stored at
// kLengthOffset and is updated with every insertion. The array grows
// dynamically with O(1) amortized insertion.
317 318
class WeakArrayList
    : public TorqueGeneratedWeakArrayList<WeakArrayList, HeapObject> {
319
 public:
320
  NEVER_READ_ONLY_SPACE
321 322
  DECL_PRINTER(WeakArrayList)

323 324 325
  V8_EXPORT_PRIVATE static Handle<WeakArrayList> AddToEnd(
      Isolate* isolate, Handle<WeakArrayList> array,
      const MaybeObjectHandle& value);
326

327 328 329 330 331 332
  // A version that adds to elements. This ensures that the elements are
  // inserted atomically w.r.t GC.
  V8_EXPORT_PRIVATE static Handle<WeakArrayList> AddToEnd(
      Isolate* isolate, Handle<WeakArrayList> array,
      const MaybeObjectHandle& value1, const MaybeObjectHandle& value2);

333 334 335 336 337 338 339 340 341 342 343
  // Appends an element to the array and possibly compacts and shrinks live weak
  // references to the start of the collection. Only use this method when
  // indices to elements can change.
  static Handle<WeakArrayList> Append(
      Isolate* isolate, Handle<WeakArrayList> array,
      const MaybeObjectHandle& value,
      AllocationType allocation = AllocationType::kYoung);

  // Compact weak references to the beginning of the array.
  V8_EXPORT_PRIVATE void Compact(Isolate* isolate);

344
  inline MaybeObject Get(int index) const;
345
  inline MaybeObject Get(const Isolate* isolate, int index) const;
346 347

  // Set the element at index to obj. The underlying array must be large enough.
348
  // If you need to grow the WeakArrayList, use the static AddToEnd() method
349
  // instead.
350
  inline void Set(int index, MaybeObject value,
351 352 353
                  WriteBarrierMode mode = UPDATE_WRITE_BARRIER);

  static constexpr int SizeForCapacity(int capacity) {
354
    return SizeFor(capacity);
355 356
  }

357 358 359 360
  static constexpr int CapacityForLength(int length) {
    return length + Max(length / 2, 2);
  }

361
  // Gives access to raw memory which stores the array's data.
362
  inline MaybeObjectSlot data_start();
363

364 365 366
  inline void CopyElements(Isolate* isolate, int dst_index, WeakArrayList src,
                           int src_index, int len, WriteBarrierMode mode);

367
  V8_EXPORT_PRIVATE bool IsFull();
368 369

  // Get and set the capacity using acquire loads and release stores.
370
  DECL_SYNCHRONIZED_INT_ACCESSORS(capacity)
371

372
  int AllocatedSize();
373

374
  class BodyDescriptor;
375

376
  static const int kMaxCapacity =
377
      (FixedArray::kMaxSize - kHeaderSize) / kTaggedSize;
378

379 380
  static Handle<WeakArrayList> EnsureSpace(
      Isolate* isolate, Handle<WeakArrayList> array, int length,
381
      AllocationType allocation = AllocationType::kYoung);
382

383 384 385
  // Returns the number of non-cleaned weak references in the array.
  int CountLiveWeakReferences() const;

386 387 388
  // Returns the number of non-cleaned elements in the array.
  int CountLiveElements() const;

389 390 391 392
  // Returns whether an entry was found and removed. Will move the elements
  // around in the array - this method can only be used in cases where the user
  // doesn't care about the indices! Users should make sure there are no
  // duplicates.
393
  V8_EXPORT_PRIVATE bool RemoveOne(const MaybeObjectHandle& value);
394

395
  class Iterator;
396

397 398
 private:
  static int OffsetOfElementAt(int index) {
399
    return kHeaderSize + index * kTaggedSize;
400 401
  }

402
  TQ_OBJECT_CONSTRUCTORS(WeakArrayList)
403 404 405 406 407 408
};

class WeakArrayList::Iterator {
 public:
  explicit Iterator(WeakArrayList array) : index_(0), array_(array) {}

409
  inline HeapObject Next();
410 411 412 413 414 415 416 417

 private:
  int index_;
  WeakArrayList array_;
#ifdef DEBUG
  DisallowHeapAllocation no_gc_;
#endif  // DEBUG
  DISALLOW_COPY_AND_ASSIGN(Iterator);
418 419
};

420 421 422 423 424 425 426
// Generic array grows dynamically with O(1) amortized insertion.
//
// ArrayList is a FixedArray with static convenience methods for adding more
// elements. The Length() method returns the number of elements in the list, not
// the allocated size. The number of elements is stored at kLengthIndex and is
// updated with every insertion. The elements of the ArrayList are stored in the
// underlying FixedArray starting at kFirstIndex.
427
class ArrayList : public TorqueGeneratedArrayList<ArrayList, FixedArray> {
428
 public:
429 430 431 432 433 434 435
  V8_EXPORT_PRIVATE static Handle<ArrayList> Add(Isolate* isolate,
                                                 Handle<ArrayList> array,
                                                 Handle<Object> obj);
  V8_EXPORT_PRIVATE static Handle<ArrayList> Add(Isolate* isolate,
                                                 Handle<ArrayList> array,
                                                 Handle<Object> obj1,
                                                 Handle<Object> obj2);
436 437 438 439 440 441 442 443 444
  static Handle<ArrayList> New(Isolate* isolate, int size);

  // Returns the number of elements in the list, not the allocated size, which
  // is length(). Lower and upper case length() return different results!
  inline int Length() const;

  // Sets the Length() as used by Elements(). Does not change the underlying
  // storage capacity, i.e., length().
  inline void SetLength(int length);
445
  inline Object Get(int index) const;
446
  inline Object Get(const Isolate* isolate, int index) const;
447
  inline ObjectSlot Slot(int index);
448 449 450

  // Set the element at index to obj. The underlying array must be large enough.
  // If you need to grow the ArrayList, use the static Add() methods instead.
451
  inline void Set(int index, Object obj,
452 453 454
                  WriteBarrierMode mode = UPDATE_WRITE_BARRIER);

  // Set the element at index to undefined. This does not change the Length().
455
  inline void Clear(int index, Object undefined);
456 457 458

  // Return a copy of the list of size Length() without the first entry. The
  // number returned by Length() is stored in the first entry.
459
  static Handle<FixedArray> Elements(Isolate* isolate, Handle<ArrayList> array);
460

461 462
  static const int kHeaderFields = 1;

463
 private:
464 465
  static Handle<ArrayList> EnsureSpace(Isolate* isolate,
                                       Handle<ArrayList> array, int length);
466 467
  static const int kLengthIndex = 0;
  static const int kFirstIndex = 1;
468
  STATIC_ASSERT(kHeaderFields == kFirstIndex);
469
  TQ_OBJECT_CONSTRUCTORS(ArrayList)
470 471 472 473 474
};

enum SearchMode { ALL_ENTRIES, VALID_ENTRIES };

template <SearchMode search_mode, typename T>
475
inline int Search(T* array, Name name, int valid_entries = 0,
476 477
                  int* out_insertion_index = nullptr,
                  bool concurrent_search = false);
478 479 480

// ByteArray represents fixed sized byte arrays.  Used for the relocation info
// that is attached to code objects.
481
class ByteArray : public TorqueGeneratedByteArray<ByteArray, FixedArrayBase> {
482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
 public:
  inline int Size();

  // Setter and getter.
  inline byte get(int index) const;
  inline void set(int index, byte value);

  // Copy in / copy out whole byte slices.
  inline void copy_out(int index, byte* buffer, int length);
  inline void copy_in(int index, const byte* buffer, int length);

  // Treat contents as an int array.
  inline int get_int(int index) const;
  inline void set_int(int index, int value);

  inline uint32_t get_uint32(int index) const;
  inline void set_uint32(int index, uint32_t value);

500 501 502
  inline uint32_t get_uint32_relaxed(int index) const;
  inline void set_uint32_relaxed(int index, uint32_t value);

503 504 505 506 507 508 509 510 511 512 513 514
  // Clear uninitialized padding space. This ensures that the snapshot content
  // is deterministic.
  inline void clear_padding();

  static int SizeFor(int length) {
    return OBJECT_POINTER_ALIGN(kHeaderSize + length);
  }
  // We use byte arrays for free blocks in the heap.  Given a desired size in
  // bytes that is a multiple of the word size and big enough to hold a byte
  // array, this function returns the number of elements a byte array should
  // have.
  static int LengthFor(int size_in_bytes) {
515
    DCHECK(IsAligned(size_in_bytes, kTaggedSize));
516 517 518 519 520
    DCHECK_GE(size_in_bytes, kHeaderSize);
    return size_in_bytes - kHeaderSize;
  }

  // Returns data start address.
521
  inline byte* GetDataStartAddress();
522 523
  // Returns address of the past-the-end element.
  inline byte* GetDataEndAddress();
524 525 526 527

  inline int DataSize() const;

  // Returns a pointer to the ByteArray object for a given data start address.
528
  static inline ByteArray FromDataStartAddress(Address address);
529 530 531 532 533 534 535 536 537 538

  // Dispatched behavior.
  inline int ByteArraySize();
  DECL_PRINTER(ByteArray)

  // Layout description.
  static const int kAlignedSize = OBJECT_POINTER_ALIGN(kHeaderSize);

  // Maximal length of a single ByteArray.
  static const int kMaxLength = kMaxSize - kHeaderSize;
539 540
  static_assert(Internals::IsValidSmi(kMaxLength),
                "ByteArray maxLength not a Smi");
541 542 543

  class BodyDescriptor;

544
 protected:
545 546
  TQ_OBJECT_CONSTRUCTORS(ByteArray)
  inline ByteArray(Address ptr, HeapObject::AllowInlineSmiStorage allow_smi);
547 548 549 550 551 552 553
};

// Wrapper class for ByteArray which can store arbitrary C++ classes, as long
// as they can be copied with memcpy.
template <class T>
class PodArray : public ByteArray {
 public:
554 555 556
  static Handle<PodArray<T>> New(
      Isolate* isolate, int length,
      AllocationType allocation = AllocationType::kYoung);
557
  void copy_out(int index, T* result, int length) {
558
    ByteArray::copy_out(index * sizeof(T), reinterpret_cast<byte*>(result),
559
                        length * sizeof(T));
560
  }
561 562 563 564 565 566

  void copy_in(int index, const T* buffer, int length) {
    ByteArray::copy_in(index * sizeof(T), reinterpret_cast<const byte*>(buffer),
                       length * sizeof(T));
  }

567 568 569 570 571
  bool matches(const T* buffer, int length) {
    DCHECK_LE(length, this->length());
    return memcmp(GetDataStartAddress(), buffer, length * sizeof(T)) == 0;
  }

572 573
  T get(int index) {
    T result;
574
    copy_out(index, &result, 1);
575 576
    return result;
  }
577 578 579

  void set(int index, const T& value) { copy_in(index, &value, 1); }

580
  inline int length() const;
581
  DECL_CAST(PodArray<T>)
582

583
  OBJECT_CONSTRUCTORS(PodArray<T>, ByteArray);
584 585
};

586 587
class TemplateList
    : public TorqueGeneratedTemplateList<TemplateList, FixedArray> {
588 589 590
 public:
  static Handle<TemplateList> New(Isolate* isolate, int size);
  inline int length() const;
591
  inline Object get(int index) const;
592
  inline Object get(const Isolate* isolate, int index) const;
593
  inline void set(int index, Object value);
594 595 596 597 598
  static Handle<TemplateList> Add(Isolate* isolate, Handle<TemplateList> list,
                                  Handle<Object> value);
 private:
  static const int kLengthIndex = 0;
  static const int kFirstElementIndex = kLengthIndex + 1;
599

600
  TQ_OBJECT_CONSTRUCTORS(TemplateList)
601 602 603 604 605 606 607 608
};

}  // namespace internal
}  // namespace v8

#include "src/objects/object-macros-undef.h"

#endif  // V8_OBJECTS_FIXED_ARRAY_H_