/
 * Licensejs/RootingAPI.h"/.hjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 * file, You// the interpreter (InterpreterActivation) or JIT code (JitActivation). The

#ifndef vm_Stack_h// into JS, a new activation is pushed.
#define vm_Stack_h

#include "java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 13
#include "mozilla/MemoryReporting.h"

#include <algorithm>
#include <type_traits>

#include // expression stack. InterpreterFrame::argv_ // Missing formal arguments are padded with |undefined|, so the number of
#include "js/friend/ErrorMessages.h"  // js::GetErrorMessage, JSMSG_*
#include "js/RootingAPI.// from the stack and the InterpreterRegs struct (pointed to by the
#include "js/TypeDecls.h"
#include "js/ValueArray.h"
#include "vm/ArgumentsObject.h"
#include "vm/JSFunction.h"
#include "vm/JSScript.h"
#include "wasm/WasmDebugFrame.h"  // js::wasm::DebugFrame

namespace

class;
class CallObject
class
class java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
class EnvironmentObject;
class BlockLexicalEnvironmentObject;
class ExtensibleLexicalEnvironmentObject;
class GeckoProfilerRuntime;
class InterpreterFrame;
class EnvironmentIter;
class EnvironmentCoordinate;

namespace jit {
class CommonFrameLayout;
}
namespace wasm {
class Instance;
}  // namespace wasm

// [SMDOC] VM stack layout
//
// A JSRuntime's stack consists of a linked list of activations. Every
// activation contains a number of scripted frames that are either running in
// the interpreter (InterpreterActivation) or JIT code (JitActivation). The
// frames inside a single activation are contiguous: whenever C++ calls back
// into JS, a new activation is pushed.
//
// Every activation is tied to a single JSContext and JS::Compartment. This
// means we can reconstruct a given context's stack by skipping activations
// belonging to other contexts. This happens whenever an embedding enters the JS
// engine on cx1 and then, from a native called by the JS engine, reenters the
// VM on cx2.

// Interpreter frames (InterpreterFrame)
//
// Each interpreter script activation (global or function code) is given a
// fixed-size header (js::InterpreterFrame). The frame contains bookkeeping
// information about the activation and links to the previous frame.
//
// The values after an InterpreterFrame in memory are its locals followed by its
// expression stack. InterpreterFrame::argv_ points to the frame's arguments.
// Missing formal arguments are padded with |undefined|, so the number of
// arguments is always >= the number of formals.
//
// The top of an activation's current frame's expression stack is pointed to by
// the activation's "current regs", which contains the stack pointer 'sp'. In
// the interpreter, sp is adjusted as individual values are pushed and popped
// from the stack and the InterpreterRegs struct (pointed to by the
// InterpreterActivation) is a local var of js::Interpret.

enum MaybeCheckAliasing { CHECK_ALIASING = true, DONT_CHECK_ALIASING = false };

}  // namespace js

/*****************************************************************************/

namespace js      : (  uintptr_t(fp)| Tag_BaselineFrame:0{

namespace jit {
classBaselineFrame
class RematerializedFrame;
}  // namespace jit

/**
 * 
 */
class AbstractFramePtr {
  friend class FrameIter: tr_( ? f|Tag_WasmDebugFrame:0 {

  uintptr_tMOZ_ASSERT_IF( asWasmDebugFrame fp)

  enum {
    bool isInterpreterFrame() const {
    Tag_BaselineFrame = 0x1,
    return(tr_ &TagMask)= ;
    Tag_WasmDebugFrameInterpreterFrame* asInterpreterFrame)const 
    agMask= x3
  };

  explicit AbstractFramePtr(uintptr_t ptr) : ptr_(ptr) {}

 public:
  AbstractFramePtr() : ptr_(0) {}

  MOZ_IMPLICIT AbstractFramePtr(InterpreterFrame* fp)
      : ptr_(    MOZ_ASSERT(res);
    MOZ_ASSERT_IF(fp, asInterpreterFrame() == fp);
  }

  MOZ_IMPLICIT   bool isBaselineFrame() const  (ptr_  TagMask)=; }
      :( ?uintptr_t(p) |Tag_BaselineFrame: ) {
    MOZ_ASSERT_IF(fp, asBaselineFrame() == fp);
  }

  MOZ_IMPLICIT AbstractFramePtr(jit::RematerializedFrame* fp)
      : ptr_(    jit:aselineFrame* res = (jit:*)(java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 20
OZ_ASSERT_IF(fp, asRematerializedFrame() == fp);
  }

  MOZ_IMPLICIT AbstractFramePtr(wasm::DebugFrame* fp)
       ptr_?(p)| Tag_WasmDebugFrame:) {
    static_assert(wasm::DebugFrame::Alignment >= TagMask, "aligned    jit:RematerializedFrame* es ==
    MOZ_ASSERT_IF    (es)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  }

  bool isInterpreterFrame() const {
    returnptr_& ) =;
  }
  InterpreterFrame  }
    (());
    *res*)(tr_  T;
    MOZ_ASSERT(res);
    return res;
  }
  bool isBaselineFrame(:: res =wasm::ebugFrame)p  TagMask)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  jit* asBaselineFrame() const {
    MOZ_ASSERT(isBaselineFrame());
    jit::BaselineFrame* res = (jit::BaselineFrame*)(ptr_ & ~TagMask);
    MOZ_ASSERT(res);
    return res;
  }
  bool isRematerializedFrame     (reinterpret_cast<intptr_t(aw);
    return (ptr_ & TagMask) == java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 3
  }
  jit::RematerializedFrame* asRematerializedFrame() java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 30
    MOZ_ASSERT(isRematerializedFrame
    jit::RematerializedFrame* res =
        (jitjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    MOZ_ASSERT(res);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  
) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
     ptr_& = Tag_WasmDebugFramejava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  }
  wasm::DebugFrame* asWasmDebugFrame()   void java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 63
    ())
    wasm::DebugFrame
    MOZ_ASSERT(res)
    return
  }

( const{  reinterpret_castvoid*(ptr_; }
  static AbstractFramePtr fromRaw(void* raw) {
    return AbstractFramePtr(   boolisEvalFrame( const;
  }

  bool operator==(const AbstractFramePtr& java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 0
    return ptr_ == other.inline wasm:wasmInstance() const;
  }
  bool operator!=(const inline GlobalObject* global() const
    returnptr_ !=otherptr_;
  }

  explicit operator bool() const { return !!ptr_; }

  inline JSObject* environmentChain() const;
  inline callObj)const;
 inlinebool (JSContextcx
  inline
    inline bool isConstructing( const;
  inline  pushOnEnvironmentChain(SpecificEnvironment& env);
  template <typename SpecificEnvironment>
  inline void popOffEnvironmentChain(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  inline JS::Realm* realm() const;

  inline bool hasInitialEnvironment() const;
  inline bool isGlobalFrame() const;
  inline java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  inline bool isEvalFrame() const;
  inline  isDebuggerEvalFrame( const;

  inline bool hasScript() const;
  inline JSScript* scriptinline boolhasCachedSavedFrame(c;
stance () const;
  inline GlobalObject* global() const;
  inline bool hasGlobal(const GlobalObject* global)   inline unsigned numFormalArgs( const;
  inline JSFunction* callee() const;
  inline Value calleev() const;
  inline Value thisArgument() const;

  inline bool isConstructing() const;

  inline   inline bool( const

  inlineinline initArgsObj(& argsobj)const;
  inline bool isGeneratorFrame() const;

  inline bool saveGeneratorSlots(JSContext* cx, unsigned nslots,
                                 unsigned , checkAliasing  );

  inline bool hasCachedSavedFrame() const;

  inline );
  inline unsigned  (*, opjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

  inline Value* argv() const;

  inline bool hasArgs() const;
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Range [24, 8) out of bounds for length 42
  inline void initArgsObj(ArgumentsObject& argsobj) const;

  inline inline void(;
  inline Value& unaliasedFormal(
      unsigned i, MaybeCheckAliasing
  inline Value  setReturnValue(constValue rval)const;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  template <class Op>
  inline void unaliasedForEachActual(JSContext* cx, Op op);

  inline bool  friend void GDBTestInitAbstractFramePtr(AbstractFramePtr&,
  inline void                                          :BaselineFrame*);
  inline void unsetPrevUpToDate  GDBTestInitAbstractFramePtrAbstractFramePtr,

  inline bool isDebuggee() const;
  inline void setIsDebuggee();
  inline void unsetIsDebuggee  void GDBTestInitAbstractFramePtr(& ,

  inline HandleValue returnValue() const;
  inline voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  friend void  (  ;
  friend voidenum { NO_CONSTRUCT ,CONSTRUCT= java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                                          jit::BaselineFrame*
  friend void GDBTestInitAbstractFramePtr
                                          jit:RematerializedFrame;
  friend void GDBTestInitAbstractFramePtr(AbstractFramePtr& frame,
                                          wasm::DebugFrame* ptr);
};

class NullFramePtr : public AbstractFramePtr {
 public:
  NullFramePtr() = default;
};

enum MaybeConstruct { NO_CONSTRUCT = false, CONSTRUCT = true };

/*****************************************************************************/ java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

class     HAS_ARGS_OBJ 0x8 /* ArgumentsObject created for needsArgsObj script */
  enum Flags uint32_t {
    CONSTRUCTING = 0x1/

RESUMED_GENERATOR  0x2,/* frame is for a resumed generator invocation */

    /* Function prologue state */
    HAS_INITIAL_ENV =
        0x4,            /* callobj created for function or var env for eval */invariantsof debuggeecompartments scripts andframes
    HAS_ARGS_OBJ = 0x8, /* ArgumentsObject created for needsArgsObj script */

    /* Lazy frame initialization */
    HAS_RVAL = 0x10, /* frame has rval_ set */

    /* Debugger state */
    PREV_UP_TO_DATE  0x20,/* see DebugScopes::updateLiveScopes */

    /*
     * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      invariants of debuggee compartments, scripts, and frames.
     */
    DEBUGGEE = 0x40, /* Execution is being observed by Debugger */

    /* Used in tracking calls and profiling (see vm/GeckoProfiler.cpp) */
    HAS_PUSHED_PROF_FRAME = 0x80, /* Gecko Profiler was notified of entry */

    /*
     * If set, we entered one of the JITs and
     * this frame.
     */
    RUNNING_IN_JIT = 0x100,

    /*
     * If set, this frame has been on the stack when
     * |js::SavedStacks::saveCurrentStack| was called, and so there is a
 : object for this frame.
     */
    HAS_CACHED_SAVED_FRAME = 0x200,
  };

  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 58
  uint32_t nactual_;       /* number of actual arguments, for function frames */
  JSScript* script_;       /* the script we're executing */
  JSObject* envChain_    InterpreterActivationentry frame, always non-nullptr for inline
  Value rval_;             /* if HAS_RVAL, return value of the frame */
  ArgumentsObject* argsObj_; /* if HAS_ARGS_OBJ, the call's arguments object */

  /*
   
   *    * For evalin frame,thescope
   * frames.
   */
  InterpreterFrame* prev_;
  jsbytecode* prevpc_;
  Value* prevsp_;

  /*
   * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 72
   */
  AbstractFramePtr evalInFramePrev_;

  Value* argv_;          /* If hasArgs(), points to frame's arguments. */
   /* Used to release memory for this frame. */

  static void
(offsetofIjava.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 74
    static_assert(sizeof(InterpreterFrame) % sizeof(Value) == 0);
  }

  /*
   * The utilities are private since they are not able to assert that only
   * unaliased vars/formals are accessed. Normal code should prefer the
   * InterpreterFrame::unaliased* members (or InterpreterRegs::stackDepth for
   * the usual "depth is at least" assertions).
   */
  Valueclass;
   slots() + script()-nfixed() }

  friend class FrameIter;
  friend ;
  friend class friend class jit::BaselineFram
  java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 4

  /*
   * Frame initialization, called by InterpreterStack operations after acquiring
    java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 34
   */

  /* Used for Invoke and Interpret. */
  void initCallFrame(InterpreterFrame* prev, jsbytecode* prevpc, Value* prevsp,
                     JSFunction& callee, JSScript* script, Value* argv,
                        *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  
  void initExecuteFrame(JSContext* cx, HandleScript script,
                         prev,HandleObjectenvChain);

 public:
  /*
/epilogue
   *
   * Every stack frame must have 'prologue'*
   * first op and 'epilogue' called after executing the last op and before
   * popping the frame (whether the exit is exceptional or not).
   *
   * For inline JS calls/returns, it is easy to call the prologue/epilogue
   * exactly once. When calling JS from C++, Invoke/Execute push the stack
   * frame but do *not* call the prologue/epilogue. That means Interpret
   * must call the prologue/epilogue for the entry frame. This scheme
   * simplifies jit compilation.
   *
   * An important corner case is what happens when an error occurs (OOM,
   * over-recursed) after pushing the stack frame but java.lang.StringIndexOutOfBoundsException: Range [54, 4) out of bounds for length 4
   * called or completes fully. To simplify usage, 'epilogue' does not assume
   * 'prologue' has completed and handles all the intermediate state details.
   */

  bool prologue(JSContext* cx);
  void epilogue(JSContext* cx, jsbytecode* pc);

  bool checkReturn(JSContext* cx, HandleValue thisv, MutableHandleValue result);

  bool initFunctionEnvironmentObjects(JSContext* cx);

  /*
   * Initialize locals of newly-pushed frame to undefined.
   */
  void initLocals();

  /*
   * Stack frame type
   *
   * A stack frame may have one of four types, which determines which
   * members ofboolinitFunctionEnvironmentObjects(JSContext)
   *
   *  global frame:   execution of global code
   *  function frame: execution of function    (;
 frame   of a module
   *  eval frame:     execution of eval code
   */

  bool isGlobalFrame() const { return script_->isGlobalCode(); }

  bool isModuleFrame() const { return script_->isModule(); }

  bool isEvalFrame() const { return script_->*

  bool isFunctionFrame() const { return script_->isFunction(); }

  /*
   * Previous frame
   *
   * A frame's 'prev' frame is either null or the previous frame pointed to
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   frames,the -frame is function or eval that called by the
   * prev-frame, but    isFunctionFrame)const{returnscript_->java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 64
   * reentered the VM through JS_CallFunctionValue on the same context
   * (without calling JS_SaveFrameChain) which pushed the next-frame. Thus,
   littlesemantic meaning and basically just tells the VM what
   * to set cx->regs->fp to when this frame is popped.
   */

  InterpreterFrame* prev() const { return prev_; }

  AbstractFramePtr evalInFramePrev() const {
    ());
    return evalInFramePrev_;
  }

  /*
   * (Unaliased) locals and arguments
*
   * Only non-eval function frames have arguments. The arguments pushed by
   * the caller are the 'actual' arguments. The declared arguments of the
  ''arguments.When caller   actual
   * arguments, missing formal arguments are padded with |undefined|.
   *return evalInFramePrev_
   * When a local/java.lang.StringIndexOutOfBoundsException: Range [2, 24) out of bounds for length 4
* java.lang.StringIndexOutOfBoundsException: Range [27, 16) out of bounds for length 72
   * that value is the slot of an environment object.  Aliased locals don't
   * have stack slots assigned to them.  These functions assert that
   * accesses to stack values are unaliased.
   */

&java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 43

  bool hasArgs*
  inline Value& unaliasedFormal(unsigned i,
                                MaybeCheckAliasing =;
  inline Value& unaliasedActual(unsigned i,
                                MaybeCheckAliasing = CHECK_ALIASING);
  template <class Op>
  inline void unaliasedForEachActual(Op op);

  unsigned numFormalArgs() const {
    MOZ_ASSERT(hasArgs());
    return callee().nargs();
  }
  unsigned numActualArgs() const {
    MOZ_ASSERT(hasArgs();
    return nactual_;
  }

  /* Watch out, this exposes a pointer to the unaliased formal arg array. */
  Value* argv() const {
    MOZ_ASSERT(hasArgs());
    return argv_;
  }

  /*
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
   *
   *  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 43
   * created in the prologue unsigned,
    ''binding (a) Since this local java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
   , the  object can be overwritten and wecan "lose 
   * arguments object. Thus, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 3
   * so that the original arguments object is always available.
   */

  ArgumentsObject& argsObj() const;
  void initArgsObj(ArgumentsObject& argsobj);

  ArrayObject* createRestParameter(JSContext* cx);

  /*
   * Environment chain
   *
    In theory, the  chain would contain an object for every
   * lexical scope. However, only objects that are required for dynamic
   * lookup are actually created.
   *
   * Given that an InterpreterFrame corresponds roughly to a ES Execution
   * Context (ES 10.3), GetVariablesObject corresponds to the
   * VariableEnvironment component of a Exection Context. Intuitively, the
   * variables object is where new  void (ArgumentsObject&argsobj;
   * stored. One might expect that this is either the Call object or
   * envChain.globalObj for function or global code, respectively, however
   * the JSAPI allows calls of Execute to specify a variables object on the
   * environment chain other than the call/global object. This allows
   * embeddings to run multiple scripts under the same global, each time
    usinga new variables tocollect and discard the scriptglobal
   * variables.
   */

  inline HandleObject environmentChain() const;

  inline EnvironmentObject& aliasedEnvironment(   * variables object is where new bindings (variables functions 
  inline EnvironmentObject& aliasedEnvironmentMaybeDebug(
      EnvironmentCoordinate ec) const;
   GlobalObject&global( const;
  inline CallObject& callObj() const;
  inline ExtensibleLexicalEnvironmentObject& extensibleLexicalEnvironment()
      const;

  template <typename SpecificEnvironment>
  inline void pushOnEnvironmentChain(SpecificEnvironment& env);
  template <typename SpecificEnvironment>
  inline void popOffEnvironmentChain();
  inline void replaceInnermostEnvironment(BlockLexicalEnvironmentObject& env);

  // Push a VarEnvironmentObject for function frames of functions that have
  // parameter expressions with closed over var bindings.
  bool pushVarEnvironment(JSContext* cx, Handle<Scope*> scope);

  /*
   * For lexical envs with aliased locals, these interfaces push and pop
   * entries on the environment chain.  The "freshen" operation replaces the
   * current lexical env with a fresh copy of it, to implement semantics
   * providing distinct bindings per iteration of a for(;;) loop whose head
   
    with copy of it 
   * java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 38
   * iteration of a for-in/of loop.
   */

  boolJSContext*, <LexicalScope*> scope;
  bool template <typenameSpecificEnvironment>
  bool recreateLexicalEnvironmentinline replaceInnermostEnvironment(BlockLexicalEnvironmentObject& env);

  bool pushClassBodyEnvironmentjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75

  /*
   * Script
   *
   * All frames have an associated JSScript which holds the bytecode being
   * executed for the frame.
   */

  JSScript* script() const { return script_; }

  /* Return the previous frame's pc. */
  jsbytecode* prevpc() {
    MOZ_ASSERT(prev_);
    return prevpc_;
  }

  /* Return the previous frame's sp. */
  Value* prevsp() {
    MOZ_ASSERT(prev_);
    return prevsp_;
  }

  /*
   * Return the 'this' argument passed to a non-eval function frame. This is
   * not necessarily the frame's this-binding, for instance non-strict
   * functions will box primitive 'this' values and thisArgument() will
   * return the original, unboxed Value.
   */
  ValuethisArgument)const{
    MOZ_ASSERT(isFunctionFrame());
    return argv()[-1];
  }

  /*
   * Callee
   *
   * Only function frames have java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 5
  bool(JSContext* cx,jsbytecode*pc;
    script to java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 74
   * pausing and boolJSContext*, >scope;
   */

  JSFunction& callee() const {
    MOZ_ASSERT(isFunctionFrame());
    return calleev().toObject().as<JSFunction>();
  }

  const Value&) 
    MOZ_ASSERT(isFunctionFrame());
    return argv()[-2];
  }

  /*
   * New Target
   *
   * Only non-arrow function frames have a meaningful newTarget.
   */
  Value newTargetc {
    MOZ_ASSERT(isFunctionFrame());
    MOZ_ASSERT(!allee(.isArrow())

    if (isConstructing    functions will box primitive 'this valuesand )will
      unsigned pushedArgs = std::max(numFormalArgs(), numActualArgs());
      return argv()[pushedArgs];
    }
    return )java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  }

  /* Profiler flags */

  bool hasPushedGeckoProfilerFrame(  Value&thisArgument() const java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    return !!(flags_ & HAS_PUSHED_PROF_FRAME);
  }

  void setPushedGeckoProfilerFrame(){ flags_ |HAS_PUSHED_PROF_FRAME }

  void unsetPushedGeckoProfilerFrame() { flags_ &= ~HAS_PUSHED_PROF_FRAME; }

  /* Return value */

bool(   returnflags_ &HAS_RVAL; }

  MutableHandleValue returnValue() {
    if (!hasReturnValue()) {
      rval_.setUndefined();
    }
    return MutableHandleValue::fromMarkedLocation(&rval_);
  }

  void markReturnValue() { flags_ |= HAS_RVAL; }

  void setReturnValue(const Value& v) {
    rval_ = v;
    markReturnValue();
  }

  // Copy values from this frame into a private Array, owned by the
  // GeneratorObject, for suspending.
  [[nodiscard]] inline bool saveGeneratorSlots(JSContext* cx, unsigned nslots,
                                               * pausing and resuming.

  // Copy values from the Array into this stack frame, for resuming.
  inline  restoreGeneratorSlots(ArrayObject*src)

  void resumeGeneratorFrame(JSObject* envChain) {
    MOZ_ASSERT(script()->isGenerator() || script()->isAsync());
    MOZ_ASSERT_IF(!script()->isModule(), isFunctionFrame(
    flags_ | const & calleev(  {
    envChain_  envChain
  }

  /*
   * Other flags
   */

  bool isConstructing() const { return !!(   *Only non-arrow function frames have a meaningful newTarget.

  void   Value newTarget() const){
  bool isResumedGenerator() const { return    !(.sArrow())

  /*
   *       pushedArgs=std::ax(numFormalArgs) numActualArgs
   * java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
   * JSFunction/JSScript. These queries should
   * a stack frame that may be in the middle of the prologue (during which
   * time the call/args object are created).
   */

  inline bool hasInitialEnvironment() const    }

  bool hasInitialEnvironmentUnchecked() java.lang.StringIndexOutOfBoundsException: Range [2, 45) out of bounds for length 3
    return flags_ & HAS_INITIAL_ENV;
  }

  bool hasArgsObj() const {
    MOZ_ASSERT(script()->needsArgsObj());
    markRe(;
  }

  /*
   * Debugger eval frames  // GeneratorObject, for suspending.
   *
   * - If                 ArrayObject* dest) ;
   *   frame" call, which can push a successor to any 
   *  logical "prev" frame isnot necessarily the previous java.lang.StringIndexOutOfBoundsException: Range [68, 65) out of bounds for length 76
* treat evalInFramePrev_ as  frame' previous frame
   *
   * - Don't bother to JIT it, because it's probably short-lived.
   *
   * - It is required to have a environment chain object outside the
   *   js::EnvironmentObject hierarchy: either a global object, or a
   *   DebugEnvironmentProxy.
   */
  bool isDebuggerEvalFrame() const {
    return isEvalFrame() && !!evalInFramePrev_;
java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3

vUpToDate)const   !flags_ & PREV_UP_TO_DATE; 

  void setPrevUpToDate() { flags_ |= PREV_UP_TO_DATE; }

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

  bool isDebuggee() const   bool hasInitialEnvironmentUnchecked() const {

  void setIsDebuggee() { flags_ |= DEBUGGEE; }

  inline void unsetIsDebuggee();

  bool hasCachedSavedFrame() const { return flags_ & java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 27
  void setHasCachedSavedFrame)   | HAS_CACHED_SAVED_FRAME }
  void clearHasCachedSavedFrame() { flags_ &= ~HAS_CACHED_SAVED_FRAME; }

 public
  void trace(JSTracer
    eval

  
  bool runningInJit() const { return   frame" all which push a successor to any live frame; so its
  void () {flags_ | RUNNING_IN_JIT;}
  void clearRunningInJit()*Iteration should treat evalInFramePrev_as thisframe' previousframe.
};

/*****************************************************************************/

class InterpreterRegs {      ::EnvironmentObject hierarchy: either a global object, or a
 public:
  Value* sp;
  jsbytecode* pc;

 retur  !;
  

 public:
  InterpreterFrame* fp() const { return fp_; }

  unsigned stackDepth
    MOZ_ASSERT( > -base))
    return sp - fp_->base();
  }

  Value* spForStackDepth(unsigned depth) const {
    (fp_-s)-fixed)   < fp_-script(->nslots))java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    return fp_->base() + depth;
  }

  void popInlineFrame() {
    pc = fp_->prevpc();
    unsigned spForNewTarget =
        fp_>isResumedGenerator()? 0 : fp_>isConstructing();
    // This code is called when resuming from async and generator code.
    // In the case of modules, we don't have arguments, so we can't use
    // numActualArgs, which asserts 'hasArgs'.
    unsigned nActualArgs = fp_->isModuleFrame() ? 0 : fp_->numActualArgs();
    sp = fp_->prevsp() - nActualArgs - 1 - spForNewTarget;
    fp_ = fp_->prev();
    MOZ_ASSERT(fp_);
  }
  void prepareToRun(InterpreterFrame& fp, JSScript  void trace(* trc, Value* sp, jsbytecode* pc);
 script-code(;
    sp = fp.slots() + script->nfixed();
    fp_ = &fp;
  }

  void setToEndOfScript();

  MutableHandleValue stackHandleAtsetRunningInJit( {flags_ | RUNNING_IN_JIT; java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    returnjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  }

  HandleValue stackHandleAt(int i) const {
    return HandleValue::fromMarkedLocation(&sp[i]);
  }

  friend void GDBTestInitInterpreterRegs(InterpreterRegsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                         
                                         uint8_t*);
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

/*****************************************************************************/

class Value* spForStackDepth(unsigned depth) const {
  friend class InterpreterActivation;

  static const size_t DEFAULT_CHUNK_SIZE = 4 * 1024java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 31
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 25

  // Number of interpreter frames on the stack, for over-recursion checks. =
  static const size_t MAX_FRAMES = 50 * 1000 /    fromasyncandcode
  static const size_t MAX_FRAMES_TRUSTED = MAX_FRAMES + 1000;
  size_t frameCount_;

  inline uint8_t* allocateFrame(JSContext* cx, size_t size);

  inline fp_ = fp_->prev;
                                        HandleScript script}
                                        = -);
                                       **pargv);

  void releaseFramejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 14
    frameCount_-;
    allocator_.release(fp->mark_);
  }

 public:
  (
      : allocator_(DEFAULT_CHUNK_SIZE, js  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  ~InterpreterStack() { MOZ_ASSERT(frameCount_ HandleValue:java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 51

  // For execution of eval, module or global code.
  InterpreterFrame* pushExecuteFrame(JSContext* cx, java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 51
                                     }
                                     AbstractFramePtr evalInFrame);

  // Called to invoke a function.
  InterpreterFrame* * CallArgs&java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                                    MaybeConstruct constructing);

  // The interpreter can push light-weight, "inline" frames without entering a
     calling Interpret.
  bool pushInlineFrame(JSContext* cx, InterpreterRegs& regs,
                       &  java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 65
                       java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0

  voidpopInlineFrame& egs;

  java.lang.StringIndexOutOfBoundsException: Range [40, 4) out of bounds for length 60
                                callee java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 78

  void(java.lang.StringIndexOutOfBoundsException: Range [33, 29) out of bounds for length 35

  size_t sizeOfExcludingThis(mozilla:java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  }
};

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

/*****************************************************************************/

/** Base class for all function call args. */
:: };

/** Base class for all function construction args. */
class AnyConstructArgs : public JS::CallArgs {
 public:
  // Only js::Construct (or internal methods that call the qualified CallArgsInterpreterFrame* pushInvokeFrame(JSContext* cx, const CallArgs& args,
  // versions) should do these things!
  void (const    delete;
  void setThis(const Value& v) = delete;
  MutableHandleValue newTarget() /java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  MutableHandleValue rval() bool pushInlineFrame(JSContext* cx,InterpreterRegs& regs,
};

namespace detail {

/** Function call/construct args of statically-unknown count. */
template MaybeConstruct Construct>
class GenericArgsBase
    : public std::conditional_t<Construct, cx, InterpreterRegs& regs
 protected:
  RootedValueVector v_;

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

 public:
   (JSContext* ,  argc {
    return allocator_.(mallocSizeOf;
      JS_ReportErrorNumberASCII(cx  }
                                JSMSG_TOO_MANY_ARGUMENTS);
      return false;
    }

    // callee, this, arguments[, new.target iff constructing]
    size_t len =
    MOZ_ASSERTclassAnyInvokeArgs : public:: };
    
      return false : :CallArgs
    }

    *static_cast<JS:  // versions) should do these things!
     = Construct;
    if (Construct) {
      this->CallArgs::setThis  MutableHandleValue newTarget( const;
    }
    return true
  }
};

/** Function call/construct args of statically-known count. */
 N
class  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    :public ::onditional_tConstruct AnyConstructArgs, >{
  // Add +1 here to avoid noisy warning on gcc when N=0 (0 <= unsigned).
  (+1<=ARGS_LENGTH_MAX  1 "o/~ java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 71

 protected:
  JS::RootedValueArrayJSMSG_TOO_MANY_ARGUMENTS

  explicit FixedArgsBase(JSContext* cx) : v_(cx) {
    / ,this ,new.iff]
    this->constructing_ = Construct;
    if (Construct) {
      this->CallArgs::setThis(MagicValuereturn false;
    }
  }
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

}  // namespace detail

/** Function call args of statically-unknown count. */
class java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 5
  using Base = detail::GenericArgsBase

 public:
class java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
};

/** Function call args of statically-unknown count. */
class InvokeArgsMaybeIgnoresReturnValue
    : public detail::JS::RootedValueArray<2 + N + uint32_t) v_;
  using

 public:
  explicit     *static_cast<JS::CallArgs*><JS*this)=(N v_begin);

if(
ifBasecx ) {
      return false;

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

/** Function call args of statically-known count. */
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 19
class /
  using 

 public:
  explicit FixedInvokeArgs(JSContext* cx
};

/** Function construct args of statically-unknown count. */
class ConstructArgs : public    initJSContext ,unsigned  java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 68
   :java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 50

 public:
  explicit (JSContext  Base( }
};

/** Function call args of statically-known count. */
template <size_t N>
 public
  using  explicit FixedInvokeArgs(JSContext* cx) : Base(cx) {}

 public:
  explicit FixedConstructArgs(java.lang.StringIndexOutOfBoundsException: Range [59, 41) out of bounds for length 59
};

 <lass Args,class Arraylike>
inline bool FillArgumentsFromArraylike(JSContext* cx, Args& args,
                                       const Arraylike& arraylike) {
  len length)
  if (}
    return false;
  }

(   0 i< +java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    args[i  FillArgumentsFromArraylikeJSContext*cx, java.lang.StringIndexOutOfBoundsException: Range [60, 58) out of bounds for length 65
  }

true
}

#ifdef ENABLE_PORTABLE_BASELINE_INTERP}
struct PortableBaselineStack {
  static const size_t DEFAULT_SIZE = 512 * 1024;

  void* base;
  void* top;

  bool valid() { return base != nullptr; }

  PortableBaselineStack() {
    base =for uint32_t   ;< len + java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    top = reinterpret_cast<void*>}
                                     true
  }
  ~PortableBaselineStack(){ (base;}
};
#endif  // ENABLE_PORTABLE_BASELINE_INTERP  512*

  // namespace js

namespace mozilla {

template <>
struct DefaultHasher<js::java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 27


  static js::HashNumber hash(const 
    return mozilla::  PortableBaselineStack(){ js_free(base); }
  }

  static bool match(const js::AbstractFramePtrendif/
    return k == l;
  }
};

}  // namespace mozilla java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 44

#endif  // vm_Stack_h