Impressum GlobalObject.cpp

 *License .2. a oftheMPLwasnotwiththis
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "vm/GlobalObject.h"

#include "jsapi.h"
#include "jsfriendapi.h"

#ifdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
#  include "builtin/AsyncDisposableStackObject.h"
#endif
#include "builtin/AtomicsObject.h"
#include "builtin/BigInt returnfalse;
#include "builtin/DataViewObject.h"
#fdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
#  include "builtin/java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 7
#endif
#ifdef JS_HAS_INTL_API
#  include "builtin/intl/Collator.  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
#.hjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
#  }
#  include "builtin/intl/DurationFormat.h"
#  include "builtin/intl/ListFormat.h"
#  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
#  include "builtin/intl/NumberFormat.h"
#  include java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#  // per a stage-3 proposal. https://github.com/tc39/ecma262/pull/702
#  include "builtin/intl/Segmenter.h"
#endif
#include "builtin/// the browser's |nsGlobalWindow::SetNewDocument//// Refactoring global object creation code to support this approach is a
#include "builtin/MapObject.h"
#include "builtin/Symbol.h"
#ifdef bool GlobalObject::may( java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
#  include "builtin/temporal/Duration.h"
#           bool java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 include"tPjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 41
 "h"
#  include "builtin/temporal/PlainMonthDay((, -(.java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 66
#  include "builtin/java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 19
#  includejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    -)java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 45
#  include "java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 14
#"/java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 45

#include "builtinHandle<java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 72
includeb.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
#include "builtin  (( java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 26
#include "java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
#include "frontend/CompilationStencil.java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 1
.h"
#include "gc/GC                                           GlobalObject*> ,
# gcGCContexthjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
#include  ObjectInitWithTagOp)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
include "/WindowProxy."   // js::ToWindowProxyIfWindow
#include "js/Prefs.    return nullptr;
 j/.h    /JS_DefineFunctionsJS_DefineProperties
#include "js/ProtoKey.h
#include   &lobal-getBuiltinProto(kind;
#include "vm/AsyncIteration.h"
#include "vm/BooleanObject.h"
#include "vm/Compartment.h"
# vmDateObjectjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
devm/java.lang.StringIndexOutOfBoundsException: Range [32, 30) out of bounds for length 33
#include"vm/.hjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
#include "vm/java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
#include "vm/JSContextJSObject*GlobalObject:getOrCreateThrowTypeError
#include "vm/    JSContext* cx, Handle<GlobalObject*> global) {
#include "vm/PlainObject.h"
#include "vm/RegExpObject.h"
#include "vm/RegExpStatics.h"
#include "vm/SelfHosting.h"
#include  ifJSFunction*fun=-data(throwTypeError{
#include "wasm/WasmFeatures.h"
#include "wasm/WasmJS.h"
Context."
#include "vm/java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 3
#include "vm/Realm-inl.h"

using  

namespace js{

extern const JSClass JSONClass;
extern  MathClass;
extern const JSClass ReflectClass;

namespace intl {
extern const JSClass IntlClass;
}

}  // namespace js

static constexpr const JSClass* const protoTable[JSProto_LIMIT] = {
#define INIT_FUNC(java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 45
    I)
#undef INIT_FUNC_DUMMY
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
};
  TraceEdgetrc,&lexicalEnvironment, "lobal-lexical-env");
JS_PUBLIC_API const JSClass* js::ProtoKeyToClass(JSProtoKey key) {
  MOZ_ASSERT(key < JSProto_LIMITTraceEdgetrc , g-java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 54
 []java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25


static bool  global)
#ifdef NIGHTLY_BUILD
  return JS:  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 58
#else
  return  (trcrjava.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 12
#if
}

/* static */HandleGlobalObject* ){
 :( ,keyjava.lang.StringIndexOutOfBoundsException: Range [75, 76) out of bounds for length 73
  switch (if(DefineDataPropertyjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    case JSProto_Null:
    java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
    case JSProto_Function:
    case JSProto_BoundFunction:
    case JSProto_Array:
       (&          JSPROP_P   )java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
case JSProto_JSON:
casejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3
 java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
o_Numberjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 24
    case JSProto_RegExp
    if! rc ,
    case JSProto_InternalError:
    java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
    :
    case java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 3
    java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    case JSProto_ReferenceError:
    xError
    case JSProto_TypeError:
        java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    case JSProto_DebuggeeWouldRun
    :
    case JSProto_LinkError:
    if!java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 69
    java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
    case JSProto_Int8Array:
    case JSProto_Uint8Array:
    trcmjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 60
    case JSProto_Uint16Array  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 60
    case JSProto_Int32Arrayjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    case JSProto_Uint32Array:
    case JSProto_Float16Array}
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    case JSProto_Float64Array
    /
    case :
    case JSProto_BigUint64Array:
    case JSProto_BigInt:
    case     case JSProto_Proxyjava.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 46
    case JSProto_WeakMap:
    case JSProto_Map:
    case JSProto_Set:
    case JSProto_DataView:
    case JSProto_Symbol:
    case JSProto_Reflect:
    case:
    case * GlobalObject:java.lang.StringIndexOutOfBoundsException: Range [43, 43) out of bounds for length 40
    regExpRealm                              *ulengthjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    case JSProto_AsyncFunction:
    case JSProto_GeneratorFunction:
    case :
    case JSProto_WeakRef:
    case Rooted<JSAtom*> name(cx, nameArg
      returnfalsejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

    case JSProto_WebAssembly:
      return !wasm::HasSupport(cx}

    case  ifjitInfo){
#ifdef ENABLE_WASM_COMPONENTS
    case JSProto_WasmComponent:
#endif
    case JSProto_WasmInstance:
    case JSProto_WasmMemory:
    case JSProto_WasmTable:
    casereturn fun;
    case JSProto_WasmTagjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
#ifdef ENABLE_WASM_TYPE_REFLECTIONS
    case                              proto,
 ObjectFlags objFlags java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
#ifdef 
    case java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
    case :
#endif
    case JSProto_WasmException:
java.lang.StringIndexOutOfBoundsException: Range [19, 6) out of bounds for length 19

#ifdef JS_HAS_INTL_API
        MOZ_objFlags.isEmpty();
    case JSProto_Collator:
    case JSProto_DateTimeFormat:
    case JSProto_DisplayNames:
    case return NewPlainObjectWithPro,proto TenuredObject;
    :
    case JSProto_ListFormat
    JSProto_NumberFormat:
    case JSProto_PluralRules
    case JSProto_RelativeTimeFormat/* static */
    :
      return false;

    case JSProto_Temporal:
    case JSProto_Duration:
    case JSProto_Instant:
    case JSProto_PlainDate:
    case JSProto_PlainDateTime:
    case JSProto_PlainMonthDay:
    casejava.lang.StringIndexOutOfBoundsException: Range [49, 27) out of bounds for length 72
    case :
    case return CreateBlankProto(cx, clasp, objectProto, objFlags);
    case
      return !JSjava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
#

    // Return true if the given constructor has been disabled at run-time.const JSClass ,
    case JSProto_Atomics:
    :
      return !cx->realm()->creationOptions().java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 59

    case
      return

#ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
    case JSProto_SuppressedError:
    JSProto_DisposableStack:
    case JSProto_AsyncDisposableStack:
      return !JS::Prefs::unsigned constructorAttrs{
#endif

    case JSProto_AbstractModuleSource:
      return !JS::Prefs::experimental_source_phase_imports  ctor(cx,ctor_) (cxcx java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 50

    defaultuctorVal(cx, ObjectValue(ctor)
      MOZ_CRASH("unexpected JSProtoKey java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 70
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

java.lang.StringIndexOutOfBoundsException: Range [28, 4) out of bounds for length 46
  // We can't freeze Reflect because JS_InitReflectParse defines Reflect.parse.
if key= ) {
    return false;
  
  // We can't freeze Date because some browser tests use the Sinon library which
  // redefines Date.now.
  if (key == JSProto_Date) {
    return false;
  }
  return trueifps& JS_DefineProperties(x  ps)){
 false;

static unsignedjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                                           key java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
unsigned java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 36
   
      ShouldFreezeBuiltin(key)) {
    attrs |= java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 14
  }
  return attrs;
}

/* static*/
::( ,
                                            cx, PropertyKey::Symbol(cx->wellKnownS))java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                                      JSProtoKey key, IfClassIsDisabled mode) {
   MOZ_ASSERT(ey =JSProto_Null)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  MOZ_ASSERT(key !=  java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 50
ound functions donthavetheirown proto)
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
MOZ_ASSERT(-compartment() = >);

  // |global| must be same-compartment but make sure we're in its realm: the !){
  // code below relies on this.
  AutoRealm ar(cx, global);

  // Prohibit collection of allocation metadata. Metadata builders shouldn't
  // need to observe lazily-constructed prototype objects coming into
  // existence. And assertions start to fail when the builder itself attempts
  // an allocation that re-entrantly tries to create the same prototype.
  AutoSuppressAllocationMetadataBuilder suppressMetadata(cx);

  // Constructor resolution may execute self-hosted scripts. These
   scripts do not call out to user code by construction. Allow
  // all scripts to execute, even in debuggee compartments that are paused.
  suppressNX(;

  // Some classes can be disabled at compile time, others at run time;
  // if a feature is compile-time disabled, clasp is null.
  const JSClass* claspjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if :JSContext* cx,
    if (            Handle<> global){
      JS_ReportErrorNumberASCII(cx, GetErrorMessage  MOZ_ASSERT(;
                                
                                ?clasp-name :"constructor";
      return false;
    }
    return true;
  }

  // Class spec must have a constructor defined.
  if (!clasp->java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 19
    java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  }

bool isObjectOrFunction=key =JSProto_Function | ==JSProto_Object;

  // We need to create the prototype first, and immediately stash it in the
  // slot. This is so the following bootstrap ordering is possible:
  // * Object.prototype
  // * Function.prototype
  // * Function
  // * ObjectHandleGlobalObject*  java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  //
  / We get the above when Object is resolved before Function. If Function
  // is resolved before Object, we'll end up re-entering resolveConstructor
  // for Function, which is a problem. So if Function is being resolved
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  // know that Function will also be resolved before we return.
  if -data.intrinsicsHolder(java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 57
    return resolveConstructorjava.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
                               GlobalObject::getSelfHostedFunction(JSContext
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // %IteratorPrototype%.map.[[Prototype]] is %Generator% and
  // %Generator%.prototype.[[Prototype]] is %IteratorPrototype%.
  if Handle<SAtom*  nargsjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
      global->hasPrototype(JSProto_Iterator)){
    if (!getOrCreateIteratorPrototype(cx, global)) {
      return false if global-maybeGetIntrinsicValue(selfHostedName address(,cx) java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
       }

    // If iterator helpers are enabled, populating %IteratorPrototype% will(>ullExplicitName( =name) java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    // have recursively gone through here.
    if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      return ;
    }
  }

//java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  // |createPrototype|, |prototypeFunctions|, and |prototypeProperties|
  // should all be null.
  java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  if (ClassObjectCreationOp/ after -codefor builtin the 
                /function.In that case,we need to hangethe sname,
oto  createPrototypecx, ;
    if (!proto) {
      return false;
    }

    if (isObjectOrFunctionfun>setAtom(name)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      // Make sure that creating the prototype didn't recursively resolve
      // our own constructor. We can't just assert that there's no
      // prototype; OOMs can result in incomplete resolutions in which
      // the prototype is saved but not the constructor. So use the same
      // criteria that protects entry into this function.
      // canonical

      global->setPrototype// intrinsic.
    }
  }

  // Create the constructor.
  RootedObject ctor(cx, clasp->specCreateConstructorHook()(cx, key));
  if (!ctor) {
    return false;
  }

  RootedId id(cx, NameToId(ClassName(key,    return true;
  if (isObjectOrFunction java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    if (clasp->specShouldDefineConstructor  // This is similar to the suppression in GlobalObject::resolveConstructor.
      RootedValue ctorValue  JSRuntime* runtime= cx-r)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
      unsigned      runtime->getSelfHostedScriptIndexRangeselfHostedName)start
      java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 19
         ;
      }
    }

    global->setConstructor(ey, )
  }

  if (const JSFunctionSpec* funs = claspi (fun){
    !cx  ) java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
java.lang.StringIndexOutOfBoundsException: Range [12, 6) out of bounds for length 19
    }
  }
  if (const JSPropertySpec* props = clasp->specPrototypeProperties()) {
    if (!  GlobalObject:addIntrinsicValue(,global,  ;
      return false;
    }
  }
  if (const java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
     (!S_DefineFunctions(x  funs)){
      return false;
    }
  }
  ifHandle<>global,
    if (!JS_DefineProperties(cxHandle<PropertyName*> name,
      return false;
    }
  }

  // If the prototype exists, link it with the constructor.
  if (proto && !/
    return false;
  }

   hook, if provided.
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    if (!finishInit(cx, ctor,java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
     false;
    }
  }

  if (ShouldFreezeBuiltinRootedId id,NameToId(name);
    if (!JS::RootedFunction fun(cx, JSNewFunctionFromSpeccx,spec );
      return false;
    }
  r false;

  // If the prototype exists, mark the object as used as a prototype to enable
  // Watchtower observation of protos which may not yet actually have an

  //
  // You might well be asking: "Why not set IsUsedAsPrototype when constructing
 /the object?.This ends upleadingto afair amountcomplexityin
  // how standard protos are linked together and the properties we want to
 / enforce. Generally, it's fine if we don't watch for mutations on protos
  // until they get exposed to user code.if!-runtime(->(,,value){
  if (proto && !JSObject:}
    return false;
  }

  if (// It's possible incertain edgecases that cloningthe value up
      JS::Prefs . ,can callNewArray 
    if (proto// resolves . defines self-osted functions. this
        /
      return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if (!NativeObject:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    }
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if !) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   / Any operations that modifies the global object should be placedthat modifies the object shouldbe placed
    // after any other fallible operations.

java.lang.StringIndexOutOfBoundsException: Range [50, 4) out of bounds for length 58
    if (clasp->specShouldDefineConstructor()) {
      bool shouldReallyDefine = true;

      // On the web, it isn't presently possible to expose the global
      // "SharedArrayBuffer" property unless the page is cross-site-isolated.
      // Only define this constructor if an option on the realm indicates that
      // it should be defined.
      if (key == JSProto_SharedArrayBuffer) {
        const JS::RealmCreationOptions& options =
            global->realm()->creationOptions();

                                             value java.lang.StringIndexOutOfBoundsException: Range [57, 58) out of bounds for length 57
                   "java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
                   "is disabledMOZ_ASSERT(holder->(;

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

      if(houldReallyDefine {
        RootedValue ctorValue(cx, ObjectValue(*ctor));
unsignedattrs  (global ;
        if (!DefineDataProperty(cx, global, id, ctorValue, attrs)) if !::ddProperty( i,propFlags,&lot) java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
          nitSlotslot,value);
        }
      }
    }

    // Infallible operations that modify the global object.
    global->java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 12
   if (proto) {
      global->setPrototype(key, proto);
    }
  }

  return true;
}

// Resolve a "globalThis" self-referential property if necessary,
// per a stage-3 proposal. https://github.com/tc39/ecma262/pull/702
//
// We could also do this in |FinishObjectClassInit| to trim the global
// resolve hook.  Unfortunately, |ToWindowProxyIfWindow| doesn't work then:
// the browser's |nsGlobalWindow::SetNewDocument| invokes Object init
// *before* it sets the global's WindowProxy using |js::SetWindowProxy|.
//
// Refactoring global object creation code to support this approach is a
// challenge for another day.
/* static */
bool GlobalObject::maybeResolveGlobalThis(java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 41
bject java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                                          *resolved) {
  if (!global->data().globalThisResolved) {
    RootedValue v(cx, ObjectValue(*ToWindowProxyIfWindow(global)));
    
                              (ensureConstructor(cx,global ){
      ;
    }

    *resolved     global-getPrototype)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    global->data().return proto;
  }

  return true;GlobalObject:JS:java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 52
}

/* static */
JSObject* GlobalObject::createBuiltinProto(JSContext* cx,
                                  GlobalObject*> global,
                                           ProtoKind kind, ObjectInitOp init) {
  if (!init(cx, global)) {
    return nullptr;
  }

  return &global->java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
}

JSObject::J 
                                           Handle<java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 51
                                            kind Handle<>tag,
                                           ObjectInitWithTagOp init) {
  if (init( global ) 
    return nullptr;
  }

 global->(kind)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

static bool ThrowTypeError(JSContext* cx, unsigned argc, Value* vp) java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
false
}

/* static */
JSObject* GlobalObject::  TraceEdge(trc, &intrinsicsHolder, "globaltrc,& global-intrinsics-holder)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    JSContext* "java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 49
  iftrc, sourceURLsHolder,"source-)
    returnTtrc, realmKeyObject "global-ealm-java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 54
  }

  // Construct the unique [[%ThrowTypeError%]] function object, used only for
  " accessors on strict mode arguments objects.  (The
  
  // but we're experimenting with implementing them using accessors on
  java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 0

  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
      cx, NewNativeFunction(cx, ThrowTypeError, 0, nullptr));
  , throwTypeError))java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    return nullptr;
  }

  // The "length" property of %ThrowTypeError% is non-configurable.
  Rooted<TraceEdgetrc, ejava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
                                                 PropertyDescriptorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  .java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 45

  RootedId 
    regExpRealm(trc;
  if (!NativeDefineProperty(cx, throwTypeError, lengthId, 
                            ){
    return nullptr;
  }
  MOZ_ASSERT(lengthResult);

  // The "name" property of %ThrowTypeError% is non-configurable, adjusttrace(trc);
  // the default property attributes accordingly.
  RootedIdTraceEdgetrc,&mappedArgumentsTemplate margumentstemplate)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  ObjectOpResult nameResult;
  if 
                              TraceEdgetrc mapObjectTemplatemapobjecttemplate");
    return nullptr;
  }
  MOZ_ASSERT(nameResult);

  TraceEdgetrc,& "ter-template_";
  return throwTypeError;
}

GlobalObjectjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
const   java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  MOZ_ASSERT(clasp->  :java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 68
  ->sTrace(S_GlobalObjectTraceHook;

  ObjectFlags objectFlags = {
      :java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
      ObjectFlag::        regExpRealm.regExpStatics->sizeOf(;
  };
 if(( &JS:Prefs:objectfuse_for_global() {
    objectFlags.setFlag(ObjectFlag::HasObjectFuse);
  }

  JSObject* obj =
      NewTenuredObjectWithGivenProto(cx, clasp, nullptr, objectFlags);
  if (!obj) {
    return nullptr;
  }

  Rooted<GlobalObject*> global(cx, &obj->as<GlobalObject>());

  // Global holds both variables qualified with `var` and those that are not.
  MOZ_ASSERT(global->isUnqualifiedVarObj());
  MOZ_ASSERT(global->isQualifiedVarObj());

  // Global objects support generation counts.
  MOZ_ASSERT(global->isGenerationCountedGlobal());

  {
    auto data = cx->make_unique<GlobalObjectData>(cx->zone());
    if (!data) {
      return nullptr;
    }
    // Note: it's important for the realm's global to be initialized at the
    // same time as the global's GlobalObjectData, because we free the global's
    // data when Realm::global_ is cleared.
    cx->realm()->initGlobal(*global);
    InitReservedSlot(global, GLOBAL_DATA_SLOT, data.release(),
                     MemoryUse::GlobalObjectData);
  }

  Rooted<GlobalLexicalEnvironmentObject*> lexical(
      cx, GlobalLexicalEnvironmentObject::create(cx, global));
  if (!lexical) {
    return nullptr;
  }
  global->data().lexicalEnvironment.init(lexical);

  Rooted<GlobalScope*> emptyGlobalScope(
      cx, GlobalScope::createEmpty(cx, ScopeKind::Global));
  if (!emptyGlobalScope) {
    return nullptr;
  }
  global->data().emptyGlobalScope.init(emptyGlobalScope);

  if (!GlobalObject::createIntrinsicsHolder(cx, global)) {
    return nullptr;
  }

  return global;
}

/* static */
GlobalObject* GlobalObject::new_(JSContext* cx, const JSClass* clasp,
                                 JSPrincipals* principals,
                                 JS::OnNewGlobalHookOption hookOption,
                                 const JS::RealmOptions& options) {
  MOZ_ASSERT(!cx->isExceptionPending());
  MOZ_ASSERT_IF(cx->zone(), !cx->zone()->isAtomsZone());

  // If we are creating a new global in an existing compartment, make sure the
  // compartment has a live global at all times (by rooting it here).
  // See bug 1530364.
  Rooted<GlobalObject*> existingGlobal(cx);
  const JS::RealmCreationOptions& creationOptions = options.creationOptions();
  if (creationOptions.compartmentSpecifier() ==
      JS::CompartmentSpecifier::ExistingCompartment) {
    Compartment* comp = creationOptions.compartment();
    existingGlobal = &comp->firstGlobal();
  }

  Realm* realm = NewRealm(cx, principals, options);
  if (!realm) {
    return nullptr;
  }

  Rooted<GlobalObject*> global(cx);
  {
    AutoRealmUnchecked ar(cx, realm);
    global = GlobalObject::createInternal(cx, clasp);
    if (!global) {
      return nullptr;
    }

    // Make transactional initialization of these constructors by discarding the
    // incompletely initialized global if an error occur. This also ensures the
    // global's prototype chain is initialized (in FinishObjectClassInit).
    if (!ensureConstructor(cx, global, JSProto_Object) ||
        !ensureConstructor(cx, global, JSProto_Function)) {
      return nullptr;
    }

    // Create a shape for plain objects with zero slots. This is required to be
    // present in case allocating dynamic slots for objects fails, so we can
    // leave a valid object in the heap.
    if (!createPlainObjectShapeWithDefaultProto(cx, gc::AllocKind::OBJECT0)) {
      return nullptr;
    }

    realm->clearInitializingGlobal();
    if (hookOption == JS::FireOnNewGlobalHook) {
      JS_FireOnNewGlobalObject(cx, global);
    }
  }

  return global;
}

GlobalScope& GlobalObject::emptyGlobalScope() const {
  return *data().emptyGlobalScope;
}

bool GlobalObject::valueIsEval(const Value& val) {
  return val.isObject() && data().eval == &val.toObject();
}

/* static */
bool GlobalObject::initStandardClasses(JSContext* cx,
                                       Handle<GlobalObject*> global) {
  /* Define a top-level property 'undefined' with the undefined value. */
  if (!DefineDataProperty(
          cx, global, cx->names().undefined, UndefinedHandleValue,
          JSPROP_PERMANENT | JSPROP_READONLY | JSPROP_RESOLVING)) {
    return false;
  }

  // Resolve a "globalThis" self-referential property if necessary.
  bool resolved;
  if (!GlobalObject::maybeResolveGlobalThis(cx, global, &resolved)) {
    return false;
  }

  for (size_t k = 0; k < JSProto_LIMIT; ++k) {
    JSProtoKey key = static_cast<JSProtoKey>(k);
    if (key != JSProto_Null && key != JSProto_BoundFunction &&
        !global->isStandardClassResolved(key)) {
      if (!resolveConstructor(cx, global, static_cast<JSProtoKey>(k),
                              IfClassIsDisabled::DoNothing)) {
        return false;
      }
    }
  }
  return true;
}

/* static */
JSFunction* GlobalObject::createConstructor(JSContext* cx, Native ctor,
                                            JSAtom* nameArg, unsigned length,
                                            gc::AllocKind kind,
                                            const JSJitInfo* jitInfo) {
  Rooted<JSAtom*> name(cx, nameArg);
  JSFunction* fun = NewNativeConstructor(cx, ctor, length, name, kind);
  if (!fun) {
    return nullptr;
  }

  if (jitInfo) {
    fun->setJitInfo(jitInfo);
  }

  return fun;
}

static NativeObject* CreateBlankProto(JSContext* cx, const JSClass* clasp,
                                      HandleObject proto,
                                      ObjectFlags objFlags) {
  MOZ_ASSERT(!clasp->isJSFunction());

  if (clasp == &PlainObject::class_) {
    // NOTE: There should be no reason currently to support this. It could
    // however be added later if needed.
    MOZ_ASSERT(objFlags.isEmpty());
    return NewPlainObjectWithProto(cx, proto, TenuredObject);
  }

  return NewTenuredObjectWithGivenProto(cx, clasp, proto, objFlags);
}

/* static */
NativeObject* GlobalObject::createBlankPrototype(JSContext* cx,
                                                 Handle<GlobalObject*> global,
                                                 const JSClass* clasp,
                                                 ObjectFlags objFlags) {
  RootedObject objectProto(cx, &global->getObjectPrototype());
  return CreateBlankProto(cx, clasp, objectProto, objFlags);
}

/* static */
NativeObject* GlobalObject::createBlankPrototypeInheriting(JSContext* cx,
                                                           const JSClass* clasp,
                                                           HandleObject proto) {
  return CreateBlankProto(cx, clasp, proto, ObjectFlags());
}

bool js::LinkConstructorAndPrototype(JSContext* cx, JSObject* ctor_,
                                     JSObject* proto_, unsigned prototypeAttrs,
                                     unsigned constructorAttrs) {
  RootedObject ctor(cx, ctor_), proto(cx, proto_);

  RootedValue protoVal(cx, ObjectValue(*proto));
  RootedValue ctorVal(cx, ObjectValue(*ctor));

  return DefineDataProperty(cx, ctor, cx->names().prototype, protoVal,
                            prototypeAttrs) &&
         DefineDataProperty(cx, proto, cx->names().constructor, ctorVal,
                            constructorAttrs);
}

bool js::DefinePropertiesAndFunctions(JSContext* cx, HandleObject obj,
                                      const JSPropertySpec* ps,
                                      const JSFunctionSpec* fs) {
  if (ps && !JS_DefineProperties(cx, obj, ps)) {
    return false;
  }
  if (fs && !JS_DefineFunctions(cx, obj, fs)) {
    return false;
  }
  return true;
}

bool js::DefineToStringTag(JSContext* cx, HandleObject obj, JSAtom* tag) {
  RootedId toStringTagId(
      cx, PropertyKey::Symbol(cx->wellKnownSymbols().toStringTag));
  RootedValue tagString(cx, StringValue(tag));
  return DefineDataProperty(cx, obj, toStringTagId, tagString, JSPROP_READONLY);
}

/* static */
JSObject* GlobalObject::getOrCreateRealmKeyObject(
    JSContext* cx, Handle<GlobalObject*> global) {
  cx->check(global);
  if (PlainObject* key = global->data().realmKeyObject) {
    return key;
  }

  PlainObject* key = NewPlainObject(cx);
  if (!key) {
    return nullptr;
  }

  global->data().realmKeyObject.init(key);
  return key;
}

/* static */
RegExpStatics* GlobalObject::getRegExpStatics(JSContext* cx,
                                              Handle<GlobalObject*> global) {
  MOZ_ASSERT(cx);

  if (!global->regExpRealm().regExpStatics) {
    auto statics = RegExpStatics::create(cx);
    if (!statics) {
      return nullptr;
    }
    global->regExpRealm().regExpStatics = std::move(statics);
  }

  return global->regExpRealm().regExpStatics.get();
}

/* static */
bool GlobalObject::createIntrinsicsHolder(JSContext* cx,
                                          Handle<GlobalObject*> global) {
  NativeObject* intrinsicsHolder =
      NewPlainObjectWithProto(cx, nullptr, TenuredObject);
  if (!intrinsicsHolder) {
    return false;
  }

  // Install the intrinsics holder on the global.
  global->data().intrinsicsHolder.init(intrinsicsHolder);
  return true;
}

/* static */
bool GlobalObject::getSelfHostedFunction(JSContext* cx,
                                         Handle<GlobalObject*> global,
                                         Handle<PropertyName*> selfHostedName,
                                         Handle<JSAtom*> name, unsigned nargs,
                                         MutableHandleValue funVal) {
  if (global->maybeGetIntrinsicValue(selfHostedName, funVal.address(), cx)) {
    JSFunction* fun = &funVal.toObject().as<JSFunction>();
    if (fun->fullExplicitName() == name) {
      return true;
    }

    if (fun->fullExplicitName() == selfHostedName) {
      // This function was initially cloned because it was called by
      // other self-hosted code, so the clone kept its self-hosted name,
      // instead of getting the name it's intended to have in content
      // compartments. This can happen when a lazy builtin is initialized
      // after self-hosted code for another builtin used the same
      // function. In that case, we need to change the function's name,
      // which is ok because it can't have been exposed to content
      // before.
      fun->setAtom(name);
      return true;
    }

    // The function might be installed multiple times on the same or
    // different builtins, under different property names, so its name
    // might be neither "selfHostedName" nor "name". In that case, its
    // canonical name must've been set using the `_SetCanonicalName`
    // intrinsic.
    cx->runtime()->assertSelfHostedFunctionHasCanonicalName(selfHostedName);
    return true;
  }

  // Don't collect metadata for self-hosted functions or intrinsics.
  // This is similar to the suppression in GlobalObject::resolveConstructor.
  AutoSuppressAllocationMetadataBuilder suppressMetadata(cx);

  JSRuntime* runtime = cx->runtime();
  frontend::ScriptIndex index =
      runtime->getSelfHostedScriptIndexRange(selfHostedName)->start;
  JSFunction* fun =
      runtime->selfHostStencil().instantiateSelfHostedLazyFunction(
          cx, runtime->selfHostStencilInput().atomCache, index, name);
  if (!fun) {
    return false;
  }
  MOZ_ASSERT(fun->nargs() == nargs);
  funVal.setObject(*fun);

  return GlobalObject::addIntrinsicValue(cx, global, selfHostedName, funVal);
}

/* static */
bool GlobalObject::getIntrinsicValueSlow(JSContext* cx,
                                         Handle<GlobalObject*> global,
                                         Handle<PropertyName*> name,
                                         MutableHandleValue value) {
  // Don't collect metadata for self-hosted functions or intrinsics.
  // This is similar to the suppression in GlobalObject::resolveConstructor.
  AutoSuppressAllocationMetadataBuilder suppressMetadata(cx);

  // If this is a C++ intrinsic, simply define the function on the intrinsics
  // holder.
  if (const JSFunctionSpec* spec = js::FindIntrinsicSpec(name)) {
    RootedId id(cx, NameToId(name));
    RootedFunction fun(cx, JS::NewFunctionFromSpec(cx, spec, id));
    if (!fun) {
      return false;
    }
    fun->setIsIntrinsic();

    value.setObject(*fun);
    return GlobalObject::addIntrinsicValue(cx, global, name, value);
  }

  if (!cx->runtime()->getSelfHostedValue(cx, name, value)) {
    return false;
  }

  // It's possible in certain edge cases that cloning the value ended up
  // defining the intrinsic. For instance, cloning can call NewArray, which
  // resolves Array.prototype, which defines some self-hosted functions. If this
  // happens we use the value already defined on the intrinsics holder.
  if (global->maybeGetIntrinsicValue(name, value.address(), cx)) {
    return true;
  }

  return GlobalObject::addIntrinsicValue(cx, global, name, value);
}

/* static */
bool GlobalObject::addIntrinsicValue(JSContext* cx,
                                     Handle<GlobalObject*> global,
                                     Handle<PropertyName*> name,
                                     HandleValue value) {
  Rooted<NativeObject*> holder(cx, &global->getIntrinsicsHolder());

  RootedId id(cx, NameToId(name));
  MOZ_ASSERT(!holder->containsPure(id));

  constexpr PropertyFlags propFlags = {PropertyFlag::Configurable,
                                       PropertyFlag::Writable};
  uint32_t slot;
  if (!NativeObject::addProperty(cx, holder, id, propFlags, &slot)) {
    return false;
  }
  holder->initSlot(slot, value);
  return true;
}

/* static */
JSObject* GlobalObject::createIteratorPrototype(JSContext* cx,
                                                Handle<GlobalObject*> global) {
  if (!ensureConstructor(cx, global, JSProto_Iterator)) {
    return nullptr;
  }
  JSObject* proto = &global->getPrototype(JSProto_Iterator);
  return proto;
}

/* static */
JSObject* GlobalObject::createAsyncIteratorPrototype(
    JSContext* cx, Handle<GlobalObject*> global) {
  if (!IsAsyncIteratorHelpersEnabled()) {
    return getOrCreateBuiltinProto(cx, global, ProtoKind::AsyncIteratorProto,
                                   initAsyncIteratorProto);
  }

  if (!ensureConstructor(cx, global, JSProto_AsyncIterator)) {
    return nullptr;
  }
  JSObject* proto = &global->getPrototype(JSProto_AsyncIterator);
  global->initBuiltinProto(ProtoKind::AsyncIteratorProto, proto);
  return proto;
}

void GlobalObject::releaseData(JS::GCContext* gcx) {
  GlobalObjectData* data = maybeData();
  setReservedSlot(GLOBAL_DATA_SLOT, PrivateValue(nullptr));
  gcx->delete_(this, data, MemoryUse::GlobalObjectData);
}

GlobalObjectData::GlobalObjectData(Zone* zone) {}

GlobalObjectData::~GlobalObjectData() = default;

void GlobalObjectData::trace(JSTracer* trc, GlobalObject* global) {
  for (auto& ctorWithProto : builtinConstructors) {
    TraceEdge(trc, &ctorWithProto.constructor, "global-builtin-ctor");
    TraceEdge(trc, &ctorWithProto.prototype, "global-builtin-ctor-proto");
  }

  for (auto& proto : builtinProtos) {
    TraceEdge(trc, &proto, "global-builtin-proto");
  }

  TraceEdge(trc, &emptyGlobalScope, "global-empty-scope");

  TraceEdge(trc, &lexicalEnvironment, "global-lexical-env");
  TraceEdge(trc, &windowProxy, "global-window-proxy");
  TraceEdge(trc, &intrinsicsHolder, "global-intrinsics-holder");
  TraceEdge(trc, &computedIntrinsicsHolder,
            "global-computed-intrinsics-holder");
  TraceEdge(trc, &sourceURLsHolder, "global-source-urls");
  TraceEdge(trc, &realmKeyObject, "global-realm-key");
  TraceEdge(trc, &throwTypeError, "global-throw-type-error");
  TraceEdge(trc, &eval, "global-eval");
  TraceEdge(trc, &emptyIterator, "global-empty-iterator");

  TraceEdge(trc, &arrayShapeWithDefaultProto, "global-array-shape");

  for (auto& shape : plainObjectShapesWithDefaultProto) {
    TraceEdge(trc, &shape, "global-plain-shape");
  }

  TraceEdge(trc, &functionShapeWithDefaultProto, "global-function-shape");
  TraceEdge(trc, &extendedFunctionShapeWithDefaultProto,
            "global-ext-function-shape");

  TraceEdge(trc, &boundFunctionShapeWithDefaultProto,
            "global-bound-function-shape");
  TraceEdge(trc, ®ExpShapeWithDefaultProto, "global-regexp-shape");

  regExpRealm.trace(trc);

#ifdef JS_HAS_INTL_API
  globalIntlData.trace(trc);
#endif

  TraceEdge(trc, &mappedArgumentsTemplate, "mapped-arguments-template");
  TraceEdge(trc, &unmappedArgumentsTemplate, "unmapped-arguments-template");

  TraceEdge(trc, &mapObjectTemplate, "map-object-template");
  TraceEdge(trc, &setObjectTemplate, "set-object-template");

  TraceEdge(trc, &iterResultTemplate, "iter-result-template_");

  TraceEdge(trc, &selfHostingScriptSource, "self-hosting-script-source");
}

void GlobalObjectData::addSizeOfIncludingThis(
    mozilla::MallocSizeOf mallocSizeOf, JS::ClassInfo* info) const {
  info->objectsMallocHeapGlobalData += mallocSizeOf(this);

  if (regExpRealm.regExpStatics) {
    info->objectsMallocHeapGlobalData +=
        regExpRealm.regExpStatics->sizeOfIncludingThis(mallocSizeOf);
  }
}