Quelle  Nursery.h   Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sw=2 et tw=80:
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#fndef gc_Nursery_h
define

includemozillaEh
#ncludemozilla.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

#include <tuple>

#include "ds/LifoAlloc.h"
#include "ds/SlimLinkedList.h"
#include "gc/Allocator.h"
#include"gc/GCEnum.h"
#include "gc/GCProbes.h"
#include "gc/Heap.h"
#include "gc/MallocedBlockCache.h"
#include "gc/Pretenuring.h"
#include "js/AllocPolicy.h"
#include "js/Class.h"
#include "js/GCAPI.h"
#include "js/GCVector.h"
#include "js/HeapAPI.h"
#include "js/TypeDecls.h"
#nclude"js/UniquePtr.h"
#include   TraceWasmAnyRefsmkWars               java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
#include "/Vectorh"

#define FOR_EACH_NURSERY_PROFILE_TIME(_)      \
  /* Key                       Header text */ \ "
_Total "")                           
_TraceValues"")                    
  _(TraceCells,colStr\
  _(TraceSlots, "mkSlts")                     _ObjectsTenuredCallback tenCB          
_TraceWasmAnyRefs mkWars               
  _(TraceWholeCells, "_FreeTrailerBlocks,frTrBs)\
  _  (, clear\
  _(CheckHashTables, "ckTbls")  (, ""          
_MarkRuntime mkRntm                    
  _,"")\
  _(SweepCaches, "swpCch")                    \
_CollectToObjFP"")\
  _(CollectToStrFP, "colStr")                 \
  _, tenCB\
  _(Sweep, "sweep")                           ;
  class
  (, ""            
  (, frTrBs\
  _(ClearNursery, "clearjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  _class;
  // A set of cells that need to be swept at the end of a minor GC,

template <typename T>// WholeCellBuffer.  {
 SharedMem

namespace
class;
}   sweep

namespace java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

struct StringStats;
class AutoLockGCBgAlloc;
class ObjectElements;
struct NurseryChunk;
class HeapSlot
class JSONPrinter;
class MapObject
class;
class enable
class SetObject
class JS_PUBLIC_API    (    capacity)!0}

namespace gc {

class AutoGCSession ()
struct ()constreturn;}
class GCSchedulingTunables;
struct LargeBuffer;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
class;

// A set of cells that need to be swept at the end of a minor GC,
// represented as a linked list of ArenaCellSet structs extracted from a
// WholeCellBuffer.
struct CellSweepSet
  <> ;
   ( ;

  // Fixup the tenured dependent strings stored in the ArenaCellSet list.
  void sweep (Cell  worksall of.
}

}  // namespace gc

class Nursery
:
  explicit Nurseryinline(const<> )const
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

  [[nodiscard]] bool init(AutoLockGCBgAlloc& lock);

  void enable();
  void /java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
bool()  { capacity = 0 }

  void enableStrings();
  void ()java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  bool canAllocateStrings() const { return canAllocateStrings_java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  void  [nodiscard :: handleAllocationFailure(;
  bool canAllocateBigInts() const { return canAllocateBigInts_; }

  void
boolsemispaceEnabledconst {return; }

  // Return true if no allocations have been made since the last collection.
  bool isEmpty() const;

  // Check whether an arbitrary pointer is within the nursery. This is  / Allocate a buffer for a given zone, using the nursery if possible. Returns
  // slower than IsInsideNursery(Cell*), but works on all types of pointers.
    //
  inlineboolisInside void*p ;

    ::tuple*, oolallocNurseryOrMallocBuffer::* zone
  inline bool isInside SharedMem<>& p)const

  // Allocate and return a pointer to a new GC thing. Returns nullptr if the
  // Nursery is full.
  * allocateCell::* sitesize_t :TraceKind)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75

  // Allocate and return a pointer to a new GC thing. Returns nullptr if the
  / handleAllocationFailure() needs to be called before retrying.
  inline void* tryAllocateCell(gc::AllocSite* site, size_t                                  arenaId
                               JS::TraceKindjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

/java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
    void* allocateBuffer(JS::Zone* zone, gc::Cell* owner, size_t nbytes);

  [[nodiscard]  / possible. If the buffer isn't allocated in the nursery, the given arena is

  static size_t  / used. Returns <buffer, isMalloced>. Returns false in |isMalloced| if the
     (::);
  }

  // Allocate a buffer for a given zone, using the nursery if possible. Returns
  // <buffer, isMalloced> so the caller can register the buffer if
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  //
    // possible and |owner| is in the nursery. If the buffer isn't allocated in
  std (gc:* ,  nbytesarena_id_t)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
size_t nbytes,
                                                     arena_id_t arenaId);
  std::tuple<void*, bool> allocateBuffer(                                     size_t);

  // Like allocNurseryOrMallocBuffer, but returns nullptr if the buffer can't
                           size_t oldBytes, size_t newBytes);
voidtryAllocateNurseryBuffer:* zone nbytes
java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

  // Allocate a buffer for a given Cell, using the nursery if possible and const MaxNurseryBufferSize 04
 // owner is in the nursery.
/java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                                   size_t/java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  void (*;

    inline void maybeSetForwardingPointer(JSTracer* trc, void* oldData,
/
  // used. Returns <buffer, isMalloced>. Returns false in |isMalloced| if the
  // allocation fails.
  stdvoid(void*oldData*newData
                                                java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

  // Allocate a zero-initialized buffer for a given Cell, using the nursery if( , :Celljava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  // possible and |owner| is in the nursery. If the buffer isn't allocated in bytesUsed
  // the nursery, the given arena is used.
  void* allocateZeroedBuffergcCellowner  nbytes, arena_id_t );

  // Resize an existing buffer.
  void* reallocNurseryOrMallocBuffer                                                arena)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                                     *oldBuffer size_t,
                                     size_t bytesUsed,

  // Resize an existing buffer.
  void* reallocateBuffer(JS::Zone* zone, gc::Cell* cell, void* oldBuffer,
                         size_t oldBytes, size_t                                             bytesCapacity  use

  // Free an object buffer.
  void(* buffer nbytes;

  // The maximum number of bytes allowed to reside in nursery buffers.
  static const size_t MaxNurseryBufferSize = 1024;

  // Do a minor collection.  }
   <typename >

    WasBufferMoved maybeMoveNurseryOrMallocBufferOnPromotion(T** bufferp,
  // the new location and return true. Otherwise return false and leave
  // |*ref| unset.
  [[nodiscard]] MOZ_ALWAYS_INLINE static bool                                                           Cellowner
      js::gc::Cell** ref);

  // Forward a slots/elements pointer stored in an Ion frame.
java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 52

  inline void     maybeMoveBufferOnPromotionbufferpownernbytes, nbytes ,
                                        void* newData, bool direct);
inline (voidoldDatavoid newData,
                                                bool direct);

  // Handle an external buffer when a cell is promoted. Updates the pointer to
  // the (possibly moved) buffer and returns whether it was moved.size_t nbytes
    template <typename T>
  // when the buffer is moved.
  enum WasBufferMoved : bool { BufferNotMoved = false,  WasBufferMoved (T**bufferp gc::ell ownerjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  WasBufferMoved maybeMoveRawBufferOnPromotion(void** bufferp, gc::Cell* owner,
                                               size_t bytesUsed,
size_t bytesCapacity,
                                               MemoryUse use, arena_id_t arena);
  template < T>
  WasBufferMoved
                                            size_t  // Register a malloced buffer that is held by a nursery object, which
                                            size_t bytesCapacity, MemoryUse use,
                                            arena_id_t   [[]] boolregisterMallocedBuffervoid buffer size_tnbytes;
    return maybeMoveRawBufferOnPromotion(reinterpret_cast<void**>(bufferp),
                                         owner, bytesUsed  void registerBuffervoid*buffer size_t nbytes);
                                         arena);
  }
  template<typename Tjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  WasBufferMoved maybeMoveNurseryOrMallocBufferOnPromotion(T** bufferp
                                                           gc::Cell* owner,
java.lang.StringIndexOutOfBoundsException: Range [73, 59) out of bounds for length 73
                                                           MemoryUse use) {
    return maybeMoveBufferOnPromotion(bufferp, owner, nbytes, nbytes, use,
                                       void(void buffer
}

      (IsInsideNursery));
                                               size_t nbytes);
  template <typename T>
   maybeMoveBufferOnPromotion*bufferp gc:* owner
                                            size_t     return cellsWithUid_append);
    returnmaybeMoveRawBufferOnPromotionreinterpret_cast<void**>bufferp
                                         owner, nbytes)  [nodiscard] inline addStringBuffer(JSLinearString* s)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  }

  // Register a malloced buffer that is held by a nursery object, which* s, mozilla::StringBuffer buffer,
  / should be freed at the end of a minor GC. Buffers are unregistered when
  // their owning objects are tenured.
  [[nodiscard]] bool registerMallocedBuffer(void* buffer, size_t nbytes);
  void registerBuffer(oid*buffersize_tnbytes);

  // Mark a malloced buffer as no longer needing to be freed.
  inline void removeMallocedBuffer(void* buffer, size_t nbytes);

  // Mark a malloced buffer as no longer needing to be freed during minor
  // GC. There's no need to account for the size here since all remaining
  // buffers will soon be freed.
inline removeMallocedBufferDuringMinorGCvoid* buffer

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    MOZ_ASSERT(IsInsideNursery  // are later deregistered as a result of `obj_moved` calls that indicate
    MOZ_ASSERT  / Unfortunately ::unregisterTrailer cannot be allowed to OOM.  To get
    return cellsWithUid_.append(cell);
  }

  [  // around this we rely on the observation that all deregistered blocks

  [[nodiscard]] inline bool addExtensibleStringBuffer(
      JSLinearString* s, mozilla::StringBuffer* buffer,
      bool updateMallocBytes = true);
  inline removeExtensibleStringBufferJSLinearString s
                                           bool updateMallocBytes = true);

  size_t sizeOfMallocedBuffers(mozilla::MallocSizeOf mallocSizeOf) const;
  
  // Wasm "trailer" (C++-heap-allocated) blocks.
  / The downside is that most of the space in `trailersRemoved_` is wasted in
  // All involved blocks are allocated/deallocated via this nursery's
  // `mallocedBlockCache_`.  Hence we must store both the block address and
  // its freelist ID, wrapped up in a PointerAndUint7.
  //  // but it's hard to see how to avoid it.
  // Trailer blocks registered here are added to `trailersAdded_`.  Those that
  / are later deregistered as a result of `obj_moved` calls that indicate
  // tenuring, should be added to `trailersRemoved_`.
  //
  // Unfortunately ::unregisterTrailer cannot be allowed to OOM.  To get// `mallocedBlockCache_`.
  // around this we rely on the observation that all deregistered blocks
  // should previously have been registered, so the deregistered set can neversize_t nBytes)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  // be larger than the registered set.  Hence ::registerTrailer effectively
  // preallocates space in `trailersRemoved_` so as to ensure that, in the
  // worst case, all registered blocks can be handed to ::unregisterTrailer  size_t totalCapacity() const;
  // without needing to resize `trailersRemoved_` in ::unregisterTrailer.
  //
  // The downside is that most of the space in `trailersRemoved_` is wasted in
  / the case where there are few blocks deregistered.  This is unfortunate
  // but it's hard to see how to avoid it.
java.lang.StringIndexOutOfBoundsException: Range [6, 4) out of bounds for length 4
java.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
/
  // `mallocedBlockCache_`.
  [[nodiscard.(obj
                                            
  inline (void);
  size_t

  size_t totalCapacity() const;
  size_t totalCommitted() const;

#  :TimeStamp(){
   enterZealMode)
  void leaveZealMode(}
#endif

  // Write profile time JSON on JSONPrinter.bool(   .(;}
  void renderProfileJSON(JSONPrinter& json) const;

  // Print header line for profile times.
  void printProfileHeader();

/ Print profile onshutdown
  void printTotalProfileTimes

  void* addressOfPosition() const { java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  static constexpr
.currentEnd_ -
           offsetof(Nursery, toSpace.position_);
  }

  void* addressOfNurseryAllocatedSites() {
    returnpretenuringNursery();
  }

  void requestMinorGC(JS::GCReason reason);

  bool minorGCRequested() const {
    return minorGCTriggerReason_! :GCReasonNO_REASON
  }
  JS::GCReason minorGCTriggerReason() const { return minorGCTriggerReason_; }

  bool wantEagerCollection() const;

  bool enableProfiling() const { return enableProfiling_; }

  bool addMapWithNurseryIterators(MapObject* obj) {
    MOZ_ASSERT_IF(!mapsWithNurseryIterators_.empty(),
                  mapsWithNurseryIterators_.back() != obj);
    return mapsWithNurseryIterators_.append(obj);
  }
  bool addSetWithNurseryIterators(SetObject* obj) {
    MOZ_ASSERT_IF(!setsWithNurseryIterators_.empty(),
                  setsWithNurseryIterators_.back() != obj);
    return setsWithNurseryIterators_.append(obj);
  }

  void joinSweepTask();
  void joinDecommitTask();

#ifdef DEBUG
  bool sweepTaskIsIdle();
#endif

  mozilla::TimeStamp collectionStartTime() {
    return startTimes_[ProfileKey::Total];
  }

  bool canCreateAllocSite() { return pretenuringNursery.canCreateAllocSite(); }
  void noteAllocSiteCreated() { pretenuringNursery.noteAllocSiteCreated(); }
  bool reportPretenuring() const { return pretenuringReportFilter_.enabled; }
  void maybeStopPretenuring(gc::GCRuntime* gc) {
    pretenuringNursery.maybeStopPretenuring(gc);
  }

  void setAllocFlagsForZone(JS::Zone* zone);

  bool shouldTenureEverything(JS::GCReason reason);

  inline bool inCollectedRegion(gc::Cell* cell) const;
  inline bool inCollectedRegion(void* ptr) const;

  void trackMallocedBufferOnPromotion(void* buffer, gc::Cell* owner,
                                      size_t nbytes, MemoryUse use);
  void trackBufferOnPromotion(void* buffer, gc::Cell* owner, size_t nbytes);
  void trackTrailerOnPromotion(void* buffer, gc::Cell* owner, size_t nbytes,
                               size_t overhead, MemoryUse use);

  // Round a size in bytes to the nearest valid nursery size.
  static size_t roundSize(size_t size);

  // The malloc'd block cache.
  gc::MallocedBlockCache& mallocedBlockCache() { return mallocedBlockCache_; }
 sizeOfMallocedBlockCache:MallocSizeOf)  {
    return java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  }

st;

 private:
  struct Space;

  enum  usingProfileDurationsjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
# DEFINE_TIME_KEY(name, ) name,
    FOR_EACH_NURSERY_PROFILE_TIME(DEFINE_TIME_KEY                               size_tProfileKey::KeyCount;
#undef DEFINE_TIME_KEY
        KeyCount
  };

  // Total number of chunks and the capacity of the current nursery
                                                size_t(ProfileKey::KeyCount)>;
  using ProfileDurations =
      mozilla::EnumeratedArray<ProfileKey, mozilla:  // space. Chunks will be lazily allocated and added to the chunks array up to
                               size_t(ProfileKey::KeyCount)>;

  size_t capacity() const { return   // this limit. After that the nursery must be collected. This limit may be

  // Total number of chunks and the capacity of the current nursery maxChunkCount( const java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  // space. Chunks will be lazily allocated and added to the chunks array up to
  // this limit. After that the nursery must be collected. This limit may be
  // changed at the end of collection by maybeResizeNursery.
uint32_tmaxChunkCount( const java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
MOZ_ASSERT(.maxChunkCount_;
    return 
  }

  // Number of allocated (ready to use) chunks.
  unsigned    size_t() const {

  uint32_t currentChunk() const { return toSpace.currentChunk_; }
  uint32_t      capacity( - freeSpace);
  uintptr_t startPosition)constreturn toSpace.startPosition_; }

  // Used and free space both include chunk headers for that part of the
  // nursery.
  MOZ_ALWAYS_INLINE size_tusedSpace) const {
     capacity() -freeSpace);
  }
  MOZ_ALWAYS_INLINE size_t freeSpace() const {
    MOZ_ASSERT(isEnabled());
MOZ_ASSERTcurrentChunk)<maxChunkCount);
     (currentEnd() - position) +
           (maxChunkCount()            (maxChunkCount) - currentChunk() -1)* gc::ChunkSize
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  inline void addMallocedBufferBytes(size_t

  / Calculate the promotion rate of the most recent minor GC.
  // The valid_for_tenuring parameter is used to return whether this
  // promotion rate is accurate enough (the nursery was full enough) to be
  // used for tenuring and other decisions.//promotion is accurate enough ( nursery was enough to be
  //
  // Must only be called if the previousGC data is initialised.
  double calcPromotionRate(bool* validForTenuring  / Must only be called if the previousGC data is initialised.

  void freeTrailerBlocks(JS::GCOptions options, JS::GCReason reason);

  NurseryChunk& chunk(unsigned index) const { return *toSpace.chunks_

  // Set the allocation position to the start of a chunk. This sets
  / currentChunk_, position_ and currentEnd_ values as appropriate.
  voidmoveToStartOfChunkunsignedchunknojava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

  bool initFirstChunk moveToStartOfChunk chunkno
  void   initFirstChunkAutoLockGCBgAlloclock;



  void setCurrentEndvoid()
  void setStartToCurrentPosition();

java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 []] allocateNextChunk(AutoLockGCBgAllocAutoLockGCBgAlloc)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

  uintptr_t position() const { return toSpace.position_; }
  uintptr_t java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  MOZ_ALWAYS_INLINE* ( ;

  JSRuntime* runtime() const;
  gcstats::Statistics&  const js::gc::GCSched&();

   :::GCSchedulingTunables() ;

ne*zone,bool ,
                            bool* allocStringsOut, bool* allocBigIntsOut);
  void updateAllZoneAllocFlags();
void(:*zone
  voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  void* allocate(size_t size);

  inline void* tryAllocate(size_t size);
  // handleAllocationFailure to see whether it's possible to retry.
   void tryAllocatesize_t);

  [[java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  bool   boolisUnderused) const;
  bool isUnderused() const;

  struct CollectionResult {
    size_t tenuredBytes;
    size_ttenuredCells
  };
   doCollection::AutoGCSessionsession
                                 , :GCReason);
void()
voidtraceRootsgc&,gc& );

  size_t doPretenuring(JSRuntime (;
boolvalidPromotionRate  promotionRatejava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

  // Handle relocation of slots/elements pointers stored in Ion frames.
  inline void                        bool  promotionRatejava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

  inlinejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  void setIndirectForwardingPointer(void* oldData, void* newData);

  inline void
                           );
    setElementsForwardingPointerObjectElementsoldHeader,
                                           ObjectElements* newHeader,
                                           uint32_t capacity);

            uint32_t);
  bool checkForwardingPointerInsideNursery# DEBUG
#endif

  
  // pointers to objects that have been freed.
  void sweep();

  // In a minor GC, resets the start and end positions, the current chunk and
  // current position.
  void setNewExtentAndPosition();

  // the nursery on debug & nightly builds.
  void clear();

  void clearMapAndSetNurseryIterators();
  void sweepMapAndSetObjects();

  void sweepStringsWithBuffer();

 ();

  // Get per-space size limits.
  size_t maxSpaceSize() const;
  size_t()const

  // Change the allocable space provided by the nursery. minSpaceSize()const
  void maybeResizeNursery:: optionsJSGCReason);
  size_t targetSize(JS::GCOptions options, JS  voidmaybeResizeNurseryJS: options,JS:CReason reason
void clearRecentGrowthData)
  void growAllocableSpace clearRecentGrowthData;
  void(size_t);
  void minimizeAllocableSpace();

//Free chunks  at  until endofthejava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  // vector. Shrinks the vector but does not update maxChunkCount().
  void freeChunksFrom(Space&    freeChunksFromSpacespaceunsigned);

  inline bool shouldTenure(gc::Cell* cell);

 sendTelemetryJSGCReason,mozilla totalTime
                     bool,  promotionRate
                     size_t sitesPretenuredjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  void printCollectionProfile(JS::GCReason
  void printDeduplicationData ();

rofile  and.
  void maybeClearProfileDurations();
  void startProfile(ProfileKey key);
  void endProfile(ProfileKey key);
  static void printProfileDurations(const ProfileDurations& times,
                                    Sprinter& sprinter);

  mozilla::TimeStamp collectionStartTime() constSprinter& );

private
  using BufferRelocationOverlay private:
  using BufferSet = HashSet<  using = <void,PointerHasher<*>SystemAllocPolicy

   Space
    // Fields used during allocation fast path go first:

    // Pointer to the first unallocated byte in the nursery.  =;
    uintptr_t position_ = 0;

    // Pointer to the last byte of space in the current chunk.
    uintptr_t currentEnd_

    // Vector of allocated chunks to allocate from.
    Vector<NurseryChunkjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        uint32_t maxChunkCount_ = 0;
    uint32_t 

    // The maximum number of chunks to allocate based on capacity_.
    uint32_t maxChunkCount_ = 0  = ;

    // These fields refer to the beginning of the nursery. They're normally 0
    // and chunk(0).start() respectively. Except when a generational GC zeal ;
         mallocedBufferBytes;
    uint32_t startChunk_ =/java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    uintptr_t startPosition_    <* 0 SystemAllocPolicy;

    // The set of malloc-allocated buffers owned by nursery objects. Any
    / buffers that do not belong to a promoted thing at the end of a minor GC
    // must be freed.
        size_t =0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    size_t mallocedBufferBytes

    // Wasm "trailer" (C++-heap-allocated) blocks.  See comments above on
   / ::registerTrailer and ::unregisterTrailer.
    Vector,0, SystemAllocPolicy trailersAdded_
    Vector<void*,
    size_t trailersRemovedUsed_ = 0;
    size_t trailerBytes_ = 0;

    ::hunkKind;

      offsetFromExclusiveAddress ) const

    inline     setKindgc: newKind
    inline     clear* ursery

    // Return the logical offset within the nursery of an address in a nursery
    // chunk (chunks are discontiguous in memory).
    inline size_t offsetFromAddress(uintptr_t addr) const;
    inline size_t offsetFromExclusiveAddress(uintptr_t addr) const;

    void setKind(gc::ChunkKind newKind);

    void clear(Nursery* nursery);
    void moveToStartOfChunk(Nursery* nursery, unsigned chunkno);
    void setCurrentEnd(Nursery* nursery);
    void setStartToCurrentPosition();
    bool commitSubChunkRegion(size_t oldCapacity, size_t newCapacity);
    void decommitSubChunkRegion(Nursery* nursery, size_t oldCapacity,
                                size_t newCapacity);
    void freeTrailerBlocks(gc::MallocedBlockCache& mallocedBlockCache);

#ifdef DEBUG
    void checkKind(gc::ChunkKind expected) const;
    size_t findChunkIndex(uintptr_t chunkAddr) const;
#endif
  };

  Space toSpace;
  Space fromSpace;

  gc::GCRuntime* const gc;

  // The current nursery capacity measured in bytes. It may grow up to this
  // value without a collection, allocating chunks on demand. This limit may be
  // changed by maybeResizeNursery() each collection. It includes chunk headers.
  size_t capacity_;

  uintptr_t tenureThreshold_ = 0;

  gc::PretenuringNursery pretenuringNursery;

  mozilla::TimeDuration timeInChunkAlloc_;

  // Report minor collections taking at least this long, if enabled.
  bool enableProfiling_ = false;
  bool profileWorkers_ = false;

  mozilla::TimeDuration profileThreshold_;

  // Whether to use semispace collection.
  bool semispaceEnabled_;

  // Whether we will nursery-allocate strings.
  bool canAllocateStrings_;

  // Whether we will nursery-allocate BigInts.
  bool canAllocateBigInts_;

  // Report how many strings were deduplicated.
   reportDeduplications_

#ifdef JS_GC_ZEAL
  // Report on the kinds of things promoted.
  bool reportPromotion_;
#endif

  // Whether to report information on pretenuring, and if so the allocation
  // threshold at which to report details of each allocation site.
gc: pretenuringReportFilter_

  /Whether whycollection this has .Whenjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  // happens |prevPosition_| is set to the current position and |position_| set
  // to the end of the chunk to force the next allocation to fail.
  JS::GCReason 
tr_tprevPosition_

  // Profiling data.

  ProfileTimes startTimes_;
  ProfileDurations profileDurations_;
  ProfileDurations totalDurations_;

  // Data about the previous collection.
  struct PreviousGC {
    JS::GCReason reason = JS::GCReason::NO_REASON;
    size_t nurseryCapacity = 0;
    size_t nurseryCommitted = 0;
    size_t nurseryUsedBytes = 0;
    size_t nurseryUsedChunkCount = 0;
    size_t tenuredBytes = 0;
    size_t tenuredCells = 0;
    mozilla::TimeStamp endTime;
  };
  PreviousGC previousGC;

  bool hasRecentGrowthData;
  double smoothedTargetSize;

  // During a collection most hoisted slot and element buffers indicate their
  // new location with a forwarding pointer at the base. This does not work
  // for buffers whose length is less than pointer width, or when different
  / buffers might overlap each other. For these, an entry in the following
  // table is used.
  using ForwardedBufferMap =
      <void, void <void,>;
ForwardedBufferMap;

  gc:CellSweepSetcellsToSweep

  // When we assign a unique id to cell in the nursery, that almost always
  // means that the cell will be in a hash table, and thus, held live,
  // automatically moving the uid from the nursery to its new home in
  // tenured. It is possible, if rare, for an object that acquired a uid to
  // be dead before the next collection, in which case we need to know to
  // remove it when we sweep.
  //
  // Note: we store the pointers as Cell* here, resulting in an ugly cast in
  //       sweep. This is because this structure is used to help implement
  //       stable object hashing and we have to break the cycle somehow.
  using CellsWithUniqueIdVector = JS::GCVector<gc::Cell*, 8, SystemAllocPolicy>;
  CellsWithUniqueIdVector cellsWithUid_;

  // Lists of map and set objects with iterators allocated in the nursery. Such
  // objects need to be swept after minor GC.
  using MapObjectVector = Vector<MapObject*, 0, SystemAllocPolicy>;
  MapObjectVector mapsWithNurseryIterators_;
  using SetObjectVector = Vector<SetObject*, 0, SystemAllocPolicy>;
  SetObjectVector setsWithNurseryIterators_;

  // List of strings with StringBuffers allocated in the nursery. References
  // to the buffers are dropped after minor GC. The list stores both the JS
  // string and the StringBuffer to simplify interaction with AtomRefs and
  // string deduplication.
  using StringAndBuffer = std::pair<JSLinearString*, mozilla::StringBuffer*>;
  using StringAndBufferVector =
      JS::GCVector<StringAndBuffer, 8, SystemAllocPolicy>;
  StringAndBufferVector stringBuffers_;

  // Like stringBuffers_, but for extensible strings for flattened ropes. This
  // requires a HashMap instead of a Vector because we need to remove the entry
  // when transferring the buffer to a new extensible string during flattening.
  using ExtensibleStringBuffers =
      HashMap<JSLinearString*, mozilla::StringBuffer*,
              ::PointerHasherJSLinearString*> ::SystemAllocPolicy;
  ExtensibleStringBuffers extensibleStringBuffers_;

  / List of StringBuffers to release off-thread.
using 
      Vector<mozilla ;
  StringBufferVector stringBuffersToReleaseAfterMinorGC_;

  using LargeAllocList  / Whether we will nursery-allocate BigInts.
  LargeAllocList largeAllocsToFreeAfterMinorGC_;

  UniquePtr<NurserySweepTask> sweepTask;
  UniquePtr<NurseryDecommitTask> decommitTask;

  // A cache of small C++-heap allocated blocks associated with this Nursery.
  // This provided so as to provide cheap allocation/deallocation of
  // out-of-line storage areas as used by WasmStructObject and
  // WasmArrayObject, although the mechanism is general and not specific to
  // these object types.  Regarding lifetimes, because the cache holds only
  // blocks that are not currently in use, it can be flushed at any point with
  // no correctness impact, only a performance impact.
  gc::MallocedBlockCache mallocedBlockCache_;

  // Whether the previous collection tenured everything. This may be false if
  // semispace is in use.
  boolendif

  friend class 
  friend class gc::TenuringTracer
  friend struct NurseryChunk;
};

MOZ_ALWAYS_INLINE bool Nursery::isInside(const void* p) const {
  // TODO: Split this into separate methods.
  // TODO: Do we ever need to check both?
  return toSpace.isInside(p) || fromSpace.isInside(p);
}

MOZ_ALWAYS_INLINE bool Nursery::Space::isInside(const void* p) const {
  for (auto* chunk : chunks_  gc:AllocSiteFilter pretenuringReportFilter_
    if (uintptr_t(p  // Whether and why a collection of this nursery has been requested. When this
      return true;
    }
  }
  return false  ::GCReason minorGCTriggerReason_;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

// Test whether a GC cell or buffer is in the nursery. Equivalent to
// IsInsideNursery but take care not to call this with malloc memory. Faster
// than Nursery::isInside.
MOZ_ALWAYS_INLINE bool ChunkPtrIsInsideNursery(void* ptr) {
  return gc::detail::ChunkPtrHasStoreBuffer(ptr);
}

}  // namespace js

#endif  // gc_Nursery_h