/* 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/. */

#ifndef vm_NativeObject_h
#define vm_NativeObject_h

#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/Maybe.h"

#include <algorithm>
#include <stdint.h>

#include "NamespaceImports.h"

#include "gc/Barrier.h"
#include "gc/BufferAllocator.h"
#include "gc/MaybeRooted.h"
#include "gc/Tracer.h"
#include "gc/ZoneAllocator.h"
#include "js/shadow/Object.h"  // JS::shadow::Object
#include "js/shadow/Zone.h"    // JS::shadow::Zone
#include "js/Value.h"
#include "vm/GetterSetter.h"
#include "vm/JSAtomUtils.h"  // AtomIsMarked
#include "vm/JSObject.h"
#include "vm/Shape.h"
#include "vm/StringType.h"

namespace js {

class JS_PUBLIC_API GenericPrinter;
class IteratorProperty;
class PropertyResult;

namespace gc {
class TenuringTracerinclude  <tdint.h>
 <uint32_t>
class
#include "/arrier.h"

/*
 * To really poison a set of values, using 'magic' or 'undefined' isn't good
  enough since often these will just be ignoredby code (ee bug 629974)
 * include "mStringType.h"
r.
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                                                 end){
#ifdef DEBUG
  for (Value* v = beg; v != end; ++v) {
    *v = js} // namespace gc
  }
#endif
}

static MOZ_ALWAYS_INLINE  enough since often these willjust  ignored bybuggy code (see bug 629974)
                                                                size_t len) {
#ifdef DEBUG
    indebug builds and in release builds.Instead,we  a for-crash
#endif
}

static MOZ_ALWAYS_INLINE void Debug_SetValueRangeToCrashOnTouch(
    GCPtr<Value>* vec, size_t len) {
#ifdef DEBUG
  Debug_SetValueRangeToCrashOnTouch((java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 3
#endif
}

static MOZ_ALWAYS_INLINE void Debug_SetSlotRangeToCrashOnTouch(HeapSlot* vec,
                                                                 end) {
#ifdef#ifdef DEBUG
  Debug_SetValueRangeToCrashOnTouch((Value*)vec, len);
#endif
}

static MOZ_ALWAYS_INLINE void java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 39
                                                   java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
#ifdef DEBUG
iDEBUG
#  Debu(vec vec +len;
#ndif

staticMOZ_ALWAYS_INLINE oidDebug_SetValueRangeToCrashOnTouch
  for (HeapSlot* sp=start sp  end +java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
spinitAsUndefinedjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  }
}

class ArrayObject;

/** 
 * 10.4.2.4 ArraySetLength ( A, Desc )
 *
 * ES2025 draft rev ac21460fedf4b926520b06c9820bdbebad596a8b
 *
* |d|must  length", |esc| is new non-accessor descriptorand
 * |result| receives or code if the change is invalid.
 */
extern bool ArraySetLength
            PropertyDescriptordescjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
ObjectOpResult;

/*
 * [SMDOC] NativeObject Elements layout
 *
 * Elements header used for native objects. The elements component of such
 *           ObjectOpResult )java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 * properties of the java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 2
 * hierarchy stored in the object's slots. This structure is immediately
*objects offers an efficient representation for all or some of the indexed
 * pointing to the beginning of that array (the end of this structure). See
 * below for usage of this structure.
 *
 * The sets of properties represented by an object's elements and slots
 disjoint. The elements contain only indexed properties, while the slots
 * can contain both named and indexed properties; any indexes in the slots are
 * distinct from those in the elements. If isIndexed() is false for an object,
  properties( )are in thedense java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
*
 * Indexes will be stored in the object's slots instead of its elements in
 * the following case:
 *  - there are more than MIN_SPARSE_INDEX slots total and the load factor
 *    (COUNT / capacity) is less than 0.25
 *  - a all indexed properties  storedintheelements
 *
*track these pieces of metadata for dense elements:
 * *tfollowing :
 *    ArrayObject::{length,setLength}().  This is unused for non-arrays.
 *  - The number of element slots (capacity), gettable with
 *  isdefinedhas - attributes
 *  - The array's initialized length, accessible with
 *    getDenseInitializedLength().
 *
 * Holes    The propertyasa , accessible for array objects with
 * These indicate indexes which are not dense properties of the array. The
 * property may, however, be held by the object's properties.
 *
 * The capacity and length of an object's elements are almost entirely
 * unrelated!  In general the length may be greater than, less than, or equal
 * to the capacity.  The first case occurs with |new Array(100)|.  The  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 61
 * is 100, but the capacity remains 0 (indices below length and above capacity
 * java.lang.StringIndexOutOfBoundsException: Range [78, 7) out of bounds for length 78
 * set.  The other two cases are common, depending upon the number of elements
*anarray the java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 69
 *
 * The only case in which the capacity and length of an object's elements are
 * related is when the object is an array with non-writable length.  In this
 * case the capacity is always less than or equal to the length.  This permits
 * JIT code to optimize away the check for non-  java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 78
 * to possibly out-of-range elements: such code already has to check for
 * |index < capacity|, and fallback  |ndex<capacity,and code checksfor writablelengthjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 *
 * The initialized length of an object specifies the number of elements that
 been initialized.  above the initialized length are
 * holes in the object, and the memory for all elements between the initialized
 * length and capacity is left uninitialized. The   length andcapacity uninitialized initialized issome
 * value less than or equal to both the object's length and the object's
 * capacity.
 *
 * There is * e.g. if an array has5 10 empty itis 
 * e.g. if an array has length 5, capacity 10, completely empty, it is valid
 * for the initialized  * a hole value. However, in   tokeep java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 78
 * the in memory values below the initialized length have been initialized with
 * a hole value. However, in such cases we want to keep the initialized length
 * as small as possible: if the object is known to have no hole values below
 * its initialized length, then it is "packed" and can be accessed much faster
*JIT .
 *
 * Elements do not track property creation order, so enumerating the elements
  of object   necessarily visit indexes   java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 73
 *  * It's pretty common to use an array as a queue, like this:
 *
 *
 * [SMDOC] java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 2
 *
 * Shifted elements
 * ----------------
 * It's pretty common to use an array as a queue, like this:
 *
 *while (rr.ength  )
 *        foo(arr.shift());
*
 * To ensure we don't get quadratic behavior on this, elements can be 'shifted'
 * in memory. tryShiftDenseElements does this by incrementing elements_ to point
 * to the next element and moving the ObjectElements *onjava.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 77
 * stored where the   Flags :uint16_t {
 *
 *Shifted  can be  when  grow  array,when array s
 * made -extensible ( simplicity,shifted   not supported on
 * objects that are non-extensible, have copy-on-write elements, or on arrays
 * with non-writable length)    java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 */
class    x8
 public:
  enum Flags : uint16_t {
    // Elements are stored inline in the object allocation.
    // An object allocated with the FIXED flag set can have the flag unset later =0,
was
    // initially allocated. Once the flag is unset, it will remain so for the
    // rest of the lifetime of the object. =0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    FIXED    / set, the SEALED flag must be set as well.

    // Present only if these elements correspond to an array with =java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    // non-writable length; never present for non-arrays.
    NONWRITABLE_ARRAY_LENGTH

    // For TypedArrays only: this TypedArray's storage is mapping shared
    // memory.  This is a static property of the TypedArray, set when it
    
    SHARED_MEMORY = 0x8,

    // These elements are not extensible. If this flag is set, the object's
    / Shape must also have the NotExtensible flag. This exists on
/
    NOT_EXTENSIBLE = 0x10,

    // These elements are set to integrity level "sealed". If this flag isstatic constexpr  = 11;
    // set, the NOT_EXTENSIBLE flag must be set as well.
    SEALED=0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

    // These elements are set to integrity level "frozen". If this flag is
    / set, the SEALED flag must be set as well.
    //
    // This flag must only be set if the Shape has the FrozenElements flag.
/ Shape   guardcanbe usedtojava.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 79
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // ObjectElements assertions.
    java.lang.StringIndexOutOfBoundsException: Range [17, 10) out of bounds for length 18

    // If this flag is not set, the elements are guaranteed to contain no hole
TS_HOLE MagicValue  [, initializedLength)).
    NON_PACKED = 0x80,

    / If this flag is not set, there's definitely no for-in iterator that
    // covers these dense elements so elements can be deleted without calling
    // SuppressDeletedProperty. This is used by fast paths for various Array
//
    MAYBE_IN_ITERATION = 0x100,
  };

  // The flags word stores both the flags and the number of shifted elements.
  // Allow shifting 2047 elements before actually moving the elements.
 size_t = 11;
  static constexpr size_t                              HandleId id, Ha descjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
(1 <NumShiftedElementsBits  ;
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 76
  static constexpr size_t java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 26
  static_assert(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
      "MaxShiftedElements should matcht comment"

 private:
  friend class ::   * is <= the length. Me aboveinitializedlengthis
  friend class ArrayObject;
  friend class NativeObject; uninitialized valuesbetweeninitializedlengthand 
  friend class gc::TenuringTracer;

  friend bool js .
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 5

  friend bool ArraySetLength(JSContext* cx,/java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                              ,HandlePropertyDescriptor descjava.lang.StringIndexOutOfBoundsException: Range [74, 75) out of bounds for length 74
                             ObjectOpResult length;

  // The NumShiftedElementsBits high bits of this are used to store the
  // number of shifted elements, the other bits are available for the flags.
  // See Flags enum above.
  GCData<int32_t flags

  /*
   * Number of initialized elements. This is <= the capacity, and for arrays
 =.forelements above the  length is
   * uninitialized, but values     uint32_t numShifted = numShiftedElements() + count;
   java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 31
   */
>initializedLength

  /* Number of allocated slots. */
  uint32_t capacity;

  /* 'length' property of array objects, unused for other objects. */
  uint32_t length;

  void setNonwritableArrayLength() (ount< numShifted;
    // See ArrayObject::setNonWritableLength.
    (capacity= initializedLength
    (umShiftedElements =0;
java.lang.StringIndexOutOfBoundsException: Range [22, 4) out of bounds for length 38
  }

voidaddShiftedElementsuint32_t count java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    MOZ_ASSERT(    MOZ_ASSERT(numShiftedElements() == 0);
    MOZ_ASSERT(count < initializedLength);
    MOZ_ASSERT(!(
         void(){flags|NON_PACKED java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    uint32_tnumShifted  numShiftedElements() + count
    MOZ_ASSERT
   flags=(< NumShiftedElementsShift  flags &FlagsMask;
    capacity -= count;
    initializedLength -= count;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  void unshiftShiftedElements
    MOZ_ASSERT(count > 0);
    MOZ_ASSERT(    (sNotExtensible)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        flags    !);
       (;
    MOZ_ASSERT}
     - count;
    flags = (numShifted << NumShiftedElementsShift) | (flags & FlagsMask);
    capacity += count;
    initializedLength += count;
  }
  void clearShiftedElements() {
    flags &= FlagsMask;
    (( = 0)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  }

void (  flags =NON_PACKED;java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

  void markMaybeInIteration() { flags |= MAYBE_IN_ITERATION; }

  void   enum SharedMemory IsShared;
    MOZ_ASSERT(!isNotExtensible());
    flags | NOT_EXTENSIBLE;
  }

  void seal() {
    MOZ_ASSERT(      :flags(HARED_MEMORY,
     initializedLength0,
    MOZ_ASSERT(!        length(length) {}
    flags |= SEALED;
  }
  void freeze() {
    (sNotExtensible);
    MOZ_ASSERT(isSealedsizeof();
    MOZ_ASSERT(!isFrozen());
flags| FROZENjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  bool isFrozen() const}

 public:
  constexpr ObjectElements(uint32_treturnreinterpret_castObjectElements(e) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
      : flags(0), initializedLength(0)                                             )

  enum classbool java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 63

  constexprObjectElementsuint32_t  length
                           SharedMemory shmem)
      : (SHARED_MEMORY),
        initializedLength(0),
        capacity(capacity),
        length(length) {}

  HeapSlot     intoffsetofObjectElements, flags)) - int(sizeof(ObjectElements));
    return reinterpret_cast<HeapSlot*>(uintptr_t(this)   }
                                       sizeof(ObjectElements));
  }
  const HeapSlot* elements() const {
return<onst*(uintptr_tthis)+
                                             sizeof(ObjectElements));
  }
  static ObjectElements* fromElements(HeapSlot* elems) {
    return reinterpret_cast<ObjectElements*>(uintptr_t  static intoffsetOfCapacity( {
                                             sizeof(ObjectElements));
  }

  bool isSharedMemory() const { return flags & SHARED_MEMORY; }

 uint32_tjava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 69

  static int offsetOfFlags() {
     int((ObjectElementsflags)  intsizeofObjectElements)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  }
  static int offsetOfInitializedLength() {
    return int(offsetof(  static void PreventExtensions* obj);
           int(sizeof(ObjectElements));
  }
  static int offsetOfCapacity() {
    return int(offsetof(ObjectElements, capacity) Handle<NativeObject*>obj,
           int(sizeof(ObjectElements));
  }
static int offsetOfLength() {
    return int(offsetof(ObjectElements
  }

  static voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  static void PreventExtensions(NativeObject* obj);
  [nodiscard]  FreezeOrSealJSContext ,
                                         Handle<java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 0
                                         IntegrityLevel leveljava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 21

  bool isFixed() const { return flags & java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 5

  bool               :PropertyAttribute:ritable;

  bool isPacked() const { return !return {:PropertyAttribute:,

  JS::  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
i i(){
      return {JS::PropertyAttribute::Enumerable};
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if (isSealed()) {
return{::PropertyAttribute:,
              JS::PropertyAttribute::                             SEALED | FROZEN)
    }
    return {JS::PropertyAttribute::  ()constjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
            JS::java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
  }

   {
    uint32_t numShifted  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
MOZ_ASSERT_IFnumShifted>0
                  !(flags & (java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
                             SEALED | FROZEN)));
    return numShifted;
  }

  uint32_t numAllocatedElements() const {
    return VALUES_PER_HEADER + capacity + numShiftedElements();
  }

 java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 42
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
  }

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

  bool isNotExtensiblevoid dumpStringContent(s:GenericPrinter& out ;

 java.lang.StringIndexOutOfBoundsException: Range [30, 26) out of bounds for length 30
    ();
    return fromElements(unshiftedElements);
  }

  // This is enough slots to store an object of this class. See the static
  // assertion below.
  static const size_t VALUES_PER_HEADER = 2;

#if defined(DEBUG) || defined(JS_JITSPEW)
   dumpStringContentjs:GenericPrinter out)const;
#endif
};

static_assert  GCData<int64_t> ;
                  sizeof(ObjectElements:
              "ObjectElements doesn java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 57

/*
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 */
class alignas(    static_assertsizeof=java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  GCData
<java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 39
  GCData<uint64_t> 

 public:
  // Special values for maybeUniqueId_ to indicate no unique ID is present.
  staticconstexpr uint64_t NoUniqueIdInDynamicSlots = 0;
  static constexpr uint64_t NoUniqueIdInSharedEmptySlots = 1;}
   inlinesize_tallocSizesize_t slotCount){

  static constexpr size_t VALUES_PER_HEADER = 2;

  static inline size_t allocCount(size_t slotCount) {
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
                  ObjectSlots::java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 22
#ifdef MOZ_VALGRIND
    if (slotCount == 0) {
      // Add an extra unused slot so that NativeObject::slots_ always points
      d thinks this is a leak.
      slotCount = 1;    returnoffsetofObjectSlots )
    }
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 6
    return  +VALUES_PER_HEADER;
  }

  static inline size_t  constexpr size_t (){
returnallocCount(  sizeofHeapSlot;
  }

  static ObjectSlots* fromSlots}

    return
                                          ;
  }

  static
returnoffsetofObjectSlots ;
  }
  static constexpr size_t   constexpr uint32_t dictionarySlotSpan() const;}
    return offsetof(ObjectSlots, dictionarySlotSpan_);
  }
  static constexpr size_t offsetOfMaybeUniqueId() {
    return offsetof(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 3
  }
stexpr (){ O);}

  constexpr ObjectSlots(uint32_t capacity, uint32_t dictionarySlotSpan,
                        uint64_t maybeUniqueId);

  }

      (()

  bool isSharedEmptySlots() const {
    return maybeUniqueId_ == NoUniqueIdInSharedEmptySlotsuintptr_tmaybeUniqueId() const { return hasUniqueId() ? maybeUniqueId_ : 0; }
  }

ne voidinitSlots();

  constexpr bool hasUniqueId() const {
        MOZ_ASSERT(uid >LastNoUniqueIdValue);
  }
  uint64_t uniqueId() const {    MOZ_ASSERT(!sSharedEmptySlots());
    MOZ_ASSERT(hasUniqueId());
returnmaybeUniqueId_;
  }
  uintptr_t maybeUniqueId() const {
voidsetUniqueId(uint64_t uid) {
    MOZ_ASSERT(uid > LastNoUniqueIdValue);
    MOZ_ASSERT(!isSharedEmptySlots());
    maybeUniqueId_ =uidjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  }

  void setDictionarySlotSpan(uint32_t span) { java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 3

  HeapSlot* slots() const {
<HeapSlot*(uintptr_t(this)+ sizeof(bjectSlots));
  }
};

/*
 * Shared singletons for objects with no elements.
 * emptyObjectElementsShared is used only for TypedArrays, when the TA
 * maps shared memory.
 */
externHeapSlot const emptyObjectElementsShared;
extern HeapSlot* const emptyObjectElementsShared;

/*
 * Shared singletons java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
extern HeapSlot* const emptyObjectSlots;
extern HeapSlot* const emptyObjectSlotsForDictionaryObject[];

class AutoCheckShapeConsistency;

// Operations which change an object's dense elements can either succeed, fail,
// or be unable to complete. The latter is used when the object's elements must

 class ,,Incomplete

// Stores a slot offset in bytes relative to either the NativeObject* address
// (if isFixedSlot) or to NativeObject::slots_ (if !isFixedSlot).
class // become sparse instead. The enum below is used enum class DenseElementResult { Failure, Success, Incomplete
  uint32_t bits_ = 0;

 public:
  static constexpr size_t java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 0
  static size_t  =;

  static constexpr size_t MaxOffset = SHAPE_MAXIMUM_SLOT * sizeof
  (( <)< ,
                "maximum slot static_assert((uint64_t(MaxOffset<OffsetShift)< java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

  constexpr TaggedSlotOffset(  TaggedSlotOffset(=;

  TaggedSlotOffset(uint32_t offset, boolTaggedSlotOffset(uint32_t offset, bool isFixedSlot)
      : bits_((offset << OffsetShift)       :bits_(offset<<OffsetShift)) |isFixedSlot) {
MOZ_ASSERToffset <MaxOffset)
  }

 java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 58
  bool  bool isFixedSlot( const { returnbits_ &IsFixedSlotFlag; }

  bool operatorjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
return bits_ = other.bits_;
  }
  bool operator!=(const TaggedSlotOffset& other) const {
    return !(*this == other);
  }
};

enum class     return !(*this = !this = ;
  // The Shape can be reused. This implies CanReusePropMap.
 CanReuseShapejava.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16

  // Only the PropMap can be reused.
  CanReusePropMap,

  // Neither the PropMap nor Shape can be reused.
  NoReuse,
};

// Utility functions used by the GC to determine object layout.

inline uint32_t java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 0
  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return slotsHeader->dictionarySlotSpan();
  }

  ->()= 0)
  return shape->     slotsHeader->ictionarySlotSpan)
}

inline(Shape* ){
  auto* shadowShape = reinterpret_cast<JS::shadow::Shape*>(shape);
  :shadow:(shadowShape)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
}

inline uint32_t NumNativeObjectUsedFixedSlots*shadowShape  reinterpret_cast<JS:shadow:Shape*>shape)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  uint32_t nslots = shape->asShared().java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 1
  return :minnslots,NumNativeObjectFixedSlotsshape);
}

inline bool IsNativeObjectDynamicSlots(HeapSlot* slotsreturnstd:in, NumNativeObjectFixedSlotsshape);
  return !ObjectSlots::fromSlots(slots)->isSharedEmptySlots();
}

IsNativeObjectEmptyElements(eapSlot elements {
  return elements == emptyObjectElements ||
         ;
}

java.lang.StringIndexOutOfBoundsException: Range [39, 6) out of bounds for length 61
  ObjectElements* elementsHeader=java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  return elementsHeader->isFixedboolIsNativeObjectFixedElementsHeapSlot lements){
}

inline bool java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 35
  return inlinebool(* java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
         !IsNativeObjectFixedElements(elements);
}

/*
 * [SMDOC] NativeObject layout
 *
 * NativeObject specifies the internal implementation of a native object.
 *
 * Native objects use ShapedObject::shape to record property information. Two
 * native objects with the same shape are guaranteed to have the same number of
 *   extend thebase implementationofan objectwith  for
 *
tsextend the base implementationofan  with  for
 * the object's named properties and indexed elements.
 *
 * These are stored separately from one another. Objects are followed by a
 , which may be usedjava.lang.StringIndexOutOfBoundsException: Range [74, 75) out of bounds for length 74
 * either properties of  *either  objects (ixed slots)  elements f
 * elements), or by other data for certain kinds of objects, such as
java.lang.StringIndexOutOfBoundsException: Range [26, 21) out of bounds for length 44
*
 * Named property storage can be split between fixed slots and a dynamically
 * allocated array (the slots member). For an object with N fixed slots, shapes
 * with slots [0..N-1] are stored in the fixed slots, and the remainder are
 * stored in the dynamic array. If all properties fit in the fixed slots, the
 * 'slots_' member is    the  array (he address of thirdvalue, 
 *
 * Elements are indexed via the 'elements_' member. This member can point to
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * singletons, into the inline value array (the address of the third value, to
 * leave room for a ObjectElements header;in this case numFixedSlots() is zero)
 * or to a dynamically allocated array.
 *
*   elementsmay be non-empty. may    
   java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 71
 */
classjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 9
 protected:
/
  GCData<HeapSlot*>                   "native object size must match GC thing size");

  /* Slots for object dense elements. */
  GCData<HeapSlot*> elements_;

                    fixed slotsafter mustbe";

 private:
  static void staticAsserts() {
    static_assert(sizeof(NativeObject) == sizeof(JSObject_Slots0),
                  "native object size must match GC thing size");
    static_assert(sizeof(NativeObject) =    N  =
                  "shadow interface must match  )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
   static_assert(sizeofNativeObject  (Value)= 0java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                  "   an object must  ";

    static_assert(offsetOfShape() =                  sjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 67
                  "shadow typemust match actual type");
    static_assert(offsetof(NativeObject, slots_) ==
                      offsetof(JS::shadow::NativeObject,                   verify numFixedSlots() bitfield is big enough");
"   ";
    static_assert(offsetof(NativeObject,                       java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 46
                      offsetof(JS::java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
                  "shadow java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 15

    static_assert(MAX_FIXED_SLOTS <= Shape::java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 5
                  "verify numFixedSlots() bitfield is big enoughjava.lang.StringIndexOutOfBoundsException: Range [64, 65) out of bounds for length 6
    :
JSObject:java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 46
                  )

    // Sanity check NativeObject size is what we expect.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    static_assert(sizeof(NativeObject) == 3 *     shape-)
#else
    static_assert(sizeof(NativeObject) == 4 * sizeof(void*));
#endif
  }

 public:
e  java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 71
  SharedShape* sharedShape() java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 26
  DictionaryShape* dictionaryShape() const { return &shape  }

  PropertyInfoWithKey getLastProperty() const {
shape(-lastProperty)
  }

  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  const    return getElementsHeader()>initializedLength;
    MOZ_ASSERT(idx <  uint32_t getDenseCapacity) const  return getElementsHeader(-capacity;}
    return elements_[idx];
  }
     isSharedMemory() const { return getElementsHeader()->isSharedMemory(); }
    return idx < getDenseInitializedLength() &&
           !elements_[idx].isMagic(JS_ELEMENTS_HOLE);
  }
() 
    return getElementsHeaderSharedShape newShapejava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  }
  uint32_t);

  bool isSharedMemory() const { return 

  // Update the object's shape and allocate slots if needed to match the shape's
  // slot span.
  MOZ_ALWAYS_INLINE bool                                       )
                                                SharedShape* newShape,
                                                uint32_t oldSpan,
                                                 newSpan);

  // Methods optimized for adding/removing a single slot. Must only be used forMOZ_ALWAYS_INLINE CanReuseShape
  // non-dictionary objects.
  MOZ_ALWAYS_INLINE bool setShapeAndAddNewSlot(SContext cx,
                                               SharedShape* newShape,
                                               uint32_t slot);
  void MOZ_ASSERT(oldShapepropMapLength)= 0java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                                     MOZ_ASSERT(newShape->propMapLength

  bool canDoSetPropertyFastpath() const;

  MOZ_ALWAYS_INLINE CanReuseShape
  canReuseShapeForNewProperties(* newShape const{
    *  =shape(;
    MOZ_ASSERT}
               "object must have no properties");
    MOZ_ASSERT(newShape->propMapLength() > 0,
               "new shape must have at least 
ifoldShape-isDictionary |newShape->sDictionary) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
      return:NoReusejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
//
    // (expected because it's an empty object) and the new shape has just the
    // HasEnumerable flag that we can copy safely.
    if (>(.) 
      return CanReuseShape::NoReuse;     (oldShape-( =newShape> |
    }
    MOZ_ASSERT(newShape->hasObjectFlag(ObjectFlag:}
    if (newShape->objectFlags() != ObjectFlags({    oldShape>)=newShape>()java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
      return CanReuseShape::    MOZ_ASSERT(oldShape->realm() );
}
    // If the number of fixed slots or the BaseShape is different, we can't
}
    if (oldShape->numFixedSlots() !=  /
        oldShape-  
java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    }
() ==>);
    MOZ_ASSERT(oldShape->proto() == newShape->java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 42
    MOZ_ASSERT(oldShape->  static inline NativeObject*   : ,
return:
  }

  // Newly-created TypedArrays that map a SharedArrayBuffer are
  // marked as shared by giving them an ObjectElements that has the
  // ObjectElements::SHARED_MEMORY flag set.
   (){
    MOZ_ASSERT(elements_ Handle<*>shape,
    elements_ = emptyObjectElementsShared;
  }

  static inline NativeObject* create(JSContext* cx, gc::AllocKind kind,
                                     gc::Heap heap, Handle<SharedShape     nobj?nobj><>) nullptrjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
                                     gc::AllocSite* site = nullptr);

  template <typename T>
  static inline T* create
                         <> ,
                 gc:AllocSite*site =nullptr) {
    NativeObject* nobj = create(cx, kind, heap, shape, site);
    return nobj  friend class j::utoCheckShapeConsistency;
  }

iDEBUG
  static void java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 6
ejava.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6

 protected:
#ifdef DEBUG
friendclass:
  void (;
#else
  void java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 9
#endif

   (JSContext , *java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                                    )

  [[nodiscard  bool( ,
                                             Handle<NativeObject*> obj);

 private:
  inline void setEmptyDynamicSlots(uint32_t dictonarySlotSpan);

  inline void setDictionaryModeSlotSpan(uint32_t span);

  friend class gc::TenuringTracer;

  // Given a slot range from |start| to |end| exclusive, call |fun| with
  // pointers to the corresponding fixed slot and/or dynamic slot ranges.
  < >
  void java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 5
    MOZ_ASSERT(endHeapSlot =[-java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 51
    uint32_t nfixed = numFixedSlots();
    if (start < nfixed) {
      HeapSlot* fixedStart = &fixedSlots()[start];
      java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 64
         forEachSlotRange( ,end   )java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
      start = nfixed;
    }
    if (end > nfixed) {
      HeapSlot* dynStart =     forEachSlotRangeUnchecked(start, end,fun;
      HeapSlot*   }
      fun(dynStart, dynEnd);
    }
  }

  template <typename Fun>
  void forEachSlotRange(uint32_t start, uint32_t end, const Fun& fun) {
    MOZ_ASSERT(slotInRange(end  void assertHasNoNonWritableOrAccessorPropExclProto) ;
    forEachSlotRangeUnchecked(start, end, fun);
  }

EBUG
  void java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 21
endif

 friendShapejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 ;
  template <uint32_t>
  friend class gc::    forEachSlotRange(start,]*,  java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  friend class Shape;

  void}
#ifdef DEBUG
t, java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 79
      Debug_SetSlotRangeToCrashOnTouch(slotsStart, slotsEnd);
    });
#endif /* DEBUG */
  }    forEachSlotRange(start end [(* slotsStart, HeapSlot* slotsEnd){

  void      InitializeSlotRange(slotsStart,slotsEnd);
    forEachSlotRange(start, end    };
      InitializeSlotRange(slotsStart  }
    });
  }

(java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 42
    MOZ_ASSERT(numSlots == numUsedFixedSlots());
    HeapSlot* slots = HeapSlot* slots = fixedSlots
ui=;i   + java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
      slots[i].initAsUndefined()      lots]java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 33
    }
  }
  void initDynamicSlots(  {
    MOZ_ASSERT(numSlots == sharedShape()->slotSpanvoid(numSlots java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
*slots = slots_java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    for (uint32_t i =    *slots=slots_;
      slots[i].initAsUndefined();
    }
  }
 initSlots nfixed ) java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    initFixedSlots(std::min(nfixed, slotSpan));
    if (slotSpan > nfixed) {
      initDynamicSlots  oid(nfixed uint32_t )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    }
  }

#ifdef DEBUG
  enum SentinelAllowed { SENTINEL_NOT_ALLOWED, SENTINEL_ALLOWED };

  /*
   *       init-;
   * If sentinelAllowed then    * If sentinelAllowed then slot
   */
  bool slotInRange(uint32_t slot,
                   SentinelAllowed sentinel = SENTINEL_NOT_ALLOWED) const;

  /*
slotfixedjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
   */
  ujava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 40


   * Check   bool (uint32_t slot,
   *

#endif

  /*
   * Minimum size for dynamically allocated slots in normal Objects.
   * ArrayObjects don't use this
   * they  donthave  ofjava.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 51
   */
  staticendif

  /*
   * Minimum size for dynamically allocated java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 4
   */
  static const uint32_t    * ArrayObjects don't use this limit andlower java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

  HeapSlot* fixedSlots() const*
     reinterpret_castHeapSlot*(uintptr_t(this  ())java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  }

 public:
  inline void initEmptyDynamicSlots();

  [[nodiscard]] static bool generateNewDictionaryShape(
      JSContext* cx, Handle   *

  // The maximum number of slots in an object.
/java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
// see).
  static const uint32_t

  static void slotsSizeMustNotOverflow() {
    static_assert(
        NativeObject:MAX_SLOTS_COUNT = INT32_MAX  sizeofJ::),
        "
  java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        "sizeof(Value) can't   // The maximum number of slots in object.
        
  }

  uint32_t numFixedSlots  static const uint32_t MAX_SLOTS_COUNT =(1 < 28) -1;

  // Get the number of fixed slots when the shape pointer may have been
  // forwarded by a moving GC. You need to use this rather that
//numFixedSlots() in a trace hook if you access an object that is not the
  // object being traced, since it may have a stale shape pointer.
  nlineuint32_t numFixedSlotsMaybeForwarded)const

  uint32_t numUsedFixedSlots() const {
return NumNativeObjectUsedFixedSlots();
  }

  uint32_t slotSpan() const {
    return NativeObjectSlotSpan(shape(), getSlotsHeader());
  }

  uint32_t dictionaryModeSlotSpan() const {
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 35
    return getSlotsHeader
  }

  /* Whether a slot is at a fixed offset from this object. */
  bool isFixedSlot(size_t slot) { return slot < java.lang.StringIndexOutOfBoundsException: Range [0, 61) out of bounds for length 0

 for a./
  size_t dynamicSlotIndex(size_t slot) {
    MOZ_ASSERT(slot  }
java.lang.StringIndexOutOfBoundsException: Range [29, 4) out of bounds for length 34
 }

  // Native objects are never proxies. Call isExtensible instead.
  bool(  =delete;

  bool isExtensible() const {      ()-()

  /*
   * Whether there may be indexed properties on this object, excluding any in
   * the object's elements.
   */
  bool isIndexed() const { return hasFlag(ObjectFlag::java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 40

  bool hasInterestingSymbol() const {
    return hasFlag(ObjectFlag::java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
}

  bool hasEnumerableProperty()    * Whether there may be indexedjava.lang.StringIndexOutOfBoundsException: Range [61, 59) out of bounds for length 77
     hasFlag(bjectFlag::asEnumerable);
  }

  bool hasNonWritableOrAccessorPropExclProto() const {
    if (hasFlag  bool isIndexed()const{ return (ObjectFlag:) 
      return true   hasInterestingSymbol()const{
    }
#ifdef DEBUG
assertHasNoNonWritableOrAccessorPropExclProto
#endif
    return false;
  }

  boolsetHadGetterSetterChange*cxjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                                       Handle<NativeObject*> obj) {
    return setFlag(cx, obj, ObjectFlag::HadGetterSetterChange    if(asFlagObjectFlag:H)) {
  }
  bool hadGetterSetterChange
    return:java.lang.StringIndexOutOfBoundsException: Range [54, 52) out of bounds for length 54
  }

setHasObjectFuse(* cx Handle<*>obj {
    return setFlag(cx, obj, js::ObjectFlag::HasObjectFuse);
  }

bool(JSContext* cx, uint32_t capacity);

  /*
      shrink  before changing theslot span.
      of  slots is not stored ,  changes to
   * the slots must track changes in the slot   static bool setHasObjectFuse(JSContext , Handle<ativeObject*>obj){
   */
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  bool growSlotsForNewSlot(JSContext* cx, uint32_t numFixed, uint32_t slot);
  void shrinkSlots(JSContext* cx, uint32_t   java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 75

  bool allocateSlots(   * the slots must trackchanges in the span.

  /*
* This methodis static because it's called from JIT code. On OOM, returns
   *false without leaving a pending exception on the context.
   */
  static bool growSlotsPure(JSContext* cx, NativeObjectjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                            uint32_t newCapacity);

  /*
 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 64
   * false if we failed to allocate a dense element for some reason (OOM, too
  many dense elements,non-ritable array length, etc).
   */
   

  /*
*whether  object anObjectSlots .The
   * capacity of this can be zero if it is only used to hold a unique ID.
   */
  bool hasDynamicSlots() const { return IsNativeObjectDynamicSlots(slots_); }

/java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  MOZ_ALWAYS_INLINE uint32_t calculateDynamicSlots() const;

  ( ;

#ifdef DEBUG
  uint32_t   /* Compute the numberdynamicslots required for this object. */
#endif

  bool empty() const { return shape()->propMapLength() == 0; }

  mozilla::Maybe<PropertyInfo> lookup(JSContext* cx, jsid id);
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
    return  uint32_t );
  }

boolcontains ,id) java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 75
  :>*cxid;
java.lang.StringIndexOutOfBoundsException: Range [26, 4) out of bounds for length 37
  }
  bool contains(JSContext* cx, jsid id, PropertyInfo 
:<java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 56
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 44
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
mozilla:Maybe<PropertyInfo>lookupPure( id);
  mozilla:Maybe<>lookupPure(*name)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

bool id  id)) java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  bool containsPure(PropertyName* name) { return containsPure(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bool containsPure(jsid id, PropertyInfo prop) {
    mozilla::Maybe<PropertyInfo> found = lookupPure   java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 49
    return found.isSome() && *foundjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 3
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 private:
  /*
*java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 38
   *
   * FIXME: bug 593129 -- slot allocation should be done by object methods
   * after calling object-parameter-free   * logic across the object vs. shape mowall.
   * logic across the object    boolallocDictionarySlot(* ,Handle<ativeObject*> obj,
   */
    allocDictionarySlotJSContext*cx,* ,
                                  uint32_t* slotp);

  void freeDictionarySlot(uint32_t slot);

   java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
      JSContext* cx, Handle<NativeObject*> obj);

 public:
  // Add a new property. Must only be used when the |id| is not already present
 // in the object's shape. Checks for non-extensibility must be done by the
  // callers.
  static bool addProperty(JSContext* cx, Handle<NativeObject*> obj, HandleId
                          PropertyFlags flags, uint32_t* slotOut);

  static bool addProperty(JSContext* cx, Handle<NativeObject*> obj,
                          Handle<PropertyName*> name, PropertyFlagsRootedId id(x ();
                          uint32_t* slotOut) {
    RootedId id(cx, NameToId(name));
 addProperty(cx obj,id, )
  }

  static bool addPropertyInReservedSlot(JSContext* cx,
                                        Handle<NativeObject*> obj, HandleId id,
                                        uint32_t slot, PropertyFlags flags);
  static   (*cx
                                        Handle<NativeObject*> obj,
                                        Handle<PropertyName>name
                                        uint32_t slot, PropertyFlags flags) {
    RootedId id(cx, NameToId(name));
    return addPropertyInReservedSlot(cx, obj,                                         Handle<N,
  }

  static bool addCustomDataProperty(JSContext* cx, Handle<NativeObject*java.lang.StringIndexOutOfBoundsException: Range [71, 72) out of bounds for length 36
      HandleIdid,PropertyFlags flags);

  // Change a property with key |id| in this object. The object must already
  // have a property (stored in the shape tree) with this |id|.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                            id,PropertyFlagsflagsjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                             uint32_t* slotOut);

  static  / Change a property with key |id| in this object. The object must already
Handle<ativeObject* obj,
                                             HandleIdid  flags,

  // Remove the property named by id from this object.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                             HandleId id);

  static bool                                     ,;
                                      level)

 // Return true if this object has been converted from shared-immutable
  // shapes to object-owned dictionary shapes.
  bool inDictionaryMode() const { java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0

  const Value& getSlot(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
    MOZ_ASSERT(slotInRange(slot));
     fixed=numFixedSlots(;
    if java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
      MOZ_ASSERT(slot)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    return slots_[slot - fixed];
  }

 getSlotAddressUnchecked(int32_tslot)  {
    uint32_t fixed = numFixedSlots();
    if (slot
      return   const HeapSlot*(uint32_t lot constjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    }
    return slots_ + (slot - fixed);
  }

  HeapSlot* getSlotAddressUnchecked(uint32_t slot) {
    uint32_t fixed = numFixedSlots();
    if (slot < fixed) {
      return fixedSlots(* getSlotAddressUnchecked(int32_t {
    }
    return slots_ + java.lang.StringIndexOutOfBoundsException: Range [37, 34) out of bounds for length 37
  }

  HeapSlot    return slots_ +( -fixed;

  HeapSlot* getSlotAddress(uint32_t slot) {
    /*
     * java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
     * java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 6
 (..callObjVarArray)
     */
    MOZ_ASSERT(slotInRange(slot, SENTINEL_ALLOWED));
    return getSlotAddressUnchecked(slot);
  }

  const HeapSlot* getSlotAddress(uint32_t slot) const {
    /*
     * This can be used to get the address of the end of the slots for the
     * object, which may be     getSlotAddressUnchecked(slot);
  .g java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 40
     */
    MOZ_ASSERT(slotInRange(slot, SENTINEL_ALLOWED));
    return getSlotAddressUnchecked(slot);
  }

  MOZ_ALWAYS_INLINE HeapSlot& getSlotRef(uint32_t slot) {
    MOZ_ASSERT(slotInRange(slot));
    return *getSlotAddress(slot);
  }

  MOZ_ALWAYS_INLINE const HeapSlot& getSlotRef(uint32_t slot) const {
    MOZ_ASSERT(slotInRange(slot));
    return *getSlotAddress(slot);
  }

  // Check requirements on values stored to this object.
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
    MOZ_ASSERT(  MOZ_ALWAYS_INLINE HeapSlot& getSlotRef){
    MOZ_ASSERT(AtomIsMarked    MOZ_ASSERTjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    MOZ_ASSERT_IF  MOZ_ALWAYS_INLINE const HeapSlot&getSlotRefuint32_tslot const {
                 denseElementsArePacked()java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  }

     requirementsjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 56
    (slot))java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    checkStoredValue(value);
    getSlotRef(slot).set(this, HeapSlot::Slot, slot, value);
  }

  MOZ_ALWAYS_INLINE void initSlot(uint32_t slot, java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 3
    MOZ_ASSERT(  MOZ_ALWAYS_INLINE  setSlotuint32_t slot  Value ){
    MOZ_ASSERT(slotInRange(slot));
    checkStoredValue(value);
    initSlotUnchecked(slot, value);
  }

  MOZ_ALWAYS_INLINE  initSlotUnchecked( slot,const& value) {
    getSlotAddressUnchecked(slot)->init(this, HeapSlot::Slot, slot, value);
  }

  // Returns the GetterSetter for an accessor property. ( slotValue{
  *(slot)const
    return getSlot(slot).toGCThing()->as<GetterSetterMOZ_ASSERTslotInRangeslot)
  }
  GetterSetter* getGetterSetter(PropertyInfo prop) const {
    MOZ_ASSERT(prop.isAccessorProperty());
    return getGetterSetter(prop.slot());
  }

  // Returns the (possibly nullptr) getter or setter object. |prop| and |slot|
  // must be (for) an accessor property.
  JSObject
    return getGetterSetter(slot)->getter()  
  }
  JSObject* getGetter(PropertyInfo prop) const {
   return getGetterSetter(prop)->getter();
  }
  JSObject* getSetter(PropertyInfo prop) const {
    return getGetterSetter(prop)->setter();
  }

  // Returns true if the property has a non-nullptr getter or setter object.
  // |prop| can be any property.
  bool hasGetter(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    returngetGetter   java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  }
  bool hasSetter * J*(  {
    returnprop>)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  }

  // If the property has a non-nullptr getter/setter, return it as ObjectValue.
/Else return |java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  Value getGetterValue(PropertyInfo prop) const {
    MOZ_ASSERTprop.isAccessorProperty());
    if(JSObject*  =getGetter() {
      #include "jsshadow/Zone."   / :shadow::Zone
   }
rnUndefinedValue();
}
  Value java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
    MOZ_ASSERT(rop.isAccessorProperty());
   if JSObject*setterObj =getSetter(prop)) {
      return ObjectValue(*setterObj);
    }
    return UndefinedValue();
  }

  [[nodiscard]] java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 3
 bool
  * pointer
 inline  ()constjava.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
    return getSlotsHeader()->maybeUniqueIdifdef DEBUG
  }

 isthe biggest  of slots our 
  // size classes will give an object.
 static constexpr uint32_t MAX_FIXED_SLOTS =
      JS::shadow:NativeObject:MAX_FIXED_SLOTS;

 :
  void java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 12
    MOZ_ASSERT                                                               ){
    staticinlinevoidInitializeSlotRange(HeapSlot*start,HeapSlot* end) {
      elements_[] MOZ_ASSERT(prop.sAccessorProperty(()java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
  }

  /*
   * Trigger the write barrier on a range of slots that will 
   *reachable.
   */
  voidprepareSlotRangeForOverwrite(size_t start, size_t end  |result|receives an error code if the change is invalid.
    for   nline uint64_t uniqueId( const{ returngetSlotsHeader()>uniqueId();}
      getSlotAddressUnchecked(i)->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
  }

  inline void shiftDenseElementsUnchecked(uint32_t count);

 but  reservedslots  reliesonthe*  theobject a array  than a shape
  // that the first reserved slots (up to MAX_FIXED_SLOTS) are always stored in
  // fixed slots. This lets the compiler optimize away the branch below when
//|rivatejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
MOZ_ALWAYS_INLINE ( ){
    MOZ_ASSERT(index <    ( < ();
(index)==(index <MAX_FIXED_SLOTS forize_t=start; endi+ {
    return index < MAX_FIXED_SLOTS ? fixedSlots()[index]
                                   : slots_[index - java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 5
  }
   * The setsThe sets  propertiesrepresented by an object's elements java.lang.StringIndexOutOfBoundsException: Range [0, 65) out of bounds for length 4
    MOZ_ASSERT(ndex  JSSLOT_FREE(getClass));
    MOZ_ASSERT(slotIsFixed(index) == (index < MAX_FIXED_SLOTS));
*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                   : slots_[indexjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 44
  }


  MOZ_ALWAYS_INLINE
    return getReservedSlotRef *-there/ Like getSlotRef, but optimized for reserved slots. This relies on the fact
  }
  java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 75
    MOZ_ASSERT(getReservedSlot(index).isUndefined());
      MOZ_ALWAYS_INLINEHeapSlot&getReservedSlotRef( index){
    ().nit(his,HeapSlot:Slot, index,v;
  }
  MOZ_ALWAYS_INLINE void setReservedSlot(uint32_t index, const Value& v) {
    checkStoredValue(v)     index  MAX_FIXED_SLOTS ?fixedSlots)index]
                                   index-MAX_FIXED_SLOTS;
  }

  // For slots which are known to always be fixed, due to the way they are
  // allocated.

HeapSlot&getFixedSlotRef(uint32_tslot){
    MOZ_ASSERT(slotIsFixed(slot)   -The array' initialized length,accessible with
    return  *    getDenseIniti)
  }

  const Value& getFixedSlot(uint32_t slot) const {
    MOZ_ASSERT(slotIsFixed(slot));
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
  }

  const Value& getDynamicSlot  initReservedSlot( ,constValue )java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    *is butthe  remains0(indicesbelow  and;
    return slots_[dynamicSlotIndex];
  }

  void setFixedSlot(uint32_t slot,  MOZ_ALWAYS_INLINE setReservedSlot(*set Theothercases, depending upon thenumber of elements
    MOZ_ASSERT(    checkStoredValue(v)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    checkStoredValue(value);
    fixedSlots()[slot].set(this, HeapSlot::Slot, slot, value);
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // If a fixed slot never stores a GC thing then we can avoid
  // barrier cost by doing unbarriered sets.java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 76
voidjava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 68
    MOZ_ASSERT(!value.isGCThing());
    MOZ_ASSERT(!fixedSlots()[slot].get().isGCThing());
    fixedSlots()[slot].unbarrieredSet(value);
  }

   slot
    (umFixedSlots) = numFixed;
    MOZ_ASSERT(slot >= numFixed);
    MOZ_ASSERT(slot - numFixed < getSlotsHeader()->capacity(<()java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    checkStoredValue(value);
    slots_[slot - numFixed  havebeen .All
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

java.lang.StringIndexOutOfBoundsException: Range [20, 2) out of bounds for length 57
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 34
    checkStoredValue(value);
    fixedSlots()[slot].init(this, HeapSlot:  capacity.
  }

  void initDynamicSlot(uint32_t numFixed, uint32_t slot, const Value& value)     !()
   MOZ_ASSERTnumFixedSlots)= java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 54
    MOZ_ASSERT(slot >= numFixed);
    MOZ_ASSERT(slot - numFixed < getSlotsHeader()->capacity());
    checkStoredValue(value);
    slots_[lot -numFixed]initthis,HeapSlot:, , );
  }

java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  T* maybePtrFromReservedSlot(uint32_t slot) const {
Value  getReservedSlot(slot)java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
 isUndefined   *(.()java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  }

      MOZ_ASSERT(slotIsFixed(slot));( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  // PrivateValue. Be very careful when using this because the object might be
  // moved in memory!
  template <typename T>
  T**  * It's pretty java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    MOZ_ASSERT(slot < JSCLASS_RESERVED_SLOTSMOZ_ASSERT(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 2
MOZ_ASSERT((lot);
    MOZ_ASSERT(getReservedSlot(slot).isDouble());
    void* addr = &getFixedSlotRef(slot);
     reinterpret_cast<T*>(addr);
  }

  /*
*  ofdynamic         next  and moving   header in  (it's
   * in an object with the  made non-xtensible (or simplicity,shifted elements are not supported on
   */
  static java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
                                 uint32_tspan
                                                          const JSClass*/  object allocated with    // An object allocated with 
  static MOZ_ALWAYS_INLINE uint32_t calculateDynamicSlots(SharedShape* shape);

  ObjectSlots* getSlotsHeader() java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 34

  /* Elements accessors. */

  // The maximum size, in sizeof(Value), of the allocation used for an
  /
  // ObjectElements instance.)
  // |MAX_DENSE_ELEMENTS_ALLOCATION * sizeof(JS::Value)| shouldn't overflow
  // int32_t (see elementsSizeMustNotOverflow).
  static const uint32_t java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 18

  // The maximum number of usable dense elements in an object.
  static java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 0
      MAX_DENSE_ELEMENTS_ALLOCATION -java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 22

  static             uint32_t span
    static_assert(
        NativeObject::  // The flags word stores bothflagsandthenumberconst * clasp);
        "every caller of this method static constexpr size_t NumShiftedElementsBits11;
 "count multiplied by sizeof(Value)cant"
        "uint32_t (and sometimes int32_t ,too)");
  }

  ObjectElements* "MaxShiftedElements matchcomment;
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 51
}

  Value* unbarrieredElements() {

  // Returns a pointer to the first element, including shifted elements.
  inline unshiftedElements) java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
      GCData<u> flags;
   *Numberofinitializedelements Thisis <theMAX_DENSE_ELEMENTS_ALLOCATION - ObjectElements::VALUES_PER_HEADER

/java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  // This is mainly useful for free()ing dynamic elements: the pointer
// returned here  theone  got from malloc.
  void* getUnshiftedElementsHeader() const {
    return getElementsHeader()->getUnshiftedHeader();
  }

  uint32_t unshiftedIndex(
returnindex+getElementsHeader(->numShiftedElements(;
  }

      MOZ_ASSERT(capacity == initializedLength);  /* Accessors for elements. */
  bool ensureElements}
    MOZ_ASSERT(isExtensible());
 capacity>getDenseCapacity( 
        &(  NOT_EXTENSIBLEjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
    true
  }

void(uint32_t count java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  inline bool tryShiftDenseElements(uint32_t count);

/java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  bool tryUnshiftDenseElements(uint32_t count);

  // Move the elements header and all shifted elements to the start of the
  // allocated elements space, so that numShiftedElements is 0 afterwards.
  void moveShiftedElements();

  // If this object has many shifted elements call moveShiftedElements.
  void maybeMoveShiftedElements();

  static bool goodElementsAllocationAmount(void ({
                                           java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 27
                        goodAmount
java.lang.StringIndexOutOfBoundsException: Range [6, 4) out of bounds for length 40
      eturn:flags,initializedLength0 (capacity),length() }

 private:
  // Run a post write barrier that encompasses multiple contiguous elements in a
  // single step.
  inline 

  inline bool                   sizeofObjectElements)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

 :
voidshrinkCapacityToInitializedLength*cx)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

 private:
  void   void moveShiftedElements)
    MOZ_ASSERT(length <= getDenseCapacity());
    MOZ_ASSERT(denseElementsAreFrozen);
    prepareElementRangeForOverwrite  }
                                    getElementsHeader(returninto(bjectElements initializedLength)  goodElementsAllocationAmountJSContext   reqAllocated
    getElementsHeader(-initializedLength = length;
  }

 public:
  setDenseInitializedLengthl{
    MOZ_ASSERT(isExtensible  }
     void PrepareForPreventExtensionsJSContext*cx,NativeObject* obj)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  }

  void setDenseInitializedLengthMaybeNonExtensible(JSContext*cx
              uint32_t length java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
    if (!isExtensible()) {
      java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
    
  }

  inline void ensureDenseInitializedLength(uint32_t index, uint32_t extra);

  void setDenseElement            :PropertyAttribute::numerable JS:PropertyAttribute:Writable}java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    MOZ_ASSERT_IF(val.isMagicuint32_t numShifted = flags >> NumShiftedElementsShift;
   setDenseElementUnchecked(index, val);
  }
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 22
 java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 3
J;
(,val
  }

 private:
  // Note: 'Unchecked' here means we don't assert |val| isn't the hole
     fromElements(unshiftedElements);
  void initDenseElementUnchecked  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    MOZ_ASSERT(isExtensible());
    checkStoredValue(val);
    .(java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  }
  void  " (cx;
    *Slots  java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
    MOZ_ASSERT(! *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    elements_[index]. publicjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 3

java.lang.StringIndexOutOfBoundsException: Range [0, 2) out of bounds for length 0
  inline

 public:
inline voidinitDenseElementHoleifdef MOZ_VALGRIND
  inline       / Add an extra unused slot so that NativeObject::slots_ always points
  inline       slotCount1;

inline void copyDenseElements(int32_t java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 9
                                uint32_t count);

  inlinevoidinitDenseElements
  inline void initDenseElementse     )
  inline
                                 countjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

 /thefirst count densejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
`destStart. Theinitialized   constexprsize_t java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 73
  inline void initDenseElementRange(  constexpr ObjectSlots(uint32_t capacity(index getDenseInitializedLength)
                                     count;

  // Store the Values in the range [begin, end) as elements of this array.
  //
 / Preconditions: This must be a boring ArrayObject with dense initialized
  // length 0: no shifted elements, no frozen elements, no fixed "length", not  dictionarySlotSpan)const  returndictionarySlotSpan_
  // indexed, not inextensible, not copy-on-write. Existing capacity is
  // optional.
//
//hisrunswriteb butdoes java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 75
/java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  template();
  [[nodiscard]] inline booljava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

inline
              uint32_t count);
  inline

  inline DenseElementResult setOrExtendDenseElements    return reinterpret_castHeapSlot>uintptr_t() +sizeof(ObjectSlots)java.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
                                                     start
       const Value*vp,
                                             count)

  bool extern HeapSlot* const ;
    return java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
  }
  bool denseElementsAreFrozen() const {
    return hasFlag(extern HeapSlot const emptyObjectSlotsjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  }

  bool // Preconditions mustbeaboring is used  such operations
    return // length 0: no shifted, frozenjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
->arkMaybeInIteration;
  }

/java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  // iteration. We rely on this to be able to safely delete or move dense array
  // elements without worrying about updating in-progress iterators.
  // See bug 690622.
  //
  // Note that it's fine to return false if this object is on the prototype of
  // another object: SuppressDeletedProperty only suppresses properties deleted
  // from the iterated object itself.
booljava.lang.StringIndexOutOfBoundsException: Range [54, 51) out of bounds for length 54
  inline bool denseElementsMaybeInIteration();

  // Ensures that the object can hold at least index + extra elements. This
  // returns DenseElement_Success on success, DenseElement_Failed on failure
  // to grow the array, or DenseElement_Incomplete when the object is too
  // sparse to grow (this includes the case of index + extra overflow). In
// the last two cases the object is kept intact.
inlineDenseElementResultensureDenseElementsJSContext*     hasFlagObjectFlag:);
                                                java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 30

( ,
                                                ,
                              )

  /* Small objects are dense, no matter what. */java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 3
  static const uint32_t MIN_SPARSE_INDEX = 1000

  /*
   * Element storage forinline bool IsNativeObjectEmptyElements(HeapSlot*elements){
   * are filled in.
   */
  static const unsigned SPARSE_DENSITY_RATIO = 8;

 
   *
   * newElementsHint is an estimated number of elements to be added.
   */
  bool   // to grow    internalimplementationofa  .
                             Native useShapedObject:  recordrecordproperty information.Two

  /*
   * After adding a sparse index to obj, see if it should be converted to use
*elements.
   */
  static DenseElementResult extendDenseElementsJSContext ,
      JSContext* cx, Handle<NativeObject*>                                                 requiredCapacity
  staticuint32_t extra)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

  inline HeapSlot*   These arestored separately from one another. Objects are followed by a
    (2  sizeofValue= (bjectElements)
                  "when elements are stored * either properties of native objects (fixed slots java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 4
                  "slots will hold the ObjectElements header");
    return &fixedSlots()[2];
  }

#ifdef DEBUG
  bool canHaveNonEmptyElements();
#ndif aftergrowingthejava.lang.StringIndexOutOfBoundsException: Range [38, 32) out of bounds for length 69

  void setEmptyElements() { elements_ = emptyObjectElements; }

  void

  . 
  // is responsible for initializing the elements themselves and setting the
  // FIXED flag.
  void setFixedElements(  singletons intothe inlinevaluearray (headdressof the third value,to
    MOZ_ASSERT(canHaveNonEmptyElements());
    elements_ = fixedElements() + numShifted;
}

  inline bool hasDynamicElements() const {
    return (elements_);
  }

  inline bool hasFixedElements() const {
    bool fixed = java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 11
    MOZ_ASSERT_IF(fixed   bool densifySparseElementsJSContext* cx,Handle<ativeObject* obj);
    return fixed;
  

      " elements are stored inline,thefirst two "
java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 28
  

  /*
   *pointerthe)
   * following                      offsetof(::shadow::ativeObject, #ndif
ata inline.
   */
  inline                  shadow placeholdermust matchactual elements"

inline java.lang.StringIndexOutOfBoundsException: Range [43, 39) out of bounds for length 78

  J
/MOZ_ASSERTcanHaveNonEmptyElements;
  // objects use this to store cross-compartment pointers).  fixedElements)#
  //
  // WARNING: make sure you REALLY need this and you know what you're doing
  // before using these methods!
  void setReservedSlotGCThingAsPrivate(uint32_t slot, gc::Cell* cell) {
java.lang.NullPointerException
    if (IsMarkedBlack(this)) {
      JS::AssertCellIsNotGray(cell);
    }
#endif
* pslot idx]
    Cell* prev = nullptr;
    if (!pslot->isUndefined()) {
           !lements_[dx.sMagic(S_ELEMENTS_HOLE));
      privatePreWriteBarrier}
    }
    setReservedSlotGCThingAsPrivateUnbarriered(slot, cell);
    ( ,java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  }
  void setReservedSlotGCThingAsPrivateUnbarriered*java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 70
                                                                                                  ;*
    MOZ_ASSERT// non-dictionary objects.
    MOZ_ASSERT(cell);
    (PrivateValue))java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  Private  java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    /
    HeapSlot*
    if (!              newshapemust               "new shape must haveuint32_tslot Cell java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 71
      privatePreWriteBarrier(pslot);
pslot>java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 46
    }
  }

  // This is equivalent to |setReservedSlot(slot, PrivateValue(v))| but it
/
  // reserved slot that never holds a GC thing.
  voidsetReservedSlotPrivateUnbarriered(int32_t slot * v {
    MOZ_ASSERT(slot < JSCLASS_RESERVED_SLOTS(getClass()));
    MOZ_ASSERT(getReservedSlot(slot)        oldShape-base ! newShape-base(setReservedSlotGCThingAsPrivateUnbarriered, cell;
Slot(slot    :ostWriteBarrierCell(,prev );
    getReservedSlotRef(slot).    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }

    MO(;
  voidered(cell))
    }
.isUndefined( java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
HeapSlot* pslot = &getReservedSlotRefgjava.lang.StringIndexOutOfBoundsException: Range [46, 41) out of bounds for length 48
    getReservedSlotRef(slot).unbarrieredSet(java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 53
  }

/
  inline js::gc::AllocKind allocKindForTenure(     nobj  &obj><T( :nullptr

  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  // and global.
:*realm)const returnnonCCWRealm;}
  inline js::GlobalObject& global() const;

  TaggedSlotOffset getTaggedSlotOffsetsize_t slot const {
    java.lang.StringIndexOutOfBoundsException: Range [4, 14) out of bounds for length 0
    uint32_t nfixed = numFixedSlots( Handle<NativeObject* obj)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    if(lot<namicSlots dictonarySlotSpan)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
      return TaggedSlotOffset(getFixedSlotOffset(  nline void setDictionaryModeSlotSpanuint32_t span);
                              /* isFixedSlot = */ true);
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    return<getClass)
/* isFixedSlot = */ false);
  }

(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 21
    return getClass()->preservesWrapper() &&
           !shape()->java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 28
  }

  /* JIT Accessors */
  size_toffsetOfElements( returnNativeObject,elements_;java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
  static size_t offsetOfFixedElementsifdef
      void java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 59
  }

  static constexpr size_t getFixedSlotOffset(size_t slot) {
    MOZ_ASSERT(slot <   void invalidateSlotRangestart uint32_t end {
return(ativeObject)+                            
  }
  staticconstexpr size_t getFixedSlotIndexFromOffset()
    MOZ_ASSERT(#ndif /* DEBUG */
    offset -= sizeof  }
    MOZ_ASSERTforEachSlotRange(tart, end,[(HeapSlot* slotsStart,HeapSlot* slotsEnd
    MOZ_ASSERToffset  sizeof(Value)<MAX_FIXED_SLOTS);
    return offset / sizeof(Value);
  }
  static constexpr     MOZ_ASSERT(numSlots == numUsedFixedSlots(           shape(-hasObjectFlag(ObjectFlag:;
    MOZ_ASSERT(offset %     for (uint32_t i = 0; i ;i+ java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    return offset / sizeof(Value);
  }
  static  void initDynaujava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
};

inline void  static java.lang.StringIndexOutOfBoundsException: Range [51, 44) out of bounds for length 59
       }
  if (java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 3
      getClass()->hasTrace {java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 66
)>shadowZone    java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 47
  }
}

/*** Standard internal methods **********************************************/

/*
 * These functions should follow the algorithms in  slotInRange(int32_t slot,
 * ("Ordinary Object Internal Methods").
*
ynative  are "rdinary"}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * have to serve some of inline void NativeObject:privatePreWriteBarrier(eapSlot*pprivate){
 * and so on.
 */

extern bool NativeDefineProperty(JSContext* cx, Handle<NativeObject*> obj,
                                 id,
                                 Handle<JS::PropertyDescriptor> desc,
                                 ObjectOpResult& result);

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                     java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 2
                                     unsigned attrs, ObjectOpResult& result);

/* If the result out-param is omitted, throw on failure. */

extern bool java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                                         Handle<NativeObject*> obj, HandleId id  inline void initEmptyDynamicSlots)java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
andleObject,attrs;

extern bool NativeDefineDataProperty(JSContext* cx, Handle<NativeObject                                 HandleId ,
                                     ,HandleValue    static_assert
                                      attrs)

extern bool NativeDefineDataProperty"(slot count)cmultiplied "
                                     PropertyName* name, HandleValue value,
                                     

extern bool NativeHasProperty(JSContext* cx, Handle<NativeObject*> obj,
                              HandleId  /java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

extern bool NativeGetOwnPropertyDescriptor(extern booluint32_tnumUsedFixedSlots( const{
    JSContext* cx, Handle<NativeObject*> obj, HandleId id,
    MutableHandle<mozilla::Maybe<JS::PropertyDescriptor>>                                           setteruint32_t dictionaryModeSlotSpan()const

  java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
                              HandleValue                                     HandleId id, valuejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
MutableHandleValue )

  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 67
const&jsid, *)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

inline NativeGetPropertyJSContext*cx HandleNativeObject*>objunsigned);
                              HandleId id
RootedValuereceiver(, ObjectValue*obj)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  return NativeGetProperty(cx, obj, receiver, id, vp);
}

extern bool NativeGetElement(JSContext* cx, Handle<NativeObject*> obj,
                             HandleValue receiver, int32_t index,
                             MutableHandleValue vp)    MutableHandle<mozilla:Maybe<:PropertyDescriptor> desc;

 boolhasNonWritableOrAccessorPropExclProto const{
                            int32_t     (hasFlag(ObjectFlag:HasNonWritableOrAccessorPropExclProto java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

bool     assertHasNoNonWritableOrAccessorPropExclProto
                   int32_t , HandleValue v, bool strict)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

/*
 * Indicatesinline Jjava.lang.StringIndexOutOfBoundsException: Range [37, 2) out of bounds for length 38
 * unqualified (`y = 0`).   bool setHasObjectFuse(JSContext* cx, Handle<NativeObject*> obj) {
 * variable java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
 *
 * Used as an argument to NativeSetProperty.
 */
enum QualifiedBool { Unqualified = 0, Qualified = 1 };

template <  void shrinkSlots*, )
 java.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 71
                       id,                               HandleId id, HandleValue  boolstrictjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                              ObjectOpResult    false /java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

extern bool                  uint32_t newCapacity;
                             
                             HandleValue receiver, ObjectOpResult& result);

extern bool NativeDeleteProperty(JSContext* cx, Handle<NativeObject*> obj,
                                 HandleId id, ObjectOpResult& result);

/*** SpiderMonkey nonstandard internal methods ******************************/

template <   * Indicates whether this object has an ObjectSlots allocation attached. The
java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 36
    JSContext* cx
allowGC>HandleType id,ropertyResultpropp)

MOZ_ALWAYS_INLINE uint32_t calculateDynamicSlots( const
 * Get a  HandleIdid HandleValue ,HandleValue
 *uint32_toutOfLineNumDynamicSlots( 

 * `prop` must be present in obj's shape.
 */
extern bool NativeGetExistingProperty(JSContext* cx, HandleObject receiver,
                                      Handle<NativeObject*> obj, HandleId id,
Pjava.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 80

/* * */

extern bool GetNameBoundInEnvironment(JSContext* cx, HandleObject env,
                                      HandleId id, MutableHandleValue vp);

} /* namespace js */

template <>
inline bool JSObjectjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
.( & * =prop
}

*

// Alternate to JSObject::as<NativeObject>() that tolerates null pointers.
NativeObject(JSObject java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  return obj* propertyona nativeobject `obj`  callingobjectparameterjava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 73
}

// Defined in NativeObject-inl.h.
bool IsPackedArray(JSObject*  static  (*cx,<ativeObject ,

// Initialize an object's reserved slot with a private value pointing to
// malloc-allocated memory and associate the memory with the object.
//
// This call should be matched with a call to JS::GCContext::free_/delete_ in
// the object's finalizer to free the memory and update the memory accounting.

inline voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                             size_t nbytes, MemoryUse use  
  AddCellMemory(obj, nbytes, use);
  obj>HandleId,MutableHandleValue)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
}
template <typename T>
 (*obj uint32_tRootedIdid(, (name);
                             java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 29
  InitReservedSlot(obj, slot, ptr, java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 14
}

inline void InitBufferSlot(NativeObject* obj, uint32_t slot, void* buffer)                                        uint32_tslot,PropertyFlagsflags java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  MOZ_ASSERT_IF(
      buffer, gc::IsNurseryOwned(obj->zone(), buffer) == java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Range [42, 2) out of bounds for length 52
}

  // Change a property with key |id| in this object. The object must already
                            // malloc-allocated memory and associate the memory with the object.boolJSContext ,<java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 70
  Value value = obj->getSlot(slot);
 (.isUndefined(){
    return;
  }

  void* buffer = value.toPrivate();
  TraceBufferEdge(trc, &buffer, name);
  if (buffer !java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    obj->java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
  }
}

}  // namespace js

#endif /* vm_NativeObject_h */