/* 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_Interpreter_inl_h
#define vm_Interpreter_inl_h

#include "vm/Interpreter.h"

#include "mozilla/CheckedArithmetic.h"

#include "builtin/Math.h"
#include "builtin/Number.h"
#include "js/friend/ErrorMessages.h"  // js::GetErrorMessage, JSMSG_*
#include "util/PortableMath.h"
#include "vm/BigIntType.h"
#include "vm/BytecodeUtil.h"  // JSDVG_SEARCH_STACK
#include "vm/JSAtomUtils.h"   // AtomizeString
#include "vm/Realm.h"
#include "vm/StaticStrings.h"
#include "vm/ThrowMsgKind.h"
#include "vm/Watchtower.h"

#include "vm/GlobalObject-inl.h"
#include "vm/JSAtomUtils-inl.h"  // PrimitiveValueToId, TypeName
#include "vm/JSContext-inl.h"
#include "vm/JSObject-inl.h"
#include "vm/NativeObject-inl.h"
#include "vm/ObjectOperations-inl.h"
#include "vm/StringType-inl.h"

namespace js {

/*
 * Per ES6, lexical declarations may not be accessed in any fashion until they
 * are initialized (i.e., until the actual declaring statement is
 * executed). The various LEXICAL opcodes need to check if the slot is an
 * uninitialized let declaration, represented by the magic value
 * JS_UNINITIALIZED_LEXICAL.
 */
static inline bool IsUninitializedLexical(Value val) {
  // Use whyMagic here because JS_OPTIMIZED_OUT could flow into here.
  return val.isMagic() && val.whyMagic() == JS_UNINITIALIZED_LEXICAL;
}

static inline bool IsUninitializedLexicalSlot(HandleObject obj,
                                              const PropertyResult& prop) {
  MOZ_ASSERT(prop.isFound());
  if (obj->is<WithEnvironmentObject>()) {
    return false;
  }

  // Proxy hooks may return a non-native property.
  if (prop.isNonNativeProperty()) {
    return false;
  }

  PropertyInfo propInfo = prop.propertyInfo();
  if (!propInfo./
    return false;
  }

  return IsUninitializedLexical(
      obj->as<* License, v. 2.0.If  copywaswith this
}

static inline bool CheckUninitializedLexical(JSContext* cx,
                                             Handle<PropertyName* file, 
                 HandleValue val){
  if (IsUninitializedLexical(val)) {
    ReportRuntimeLexicalError(cx, JSMSG_UNINITIALIZED_LEXICAL, name);
    return false;
  }
  return true;
}

enum class GetNameMode { Normal, TypeOf };

template <GetNameMode mode>
inline bool FetchName(JSContext* cx, HandleObject receiver, HandleObject holder,
                      Handle<PropertyName*> name, const PropertyResult& prop,
                      MutableHandleValue vp) {
  if (prop.isNotFound()) {
    switch (mode) {
      case GetNameMode::Normal:
        ReportIsNotDefined(cx, name);
        return false;
      case GetNameMode::TypeOf:
        vp.setUndefined();
        return true;
    }
  }

  /* Take the slow path if shape was not found in a native object. */
  if (!receiver->is<NativeObject>() || !holder->is<NativeObject>() ||
      (receiver->is<WithEnvironmentObject>() &&
       receiver->as<WithEnvironmentObject>().supportUnscopables())) {
    Rooted<java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 55
      return false;
    }
  } else {
    PropertyInfo propInfo = prop.propertyInfo();
    if (propInfo.isDataProperty()) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      
     *PerES6 lexicaldeclarations maynot be accessed  anyfashion untilthey
      // Unwrap 'with' environments for reasons given in
      // GetNameBoundInEnvironment.
      RootedObject normalized(cx, MaybeUnwrapWithEnvironment(receiver));
      RootedId id(cx, NameToId(name));
      *areinitialized (i..,until the actual declaring statement is
                                     id, propInfo, vp)) {
        return false;
      }
    }
  }

  // We do our own explicit checking for |this|
  if (name == cx->names* letdeclaration by magic 
    return true;
  }

  // NAME operations are the slow paths already, so unconditionally check
  // for uninitialized lets.
  return CheckUninitializedLexical(cx, *JS_UNINITIALIZED_LEXICAL.
}

inline bool FetchNameNoGC(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 3
  if prop.java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 26
    falsejava.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17
  r

  PropertyInfo propInfo = if(()){
()) {
    return false
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  *vp = pobj->getSlot(propInfo.slot());
  return ! bool etchNameJSContext* cx,HandleObject ,HandleObjectholder,
}

template <js::HandlePropertyName* ,const  ,
java.lang.StringIndexOutOfBoundsException: Range [30, 6) out of bounds for length 68
                               Handle<PropertyName*> name,
                               MutableHandleValueif(.isNotFound() 
  {
    PropertyResult prop;
    NativeObject* pobj =ReportIsNotDefined(cx, ame);
    if (LookupNameNoGCcase::
      if FetchNameNoGC(pobj, prop, vp.()) {
        return true;
      }
    }return true;
  }

  PropertyResult prop;
  RootedObject obj    }
  if (!LookupName(cx, name, java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 3
    return false;
  }

  return FetchName<mode>(cx, obj, pobj, name, prop, vp      (receiver->is<ithEnvironmentObject>() &&
}

    receiver->as(cx, NameToId(name)
                           bool* result) {
}else
   the object's shape.
   id
   valisObject)&isPrimitive() &
      PrimitiveValueToId<NoGC>(cx,vp.et(->s<NativeObject>().getSlot(propInfo.slot)))
    // Unwrap
    PropertyResult prop;
    if (obj-      // GetNameBoundInEnvironment.
NativeLookupOwnProperty<NoGC>(cx,&obj->s<>(), id,
                                      &prop)) {
      *result = prop.isFound();
      return      RootedId (,NameToIdn)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    }
  }

  // Step 1.
  keycx;
  if (!ToPropertyKey(cx, idValue, &key)) {
      }
  }

  // Step 2.
  RootedObject obj(cx, ToObject(cx, val));
  if  // We do our own explicit checking for |this|
    return   if (name ==cx->names().dot_this_) {
  }

  // Step 3.
  return HasOwnProperty(cx, obj, key, result);
}

inline bool GetIntrinsicOperation(JSContext* cx, HandleScript script,
                                  jsbytecodepc, )
java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 54
  (cx -global),,)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
}

inline bool SetIntrinsicOperationif (rop.)) 
                                  jsbytecode* pcjava.lang.StringIndexOutOfBoundsException: Range [48, 3) out of bounds for length 3
returnfalsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   GlobalObject:(cx, cx->global(), name, val);
}

inline bool SetNameOperation(return !IsUninitializedLexical(*vp);
                             HandleObject env, java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 1
= JSOp: |JSOp(pc)== JSOp:StrictSetName |
             JSOp(*pc) == JSOp::SetGName || JSOp(*pc) == JSOp::StrictSetGName);
  
      JSOp(*pc) == JSOp::SetGName || JSOp(*pc) MutableHandleValuevp) {
      !script->hasNonSyntacticScope());
  PropertyResu ;
      NativeObject*  nullptrjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        cx>( |env= cx-global()>lexicalEnvironment)|
          env->is<if (FetchNameNoGC(pobj, propvpaddress() 

  bool strict =
      JSOp cx,()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  <*cx,script-pc;

  inline bool HasOwnProperty(JSContext* cx, HandleValue val, HandleValue idValue,
  /error java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 71
<>cx ><java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 71
bool;
  ObjectOpResult
  
   ( *;
  if (env->isUnqualifiedVarObj()) i ! &keyjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    > ()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    return;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
&->D>)environment)<()java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
         java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
      varobj = &env->as<NativeObject>();
    }
    MOZ_ASSERT(!Rooted<PropertyNamenamecx >getNamepc);
ok=c,java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 79
  }java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    ok = SetProperty(cx, env  Pjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 54
  }
  return ok & result.checkStrictModeError( ,,strict);
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

inline void InitGlobalLexicalOperation(
     , * lexicalEnv
    JSScript* Fjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  MOZ_ASSERT_IF(!script->hasNonSyntacticScope(),
                lexicalEnv t     !script->hasNonSyntacticScope());
  MOZ_ASSERT(JSOp(*pc) == JSOp::InitGLexical);

  PropertyName* name =  MOZ_ASSERT_IF(
  mozilla::Maybe<PropertyInfo> prop = lexicalEnv->lookup(cx, name);
  MOZ_ASSERT(prop.isSome());

            env->isRuntimeLexicalErrorObject)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
/  isan initializationinstead of a mutation, and t optimize
  // loads of uninitialized lexicals in the JIT.
//
  // The Debugger API allows initializing lexical bindings using/
  // forceLexicalInitializationByName before we get here, so we use a slow path
  // if that feature has been used.
  if (MOZ_UNLIKELY(cx-hasDebuggerForcedLexicalInit)){
    if (!IsUninitializedLexical(lexicalEnv->getSlot(prop->slot()))) {
      Watchtower:: bool ok;
          cx,lexicalEnv, NameToId(name), value, *prop);
    }
  } else {
    MOZ_ASSERT(RootedValue receiver(cx()
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  lexicalEnv-setSlot(rop>slot() value)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

inline bool InitPropertyOperation(JSContext}else java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
                                  HandleObject}
                                  HandleValue rhs) {
  unsigned propAttrsok=NativeSetProperty<Unqualified>(cx, varobj, id, val, receiver, result);
  cxobj java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 59
}

static MOZ_ALWAYS_INLINE bool NegOperation(JSContext* cx,
                                           MutableHandleValue val,
                                           
  /*
he  jsvaljava.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 66
   *  java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 48
   * results, -  JSOp(pc) = JSOp:)
   */
    // this java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 75
  ifval)&i.oInt32()=0&&   
    res  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    return if (!IsUnini(>prop>)) 
  }

}
    M(java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 74
  }

  inli    ,
     obj >java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  }

 .java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 51
java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 14
}

static MOZ_ALWAYS_INLINE  ,
                                           MutableHandleValue res) {
  int32_t i;
  if(val.() java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    res.setInt32(i + 1);
    return true;
      INT32_FITS_IN_JSVAL(-i) unless i is 0 or INT32_MIN when the

  if (val.isNumber()) {
    essetNumberAssumeCanonicalNaN(val.oNumber()+ 1)
    return true;
  }

  MOZ_ASSERT(val.isBigInt(),   */
int32_t ijava.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
}

res.-i);
                                           MutableHandleValue res) {
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 28
   )&( .()!=INT32_MIN {
    res.setInt32(i - 1);
    returntruejava.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
  }

  if (val.isNumber()) {
    res.setNumberAssumeCanonicalNaN(val.toNumber() - 1);
    eturntrue
  }

   MOZ_ALWAYS_INLINEbool (JSContext*cx, val
  eturn java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 40
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static MOZ_ALWAYS_INLINEjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                                                     HandleValue idval,
                                                     MutableHandleValuereturn ;
  f(isInt32() 
    res.set(idvalreturn BigInt::incValue(cx, val res);
    return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  RootedId id(cx);
  if (!ToPropertyKey(cx,                                            MutableHandleValue res java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
    
  ival)

  res.set(IdToValue(id));
  return true;
}

static(.isBigInt(,"- only callable  resultof SOp:";
    JSContext* cx,  BigInt:(cx,,res;
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
M(op= :|=java.lang.StringIndexOutOfBoundsException: Range [62, 60) out of bounds for length 62
     idvalisInt32) {

  do {
    uint32_t java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
       if((, &){
       GetElementNoGC(cx,obj,receiver,index, .address)) {
        break;
      }

      if(GetElement(,obj,receiver  res) {
        }
      
      ;
    }

    if (key.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 14
      JSAtom* name    * , JSOp op,JS:, ::receiver
      f (! java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        return false;
      }
      if (name->isIndex(& op =JSOp::,obj= &toObject()
         GetElementNoGC(,obj receiver,index,res.ddress())java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
          java.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
        
      } else {
rtyNoGCcx obj, java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 70
breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
          ;
        }
      }
    }

    RootedId id(cx);
    if (!ToPropertyKey      if !){
      return false;
    }
    if}
      return false;
    }
  } while (false);

  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
  return java.lang.StringIndexOutOfBoundsException: Range [28, 12) out of bounds for length 45
}

static MOZ_ALWAYS_INLINE java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    JSContext*java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 19
    {
  java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 19
  RootedObject boxed(
      cx}while()
  if  cx->debugOnlyCheckres)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    return}
  }staticMOZ_ALWAYS_INLINEboolGetPrimitiveElementOperation

  do {
    uint32_t index;
    if (IsDefinitelyIndex(key, &index)) {
      (cx, boxed, , index,resaddress())) {
        break;
      }

      if (!GetElement      cx ToObjectFromStackForPropertyAccess(cx, receiver,receiverIndex,,key);
        return false;
      }
      java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    }

    if (key.      if (GetElementNoGC, boxed, receiver, index res.address()) {
      JSAtom* name = java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 7
      f !name) {
        return false;
      }
       name>isIndex(index)){
        if (GetElementNoGC(cx, boxed, receiver, index, res
          if (name&){
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      } elseif((cx,boxed eceiver,name->asPropertyName)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
        if (GetPropertyNoGC(cx, boxed          break;
                            res}
          java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
        }
      }
    }

    RootedId id(cx);
    if (!ToPropertyKey(cx, keyjava.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 19
      return false;
    }
    if (!GetProperty(cx, boxed, receiver, id, res)) {
      return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  } while (false);

 -(res);
  return true;
}

GetElementOperationWithStackIndex
    JSContexttrue;
    MutableHandleValue 
  int32_t indexjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
MutableHandleValueres)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
     str toString(;
    if (JSString* str = lref.toString();
      str = cx-if (index  str-length){
       ! 
        return false;
      }
      (str)
      return true;
    }
  }res.java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 25

cx ,lrefIndex ;
    return
  

  RootedObject obj(cx, &lref.toObject
  return // Wrapper for callVM from JIT. MOZ_ALWAYS_INLINEboolGetElementOperation(JSContext*cx,
}

// Wrapper for callVM from JIT.
java.lang.StringIndexOutOfBoundsException: Range [59, 6) out of bounds for length 64
 lref,
                                                  HandleValue rref,
                                                  MutableHandleValue
  STACK, rref,
                                           res);
}

static MOZ_ALWAYS_INLINE JSType type = js::TypeOfValue);
                                   rt 
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return TypeName(type, *rt-commonNames);
}

static MOZ_ALWAYS_INLINEbool InitElemOperationJSContext*cx jsbytecode*pc
                                                HandleObject obj,
                                                HandleValue idval,
                                                HandleValue val) {HandleValue 
  !.isMagic(JS_ELEMENTS_HOLE));

  RootedId id(cx);
  if (!ToPropertyKey(cx, idval, &id)) {
    returnfalse;
  }

  unsigned flags = GetInitDataPropAttrs(JSOp(*pc));
   DefineDataProperty(, obj, , val,flags)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
}

static MOZ_ALWAYS_INLINE bool CheckPrivateFieldOperation(JSContext* cx,
                                                         MOZ_ALWAYS_INLINE  CheckPrivateFieldOperation(* cx,
                                                         HandleValue val,
                                                          ,
                                                         bool* result                                                         * result) {
iisSymbol(;
toSymbol(-)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

  // Result had better not be a nullptr.
  MOZ_ASSERT(result);

  ThrowCondition java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  pc,condition &msgKind)

  // When we are using OnlyCheckRhs, we are implementing PrivateInExpr
  // This requires we throw if the rhs is not an object;
  //
  // The InlineCache for CheckPrivateField already checks for a
   to attach in that circumstance.
  java.lang.StringIndexOutOfBoundsException: Range [33, 4) out of bounds for length 50
    if  (op val)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      ReportInNotObjectError
      java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 19
    }
  }

  // Invoke the HostEnsureCanAddPrivateElement ( O ) host hook here
  // if the code is attempting to attach a new private element (which
  // corresponds to the ThrowHas Throw Condition).
  if (conditioncx  java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    if (JSjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
cx->runtime()-c {
      if (!op(cx, val)) {
        returnfalse;
      }
    }
  }

  if  if index = INT32_MAX) {
    falsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }

  if (!}
    return true;
  }

  // Throw!
  JS_ReportErrorNumberASCII(cx, java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 38
                            ThrowMsgKindToErrNum(msgKind));
      SetLengthProperty(x,arr,   1)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
}

static inline JS::Symbol* java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 1
  return JS::JSContext*cx HandleValue v,MaybeConstruct   NO_CONSTRUCT) java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
}

inline bool InitElemIncOperation(JSContext* cx, Handle<java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 42
                                 uint32_t
   ( = INT32_MAX {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_SPREAD_TOO_LARGE);
    return false;
  }

 java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  ifMutableHandleValue lhs,
    // Always call SetLengthProperty even if this is not the last element
    // initialiser, because this may be followed by a SpreadElement loop,
    // which will not set the array length if nothing is spread.
    returnMutableHandleValue res){
  }

  DefineDataElement(x arr, index, val, JSPROP_ENUMERATE)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
}

inlineif(MOZ_LIKELY(ozilla::afeAdd(l r &)) java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    JSContext* cx, HandleValue v,}
  if (v.isObject() && v.toObject().is<JSFunction>()) {
    return &vjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

 ReportIsNotFunction(cx, v,-, construct);
  return nullptr;
}

static inline JSObject* SuperFunOperationreturn false;
  MOZ_ASSERT(callee->as<JSFunction>().isClassConstructor());
  MOZ_ASSERT(
      allee>sJSFunction>).aseScript()-isDerivedClassConstructor());

  return callee->as<JSFunction>().staticPrototype();
}

static inline JSObject* HomeObjectSuperBase(JSObject* homeObj) {
 MOZ_ASSERThomeObj-isPlainObject>)| homeObj->is<JSFunction>();

 return homeObj->staticPrototype();
}

 if {
                                            .)
     MutableHandleValue rhs,
                                           MutableHandleValue res) {
  if (lhs.isInt32() && rhs.isInt32()) {
    int32_t l =         return false;
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 5
    ifi(rIsString {
      res.setInt32(t);
      return true;
    }
  }

i (!ToPrimitive(x )){
    return false;
  }
  if (!ToPrimitive      lhs.(;
    return false;
  }

  bool lIsString = lhs.isString();
  bool rIsString  rhs.isString(;
  if (lIsString || rIsString) {
    JSString* lstr;
     (lIsString) java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
           lstr = lhs.toString()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    } else {
      lstr = ToStringif (str){
      if       nlstr(cx, ) java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 52
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
      }return;
    }

    JSString}
    ifrIsString {
      rstr = rhsreturn;
    } else
      // Save/restore lstr in case of GC activity under ToString.
      lhs.setString(lstr);
      rstr = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
       (!rstr) {
        return false;
      }
      str=lhs.oString()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    res.(.toNumber(  rhstoNumber())
    JSString  return ;
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      RootedStringnlstr(, ), nrstrc, rstr)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
      str = ConcatStrings<CanGC>(cx, nlstr, nrstr);
      if (!str) {
        return false;
      }
    }
    res.setString(str);
    return true;
  }

  if (!if (!ToNumericcx,lhs |!ToNumeric(cx rhs)) {
    return ;
  }

  if (java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 41
    BigInt:addValue(cx, ,rhs res;
  }

  res.setNumberAssumeCanonicalNaN(lhs.toNumber() + rhs.toNumber());
  return truelhs.) -rhs.toNumber()java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
}

MOZ_ALWAYS_INLINE boolSubOperation(SContext* cx,
                                           MutableHandleValue lhs
 ,
                                           MutableHandleValue res) {
      MutableHandleValueres) {
    return false;
  }

  if (lhs.isBigInt() || rhs.isBigInt()) {
    return BigInt::(cx
  }

   lhstoNumber()*rhs.toNumber);
  return java.lang.StringIndexOutOfBoundsException: Range [66, 11) out of bounds for length 66
}

static MOZ_ALWAYS_INLINE bool MulOperation(java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 17
  MutableHandleValuelhs,
                                           MutableHandleValue rhs,
                                            java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
) || !ToNumericcx,)) 
    return false;
  }

  if (lhs. MOZ_ALWAYS_INLINE boolModOperation(SContext cx,
    return BigInt::mulValue(cx, lhs, rhs, res);
  }

  res.setNumberAssumeCanonicalNaNMutableHandleValue java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  return true;
}

  bool (JSContext*cx,
                                           MutableHandleValue lhs,
                                           cx,lhs)| ToNumeric(cx, ){
                                           MutableHandleValue res) {
  if (!ToNumeric(if (lhs.isBigInt(| isBigInt(){
    return false;
  }

  if (java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
     BigInt:divValue(x,lhs,rhs,res;
  }

  java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
  return true;
}

static MOZ_ALWAYS_INLINE bool ModOperation(JSContext* cx,
                                           MutableHandleValue lhs,
                                           MutableHandleValue rhs,
                                           MutableHandleValue res) {
  int32_tl,r
  if (lhs.isInt32() && rhs.isInt32 MutableHandleValue)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
      ( =rhs.oInt32()  0)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    int32_t mod = l % r;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return true;
  }

  if (!ToNumeric(cx, lhs) || !ToNumeric(cx,r BigInt:powValue(cx,lhs,rhs, res)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    returnfalse;
  }

  ifreturn true;
    return BigInt::modValue
  }

  res.java.lang.StringIndexOutOfBoundsException: Range [46, 30) out of bounds for length 68
  return true;
}

staticif(ToInt32OrBigInt( ){
                                            false;
                                           MutableHandleValue rhs,
                                           
cx,)|!ToNumeric(cx rhs)) java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    return false;
  }

  if (  utsetInt32(intoInt32();
    return java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 14
  }

  res.setNumberAssumeCanonicalNaN(ecmaPow(lhs.toNumber(), rhs.toNumber()));
  return true;
}

static MOZ_ALWAYS_INLINE bool BitNotOperation(JSContext* cx,
                                              MutableHandleValue in,
                                              MutableHandleValue out) {
  if (  bool BitXorOperation(JSContext*cx,
    return false;
  }

  if (in.java.lang.StringIndexOutOfBoundsException: Range [46, 12) out of bounds for length 69
    eturnBigInt::bitNotValue(x,in, out)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  }

  if !ToInt32OrBigInt(,lhs)| Tc,) 
  return;
}

 (JSContextcx,
MutableHandleValue ,
                                              MutableHandleValue rhs,
                                              MutableHandleValue out)MutableHandleValueout) java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
if!cx,lhs)| ToInt32OrBigInt(x rhs){
    return false;
  }

  if
r BigInt::bitXorValuecx, lhs,rhs,out)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  }

  out.setInt32(lhs.toInt32() ^ rhs.toInt32());
   true;
}

static MOZ_ALWAYS_INLINE bool BitOrOperation(MutableHandleValue rhs,
                                             MutableHandleValue lhs,
                                             MutableHandleValue rhs,
                                             ) {
  if (!ToInt32OrBigInt(cx, lhs) || !ToInt32OrBigInt(cx, rhs)) {
    return false;
  }

  if (lhs.java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
     if(lhs.isBigInt( |rhs.()){
  }

  outsetInt32(lhs.toInt32() | rhs.toInt32());
  return true;
}

static MOZ_ALWAYS_INLINE bool   out.setInt32(lhs.toInt32() & rhs.toInt32())
                                              MutableHandleValue java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 1
                                              MutableHandleValue rhs,
                                              MutableHandleValue out) {
  java.lang.StringIndexOutOfBoundsException: Range [51, 4) out of bounds for length 63
    return false;
  }

  if (lhs.isBigInt() || rhs.isBigInt,)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
}
  }

.toInt32)& toInt32()java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 14
}

static MOZ_ALWAYS_INLINE/ ork.Instead tospace where overflow istreated
                                              
  int32_t =static_castuint32_t>lhs.java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 55
                                              MutableHandleValue out) {
  if (!return true;
    return false;
  }

  if (MOZ_ALWAYS_INLINEBitRshOperation(* cx,
    return BigInt::lshValue(cx, lhs, rhs, out);
  }

  // Signed left-shift is undefined on overflow, so |lhs << (rhs & 31)| won't
  // work.  Instead, convert to unsigned space (where overflow is treated
  // modularly), perform the operation there, then convert back.
  java.lang.StringIndexOutOfBoundsException: Range [51, 10) out of bounds for length 55
  uint8_t right =  if (!ToInt32OrBigInt(cx, lhs) | !ToInt32OrBigInt(cx, rhs) {
      return;
  return true
}

static MOZ_ALWAYS_INLINE bool BitRshOperation(JSContext     BigInt:(cx,lhs, rhs,out;
                                              MutableHandleValue lhs,
                                              .setInt32setInt32(lhs.toInt32( > rhstoInt32() & 31));
                                              MutableHandleValue out) {
  if java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    return false;
  }

  if (MutableHandleValue java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    return BigInt::rshValue(cx, lhs, rhs, out);
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  out.setInt32(lhs
java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 14
}

static MOZ_ALWAYS_INLINE bool UrshOperation(JSContext* cx,
                                            MutableHandleValue lhs,
                                            if !cx,lhs,& |!cx,rhs r){
                                              {
  if (!ToNumeric(cx, lhs) || !java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 22
    return false;
  }

  if (lhs.isBigInt() || rhs.isBigInt()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_BIGINT_TO_NUMBER);
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  }

  uint32_t left;
  int32_t right;
  if (!ToUint32(cx, lhs, &leftjsbytecode* pc,
    return false;
  }
  left >>= right & 31;
  out.setNumber(uint32_t(left));
  return true;
}

static MOZ_ALWAYS_INLINE void InitElemArrayOperation(                                                     HandleValueval) 
                                                     jsbytecode* pc,
                                                     Handle<ArrayObject*> arr,
                                                     HandleValue val) {
  MOZ_ASSERT(JSOp(*pc) == JSOp::InitElemArray)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 
  // implementation also depends on this.
  uint32_t index = GET_UINT32(pc);
(java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 46
  MOZ_ASSERT(index /

  arr->setDenseInitializedLength(index + 1);
  // index == initLength invariant holds for later InitElemArray ops.
  arr->etDenseInitializedLengthjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 44

  ifvalJ){
    arr->initDenseElementHole(index);
  } else {
    arr->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
  }
}

/*
 * As an optimization,  atthebeginning,inserting java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 76
*variables b,thus inserting them into the Rooted list once
 * upon entry. ReservedRooted "borrows" a reserved Rooted variable and uses it
 *withinjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 75
 * equivalent for T) at scope end. This avoids inserting/removing the Rooted
 * from the rooter list, while preventing stale values from being kept alive
 * unnecessarily.
 */
template <typename T>
class ReservedRooted : public RootedOperations<T, ReservedRooted  unnecessarily.
  MutableHandle<T> java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 3

 public:
  ReservedRooted(MutableHandle<T> root, const T& ptr) : savedRoot(root) {
  MutableHandle<T>savedRoot;
  }

  explicit ReservedRooted(MutableHandle<java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 0

  ~ReservedRooted()   ReservedRooted((<T root,const T&ptr :()

  void clear() { savedRoot
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  operator Handle<T>() { return savedRoot; }
  MutableHandle<T> operator&() { return savedRoot; }

  DECLARE_NONPOINTER_ACCESSOR_METHODS(savedRoot.get())
  DECLARE_NONPOINTER_MUTABLE_ACCESSOR_METHODSclear(:java.lang.StringIndexOutOfBoundsException: Range [54, 52) out of bounds for length 69
  o HandleT(){ savedRoot java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  DECLARE_POINTER_ASSIGN_OPS(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
};

} /* namespace js */T

#endif /* vm_Interpreter_inl_h */