Quelle  Stack.h   Sprache: C

/* 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_Stack_h
#define vm_Stack_h

#include "mozilla/HashFunctions.h"
#include "mozilla/MemoryReporting.h"

#include <algorithm>
#include <type_traits>

#include "js/ErrorReport.h"
#include "js/riend/ErrorMessages.h"  // js::GetErrorMessage, JSMSG_*
#include ""
#include"jsTypeDecls"
#include "js/ValueArray.h"
#include "vm/ArgumentsObject.h"
#include "vm/JSFunction.h"
#include "vm/JSScript.h"
#include "wasm/WasmDebugFrame.h"  // js::wasm::DebugFrame

namespace js {

class InterpreterRegs;
class CallObject;
class FrameIter;
class ClassBodyScope;
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 { java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 25

}  // namespace js

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

namespace js {

namespace
class BaselineFrame;
classclass InterpreterRegs
}  // namespace jit

/**
 * Pointer to a live JS or WASM stack frame.
 */
class AbstractFramePtr {
  friend // the interpreter (InterpreterActivation) or JIT code (JitActivation). The

  uintptr_t ptr_;// into JS, a new activation is pushed.

  enum {
    Tag_InterpreterFrame = 0// means we can reconstruct a given context's stack by skipping activations
    Tag_BaselineFrame = 0x1,
    Tag_RematerializedFrame = 0x2,
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    TagMask = 0x3
  };

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

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

  MOZ_IMPLICIT AbstractFramePtr(InterpreterFrame* fp)
// expression stack. InterpreterFrame::argv_ points// Missing formal arguments are padded with |undefined|, so the number of
    MOZ_ASSERT_IF(fp, // the activation's "current regs", which contains // the interpreter, sp is adjusted// from the stack and the InterpreterRegs struct (pointed to by the
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      : ptr_fp? (   :0) 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

   BaselineFrame;
       RematerializedFrame
    MOZ_ASSERT_IF
  }

  MOZ_IMPLICIT AbstractFramePtrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      :fp uintptr_t(fp | : 0) {
    static_assert(wasm
    fp,asWasmDebugFrame() == )
  }

  java.lang.StringIndexOutOfBoundsException: Range [25, 6) out of bounds for length 35
     (  ) =Tag_InterpreterFrame
  }
   ( const{
    MOZ_ASSERT(  0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 20
    return res}
  }
{ return (&  = Tag_BaselineFrame
  jit ptr_fp? f)   : 0 java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
::res jit:BaselineFrame(tr_ & ~TagMask);
    MOZ_ASSERT(res);
    return res;
  }
  bool isRematerializedFrame() const {
    return (ptr_ & TagMask) == Tag_RematerializedFrame;
  }
    Mjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
      :(fp  uintptr_tfp Tag_WasmDebugFrame  0 java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    jit:*es =
        (jit::RematerializedFrame*)(ptr_ & ~TagMask);
    MOZ_ASSERT(;
    return res;
  }
  bool java.lang.StringIndexOutOfBoundsException: Range [2, 23) out of bounds for length 3
    return (ptr_ & TagMaskreturn ( &TagMask) ==Tag_InterpreterFrame;
  }
  wasmMOZ_ASSERT(isInterpreterFrame
    InterpreterFrame  = (InterpreterFrame( & ~agMask)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    wasm:ebugFrame*res (:D*(tr_&~TagMask;
    MOZ_ASSERT(res);
    return res;
  }

  void* ::BaselineFramejava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 47
  static java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 20
    returnAbstractFramePtr<>raw)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  }

  bool operator==(const AbstractFramePtr& other) const {
    return ptr_ == other.ptr_;
  }
  bool operator!=(const AbstractFramePtr& other) const {
    java.lang.StringIndexOutOfBoundsException: Range [36, 10) out of bounds for length 30
  }

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

  inline JSObject* environmentChain() const;
  inline CallObject}
  inlinesWasmDebugFrame() onst {
  inline bool pushVarEnvironment(JSContext* cx, Handle<return (  TagMask)=Tag_WasmDebugFrame;
  template <typename java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 3
  inline pushOnEnvironmentChain(SpecificEnvironment& env);
  template <typename SpecificEnvironment>
  inline void MOZ_ASSERT(isWasmDebugFrame;

  res);

  inline bool}
  inline bool isGlobalFrame() const;
    void* raw()  return<>) java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
inline (;
  inline bool   

  inline bool hasScript() const;
  inline JSScript* script() const;
  wasm:Instance* wasmInstancejava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  ;
  inline bool hasGlobal(const GlobalObject    return !=.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  inline java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 0
  inline Value CallObject&( ;
    boolinitFunctionEnvironmentObjects* );

)

voidjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 63

  inline bool isFunctionFrame() const;
  inline bool java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  inline bool saveGeneratorSlots(JSContext* cx, unsigned nslots,
                                 ArrayObject*boolisDebuggerEvalFrame)const

   hasCachedSavedFrame) onst

  inline unsigned*wasmInstance)constjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  inline)

  inline Value* argv() const;

  inline bool hasArgs &java.lang.StringIndexOutOfBoundsException: Range [31, 28) out of bounds for length 37
 hasArgsObj(;
  inline ArgumentsObject& 
   voidArgumentsObject)

  java.lang.StringIndexOutOfBoundsException: Range [39, 8) out of bounds for length 39
  inline Value& unaliasedFormal(
      i MaybeCheckAliasingcheckAliasing=CHECK_ALIASING;
  inline Value& unaliasedActual(
      unsigned java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  template <class    unsigned numActualArgs()const
  inline voidunaliasedForEachActual(SContext cx Op);

  inline bool prevUpToDate() const;
  inline void java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  inline java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0

  inline bool inline ArgumentsObject& argsObj() const;
  inline void setIsDebuggee();
   unsetIsDebuggee)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

  inline HandleValue returnValue() const;
  inline void setReturnValue & ;

  friend void GDBTestInitAbstractFramePtrjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 21
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 60
jit:java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  friend void(&,
                                          jitjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  friend  AbstractFramePtrframe
                                          wasm
};

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

 MaybeConstruct  =false   true};

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

class InterpreterFrame {
  enum Flags : uint32_t {
    CONSTRUCTING = 0x1, /* frame is for a constructor invocation */

    RESUMED_GENERATOR =                                           :*)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

    /* Function prologue state */
    HAS_INITIAL_ENV =
        0x4,            /* callobj created for function or var env for eval */
 =,/

    /* Lazy frame initialization */
   :{

    /* Debugger state */
     =0 

    /*
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     *    ,, .
     */
    DEBUGGEE =

    =0 /* see DebugScopes::updateLiveScopes */
        

    /*
     * If set, we entered one of      * ofjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 64
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     */
    RUNNING_IN_JIT = 0x100,

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

  mutable uint32_t flags_; /* bits described by Flags */
  uint32_t nactual_;       /* number of actual arguments, for function frames */
  JSScript* script_;       /* the script we're executing */
  JSObject* envChain_;     /* current environment chain */
  Value rval_;             /* if HAS_RVAL, return value of the frame */
  ArgumentsObject* argsObj_; /* if HAS_ARGS_OBJ, the call's arguments object */

  /*
   * Previous frame and its pc and sp. Always nullptr for
*'s entryjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 71
   * frames.
   */
  InterpreterFrame* prev_;
  jsbytecode* prevpc_;
  Value* prevsp_/*

  /*
 aneval--frame DEBUGGER_EVAL , frame in whose scope
   *  java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 22
   */
  AbstractFramePtr evalInFramePrev_;

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

  static void staticAsserts()    we're evaluating code. Iteration treats this as our previous frame.
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    static_assert(LifoAlloc::Mark mark_;
  }

  /*
   * The     static_assert(nterpreterFrame, rval_) % sizeof(Value) == 0);
   * unaliased vars/formals are accessed. Normal code should prefer the
   * InterpreterFrame::unaliased* members (or InterpreterRegs::stackDepth for
   * the usual "depth is at least" assertions).
   */
  Value* slots() const { return (Value*)(this + 1); }
  Value* base() const { return slots() + script()->nfixed(); }

  friend  FrameIter
  friend class Value* base() const { return+ )>();}
  friend class class InterpreterRegs
  e;

  /*
   * Frame initialization, called by InterpreterStack operations after acquiring
   * the    *the raw memory for the frame:
   */

  /* Used for Invoke and Interpret. */
  void initCallFrame
                     JSFunction/* Used for eval, module or global frames. */
                     uint32_t nactual, MaybeConstruct constructing);

  /* Used for eval, module or global frames. */
  void initExecuteFrame(JSContextAbstractFramePtrprev,HandleObject );
                        AbstractFramePtr prev, HandleObject envChain);

public
  /*
   * Frame    * Frame prologue
   
   * Every stack frame must have 'prologue' called before executing the
   * first op and 'epilogue' called after executing the last op and before
   * java.lang.StringIndexOutOfBoundsException: Range [3, 1) out of bounds for length 4
   *
   * 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.
java.lang.StringIndexOutOfBoundsException: Range [54, 4) out of bounds for length 4
   * An important corner case is what happens when an error occurs (OOM,
   * over-recursed) after pushing the stack frame but before 'prologue' is
   * 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);

   (* cx)

  /*
   * Initialize locals of newly-pushed java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 4
   */
  void initLocals()java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

  /*
   * Stack frame type
   *
   * A    *  module:   execution ofjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   * members of the frame may be accessed and other invariants:
   *
   *  global frame:   execution of global code
   *  function frame: execution of function code
   *  module frame:   execution of a module
   *  eval frame:     execution of eval code
   */

  bool isGlobalFrame() *   nextframea function eval wascalledbythe

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

  bool isEvalFrame() const { return script_->isForEval(); }

  bool(    script_-isFunction(); }

  /*
   * Previous frame
   *
   * A frame's 'prev' frame is either null or the previous frame pointed to
   * by cx   *'prev'has little java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 76
   * frames, the next-frame is a function or eval that was called by the
   * prev-frame, but MOZ_ASSERT(isEvalFrame
   * java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 4
   * (without calling JS_SaveFrameChain) which pushed the    java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   * 'prev' has little semantic meaning and basically just tells the VM what
   *    * calleeare the formal arguments. the callerpassesless actual
   */

  InterpreterFrame* prev() const { return prev_; }

  AbstractFramePtr evalInFramePrev() const {
    MOZ_ASSERT(isEvalFrame());
   ;
  }

  /*
   * (Unaliased) locals and arguments
   *
   * Only non-eval function   environment operations, or 'arguments'), the canonical location for
   * the caller are the 'actual' arguments. The declared arguments of the
   *
   *   inline Value unaliasedLocal(uint32_t i);
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   * When a local/formal variable is aliased                                 MaybeCheckAliasing=CHECK_ALIASING)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
   * java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 3
   * that value is the slot of an environmenthasArgs)
   * have   }
   * accesses to stack   *Arguments object
   */

  inline Value& unaliasedLocal(uint32_t i);

  bool hasArgs() const { return isFunctionFrame(); }
  inline Value& unaliasedFormal(unsigned i,
                                MaybeCheckAliasing = CHECK_ALIASING);
  inline Value& unaliasedActual( ijava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
                                MaybeCheckAliasing = CHECK_ALIASING);
  template <class *'arguments'(script->rgumentsLocal. Since localis
  inline void unaliasedForEachActual(Op op);

  unsigned numFormalArgs() const {
    MOZ_ASSERT(hasArgs());
    return callee().nargs();
  }
  * mutablearguments   lose"the
    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_;
  }

  /*
   * Arguments object
   *
   * If a non-eval function has script->needsArgsObj, an arguments object is
   * created /java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   * 'arguments' binding (script->argumentsLocal* environmentchain java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 71
   * mutable, the arguments object can be overwritten and we can "lose" the
   * arguments object. Thus, InterpreterFrame keeps an explicit argsObj_ field
   * so that the original arguments object is always available.
   */

  ArgumentsObject& argsObj() const;
   initArgsObj argsobj)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

  ArrayObject* createRestParameter(JSContext* cx);

  /*
   * Environment chain
   *
   * In theory, the environment 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    *using newobject to and   's java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 and )are
   * inlineGlobalObject& global);
   * envChain.globalObj for function or global code, java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 12
   * the JSAPI allows calls of Execute to specifyjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * environment chain other than the call/global object. This allows
   * embeddings to run multiple scripts under the same global, each time
   * using a new variables object to collect and discard the script's global
   * variables.
   */

  inline HandleObject environmentChain() const;

  inline * current lexical enva  it containing uninitialized
  inline EnvironmentObject& aliasedEnvironmentMaybeDebug(
      EnvironmentCoordinate ec) const;
  inline GlobalObject& global() const;
  inline CallObject& callObj() const;
  inline ExtensibleLexicalEnvironmentObject& java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 35
      const;

  template <typename java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 5
  inline void pushOnEnvironmentChain pushLexicalEnvironment(JSContext*cx Handle );
   >
  inline void popOffEnvironmentChain()n(JSContext* cx, jsbytecode* pc);
  inline void java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 78

  // Push a VarEnvironmentObject for function frames of functions that have
  // parameter expressions with closed over var bindings.
  bool pushVarEnvironment

  /*
   * For lexical envs with aliased locals, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 4
   * entries on the environment chain.  The "freshen" operation java.lang.StringIndexOutOfBoundsException: Range [64, 72) out of bounds for length 5
   * current lexical env with a fresh copy of it, java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 3
   * providing distinct bindings per iteration of a for(;;) loop whose head
   * has a lexical declaration.  The "recreate" operation replaces the
   * current lexical env with a copy of it containing uninitialized
   * bindings  & thisArgument( const 
   * iteration of a for-in/of loop
   */

  bool pushLexicalEnvironment(JSContext* cx, Handle<LexicalScope*> scope);
 freshenLexicalEnvironment cx, jsbytecode pc)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  bool recreateLexicalEnvironment(JSContext* * create a wrapper callee to allow passing thegenerators for

  bool pushClassBodyEnvironment( cx,Handle<ClassBodyScope* scope)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78

  /*
   * Script
   *
   * All frames have*/
   * executed for the frame.
   */

  JSScript* script() const { returnconst&calleev( const{

  /* 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_;
  }

  /*
   () onst {
   *c(.)
*functionswillbox 'this'   thisArgument( 
   * return the original, unboxed     UndefinedValue(;
   */
 thisArgument){
    MOZ_ASSERT(isFunctionFrame());
    return argv()[-1];
  }

  /*  = ; 
   * Callee
   *
   * Only function frames have   hasReturnValue)const {    HAS_RVAL;java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   * the same callee java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   * create a wrapper java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
   *pausing and resuming.
   */

  JSFunction&voidrestoreGeneratorSlots( )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    MOZ_ASSERT(isFunctionFrame());
    return calleev().toObject().as<JSFunction>();
  }

Valuecalleev)const
    envChain_ =envChain;
    return argv()[-2];
  }

  /*
   * New Target
   *
    java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 64
   */
  Value newTarget() const {
    MOZ_ASSERT(isFunctionFrame());
    MOZ_ASSERT(callee).)

    if (isConstructing()) {
unsignedpushedArgs =max(,numActualArgs());
      return argv()[pushedArgs];
    }
    return UndefinedValue();
  }

  /* Profiler flags */

  bool hasPushedGeckoProfilerFrame() {
    return !!(flags_ & HAS_PUSHED_PROF_FRAME);
  }

  void setPushedGeckoProfilerFrame() { flags_ |= HAS_PUSHED_PROF_FRAME; }

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

  /* Return value */

  bool hasReturnValue() const { return flags_ & HAS_RVAL; }

  MutableHandleValue returnValue() {
    if (!hasReturnValue()) {
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
    return 
  }

  void markReturnValue() { flags_ |= HAS_RVAL; }

  void setReturnValue(const Value& v) {
    rval_ = v;
turnValue()java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  }

  
  
  [[nodiscard]] inline bool saveGeneratorSlots(JSContext* cx, unsigned nslots,
                               * const;

  // Copy values from the Array into this stack frame, for resuming.


  void resumeGeneratorFrame(JSObject* envChain) {
    MOZ_ASSERT(script()->isGenerator() || script()->isAsync());
    MOZ_ASSERT_IF(!script()-*   prev"frameis not frame in memory.
    flags_ |= HAS_INITIAL_ENV;
    envChain_ = envChain;
  }

  /*
   * Other flags
   */

  bool    *   Iteration should evalInFramePrev_thisframes frame.

  void setResumedGenerator() { flags_ |= RESUMED_GENERATOR; }
  bool isResumedGenerator() const { return !!(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 4

  /*
   * These two queries should not be used in general: the presence/absence of
   * the call/args object is determined by the static(ish) properties of the
   * JSFunction/JSScript. These queries should only be performed when probing
   * a stack
   * time () {return !( ) }
   */

  inline bool

java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 47
    return flags_ & java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
  }

  bool hasArgsObj() const {
    MOZ_ASSERT(script()->  (){flags_| HAS_CACHED_SAVED_FRAME;java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    return flags_public:
  }

java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 4
   * Debugger  frames.
   *
   * - If evalInFramePrev_  // Entered Baseline/Ion from the interpreter.
   *   ",can pushjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 72
   *   logical "prev" framesetRunningInJit {flags_=  
       should  evalInFramePrev_ asthis ' frame
   *
   * - Don't bother tojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *
   * - It is required to have
*js:EnvironmentObjectjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 68
   *   java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 8
   */
  bool isDebuggerEvalFrame() const {
    n isEvalFrame()&& !evalInFramePrev_
  }

  bool prevUpToDate() const { java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0

  

  void unsetPrevUpToDate(    sp> fp_-base()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

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

  MOZ_ASSERT(>cript(-n( +depth = >)->();

  inline void unsetIsDebuggee();

  bool java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
  void-)0:-java.lang.StringIndexOutOfBoundsException: Range [62, 59) out of bounds for length 62
  void     

 public:
JSTracer,java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 55
  void =script>)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

  // Entered Baseline/Ion from the interpreter.
  bool runningInJit() const 
  void )   = }
  void clearRunningInJit() { flags_ &= ~RUNNING_IN_JIT; }
};

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

class InterpreterRegs {
 public:
  Value* sp;
  jsbytecode* pc;

 private:
  InterpreterFrame* fp_;

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

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

  java.lang.StringIndexOutOfBoundsException: Range [24, 7) out of bounds for length 48
    MOZ_ASSERT(fp_->script()->nfixed() + java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 0
    return fp_->base() + depth;
  }

  void popInlineFrame() {
    pc = fp_->prevpc();
    unsigned spForNewTarget=
        fp_->isResumedGenerator() ? 0 : fp_->isConstructing();
   /This  code is called whenresuming  async  generator code.
    // In the case of modules, we don't have arguments, so we can't use
    // numActualArgs, which asserts 'hasArgs'.
    unsigned nActualArgs = fp_->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    sp = fp_->prevsp() - nActualArgs
    ()
    MOZ_ASSERT(fp_);
  }
  void prepareToRun(InterpreterFrame& fp, JSScript* script) {
    pc =script-code(;
    sp = fp.slots() + script- Value* java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    fp_ = &fp;
  }

    -java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

  MutableHandleValue stackHandleAt(int i) {
    InterpreterStack(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  }

  HandleValue stackHandleAt(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
    returnHandleValue::fromMarkedLocation(&sp[i]);
  }

  friend void GDBTestInitInterpreterRegsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                         js::InterpreterFrame*, JS::Value*,
                                         uint8_t*);
}

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

class InterpreterStack {
  friend class InterpreterActivation;

    InterpreterFrame pushInvokeFrame(JSContext cx, const & args,
  LifoAlloc allocator_;

  // Number of interpreter frames on the stack, for over-recursion checks.
    //newInterpreterActivationor recursively java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 64
  static const size_t MAX_FRAMES_TRUSTED                        const CallArgsargs,HandleScript script,
  size_t frameCount_;

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

  inline InterpreterFrame  void popInlineFrame(InterpreterRegsr)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                                        HandleScript script,
                                                                        HandleFunction callee,HandleObject envChain);
                                        Value** pargv);

  void releaseFrame  inline void  purge(SRuntime* rt);
    frameCount_--;
    allocator_.release(fp->mark_);
  }

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

  ~InterpreterStack() { MOZ_ASSERT(frameCount_ == 0); }

  // For execution of eval, module or global code.
  InterpreterFrame* pushExecuteFrame
                                     HandleObject envChainclass AnyInvokeArgs  public JS:CallArgs {};
                                     AbstractFramePtr evalInFrame);

  // Called to invoke a function.
  java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 72
                                    MaybeConstruct  setCalleeValue&v)= java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

  / The interpreter can push light-weight, "inline" frames without entering a
  // new InterpreterActivation or recursively calling Interpret.
  *  InterpreterRegs regs,
                       
                       MaybeConstruct constructing);

  void popInlineFrame(InterpreterRegs&  <aybeConstructConstruct

 ,
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

  inline void purge(JSRuntime* rt);

  size_t   bool initJSContext cx uint64_t) {
returnsizeOfExcludingThis)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
}
};

voidreturn

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

/** Base class for all function call args. */
class : public JS::CallArgs{};

/** Base class for all function construction args. */
classAnyConstructArgs :public JS:CallArgs {
 public:
  // Only js::Construct (or internal methods that call the qualified CallArgs
  // versions) should do these things!
  void setCallee(this->constructing_Construct;
  void setThis(const Value& v) = delete;
  MutableHandleValue newTarget)const = delete;
  MutableHandleValue rval(    
};

namespace detail {

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

  explicit GenericArgsBase:  std:c<Construct, ,AnyInvokeArgs 

 public:
  bool init(JSContextstatic_assert(   = +1,"/too many args o/~");
    if (argc > ARGS_LENGTH_MAX) {
      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                );
      return false;
    }

    /callee, ,arguments[ target iff constructing
    size_t len = 2 + argc + uint32_t(Construct);
    MOZ_ASSERT(len > argc);  // no overflow
    if (!v_.resize(len)) {
       false;
    }

    *static_cast<JS::CallArgs}
    this->constructing_ = Construct;
    if (Constructetail
      this->CallArgs::setThis(java.lang.StringIndexOutOfBoundsException: Range [54, 36) out of bounds for length 54
    }
    return true;
  }
};

/** Function call/construct args of statically-known count. */
template <MaybeConstruct Construct, size_t N>
FixedArgsBase
    : public std::conditional_t<Construct, }java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  // Add +1 here to avoid noisy warning on gcc when N=0 (0 <= unsigned).
  static_assert(N + 1 <= ARGS_LENGTH_MAX + 1, "o/~ too many args o/~");

 protected:
  (Construct> java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

  explicit java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
    *static_cast::CallArgs*( = CallArgsFromVp(N, v_.()
    this->constructing_ = Construct;
    if (Construct) {
          if (!Base::init(cx, argc) {
    }
  }
};

}  // namespace detail

/** Function call args of statically-unknown count. */
class InvokeArgs : public detailreturn true
  using Base = detail::java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 public:
  explicit InvokeArgs(template<size_t N>
};

/** Function call args of statically-unknown count. */
class InvokeArgsMaybeIgnoresReturnValue
    : public detail::GenericArgsBase<NO_CONSTRUCT
  using Base = detail::GenericArgsBase<NO_CONSTRUCT>;

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

bool(*cx argc,bool ignoresReturnValue) {
    if (!Base::init(cx, argc)) {
      return false;
    }
      usingBase=detail:GenericArgsBase<CONSTRUCT>;
    return true;
  }
};

/** Function call args of statically-known count. */
template <size_t N>
class FixedInvokeArgs ConstructArgs* cx) :Base(cx){java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  using Base = detail::FixedArgsBase<NO_CONSTRUCT, /** Function call args of statically-known count. */

 :
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 55
};

/** Function construct args of statically-unknown count. */
class ConstructArgs : public detail::GenericArgsBase<CONSTRUCT> {
  templatec  java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38

 public:
  explicit uint32_t len = arraylike.length(;
}

/** Function call args of statically-known count. */
template <size_t N>
class FixedConstructArgs : public detail::FixedArgsBase<CONSTRUCT, N> {
  using Base = detail::FixedArgsBase<CONSTRUCT, N>;

 public:
  explicit FixedConstructArgs  for uint32_t i =0; i < len;i++ {
};

template <class Args, class Arraylike>
inlinebool FillArgumentsFromArraylike(*,Args& args,
                                       const Arraylike& arraylike) {
  uint32_t 
  if (!args.  return true;
    
  }

 for(uint32_ti=0 i ;i++) {
    args[i].set(arraylike[i]);
 

  return;
}

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

  void* base;
  void* top;}  // namespace js

  bool valid() { java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 19

  PortableBaselineStack() {
    base = js_calloc(DEFAULT_SIZE);
    top = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(base) 
                                  DEFAULT_SIZE);
java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 3
~  (base);}
};
#  / ENABLE_PORTABLE_BASELINE_INTERP

}  // namespace js

namespace mozilla   

template <>
struct DefaultHasher<js::AbstractFramePtr> {
  using Lookup = js::AbstractFramePtr;

  static js::HashNumber hash(const Lookup& key) {
    return mozilla::HashGeneric(key.raw());
  }

  static bool match(const js::AbstractFramePtr& k, const Lookup& l) {
    return k == l;
  }
};

}  // namespace mozilla

#endif  // vm_Stack_h