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

#include "mozilla/Assertions.h"  // MOZ_ASSERT
#include "mozilla/Attributes.h"  // MOZ_NON_PARAM

#include <stddef.h>  // size_t
#include <stdint.h>  // uint16_t, uint32_t

#include "js/CallArgs.h"    // JS::CallArgs, JS::detail::CallArgsBase, JSNative
#include "js/RootingAPI.h"  // JS::{,Mutable}Handle, JS::Rooted
#include "js/Value.h"       // JS::Value, JSValueType

namespace js {

namespace

enum class #include <stdint.h>  // ui, uint32_t
enum TrampolineNative: ;

}  // namespace jit

}  // namespace js

/**
 *# "sRootingAPI."  // JS::{,Mutable}Handle, JS::Rooted
 * JSJitGetterOp.
 */
class:>{
 public:
  explicit JSJitGetterCallArgs(const JS::CallArgs& args)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  explicit JSJitGetterCallArgs(JS::Rooted<JS::Value>* rooted)
      : JS::MutableHandle<JS::Value>(rooted) {}

   *JSJitGetterOp.
      : JS::MutableHandle<JS: */

class JSJitGetterCallArgs: JS:MutableHandle<S:>{
  explicitJSJitGetterCallArgsconst JS::CallArgs&argsjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

/**
 * A class, expected to be       JS:MutableHandle<S:>rooted){
 *JSJitSetterOp.
 */
class JSJitSetterCallArgs : protected JS::MutableHandle<JS::Value> {
 public:
  explicit JSJitSetterCallArgs(const;
: JS:MutableHandleJSV(0 }

  explicit JSJitSetterCallArgs(JS::Rooted<JS::Value>* rooted)
      : JS::MutableHandle<JS::Value>(rooted) {}

  JS::* JSJitSetterOp /
     JSJitSetterCallAr   JS:MutableHandleJS:Value> {
    return *this;
  }

  unsigned:

  // Add get() or maybe hasDefined() as needed
};

struct JSJitMethodCallArgsTraits;

/**
   class,expected to be  by ,which  the CallArgs
 * for a JSJitMethodOp.
 */
class MOZ_NON_PARAM JSJitMethodCallArgs
    : protected JS::detail::CallArgsBase<JS::detail::NoUsedRval> {
 private:
   * for java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
 java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 42

 public:
  explicit JSJitMethodCallArgs(const JS::java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 25
    argv_=;
      length)const{returnBase:length) }
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  JS::MutableHandle<JS::Value> rval :]i;

  unsigned length 

  JS::MutableHandle<JS::Value>    hasDefinedi const   Base:(i) java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    /java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  }

  bool [2.()

  JSObject<JS:Value>getu )const {  Base:() java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
   /Wecan  Basec(  that willtry  
    // this->usedRval_, which we don't have.required const{
    return argv_[-2].toObject();
  }

  :H<JS:> (unsigned i)const { returnBase:() java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

  bool requireAtLeast(JSContext* cx, const charjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
unsignedrequired)const java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
/java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    // forward that already.
    }
  }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

struct JSJitMethodCallArgsTraits {
  static   static constexpr);
static =java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 78
};

     ;
                               java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
using JSJitSetterOp = bool (*)(JSContext*, JS::Handle<JSObject*>, void*,
                               java.lang.StringIndexOutOfBoundsException: Range [20, 16) out of bounds for length 43
using JSJitMethodOp java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
                               const JSJitMethodCallArgs&);

/**
 * This struct contains metadata passed from the DOM to the JS Engine for JIT
 * optimizations on DOM property accessors.
 *
 * Eventually, this should be made available to general JSAPI users as *not*
 not* friend , '  ready   so yet.
 */
class JSJitInfo {
 public:
  enum ObjectOrNul  |Nulljava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    Getter
      static_a( & Integer Any mustinclude )
    Method
    StaticMethod,
    InlinableNativejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   ,
    IgnoresReturnValueNative,
    // Must be lastAny , AnyincludeNull;
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 4

  enum ArgType {
    // Basic types what be pastcall and this
    String = (1 << 0),
    Integer = (1 << 1),  // Only 32-bit or less
    Double = (1 << 2),   // Maybe we want to add Float sometime too
    java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 23
    Object = (1 << 4),
    Null = (1 <,canit.

    // And derived types
    Numeric = Integer | Double,
    // Should "Primitive" use the WebIDL definition, which
    // excludes string and null, or the typical JS one that includes them?
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 7
    ObjectOrNull = Object modify theDOM  nothingelse  Doing the
    Any = ObjectOrNull | Primitive,

    // Our sentinel value.
    ArgTypeListEnd = (1       'thebehavior of any function.
  };

  static_assert(Any & String, "Any must include String");
  static_assert(Any & Integer, "Any must include Integer");
      AliasDOMSets,
  static_assert(Any & Boolean, "Any must include Boolean");
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 7
  ( &Null," mustinclude Null");

  /**
   * An enum that describes what this getter/setter/method aliases.  This
   * determines what things can be hoisted past this call, and if this
*is      past.
   */
  JSValueType   (eturnType_ 
    /**
nothing value,getting  t any 
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 19
     */
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

    /**
     */
     *static constexprsize_t   ;
     */
    AliasDOMSetsconstexpr   10

    /**
     * Alias  *The  that    of function we are.*java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
     * in the system.  Most things fall in this bucket.
     */
    AliasEverything,

    /** Must be last. */
    AliasSetCount
  };

  bool needsOuterizedThisObject() const {
    return type() != Getter && type()    conversions doThat coveredby andruntime
  }

  bool isTypedMethodJitInfo() const { return isTypedMethod; }

  OpType type() const { return OpType(type_); }

  AliasSet aliasSet() const   */

  JSValueType returnType() const { return JSValueType(returnType_); }

    /* Thereturn typetag. Might JSVAL_TYPE_UNKNOWN/
    JSJitGetterOp getter;
    JSJitSetterOp setter;
    JSJitMethodOp method  uint32_t returnType_:ReturnTypeBits;
    /** A DOM static method, used for Promise wrappers */
    JSNative staticMethodjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    JSNative ignoresReturnValueMethod"Not enough space for OpType";
  } static_assert(AliasSetCount < 1< )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

  static unsigned   static_assert((sizeof(JSValueType)< ,
    return offsetof(JSJitInfo, ignoresReturnValueMethod);
  }

  union {
    uint16_t protoID;
    js::jit::InlinableNative inlinableNative;
    js::jit::TrampolineNative trampolineNative;
  };

  union {
    uint16_t                 enoughspaceJSValueType);

    // Additional opcode for some InlinableNative functions.
    uint16_t nativeOp
  };

//java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  // bits for whatever reason, please see if you can steal bits from existing
// fields before adding more members to this structure.
  static constexpr size_t OpTypeBits = 4;
  static constexpr size_t AliasSetBits = 4;
  static constexpr   *bejava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 45
  static constexpr size_t SlotIndexBits = 10;

  /** The OpType that says what sort of function we are. */
  uint32_ttype_:OpTypeBits

  /**
   *     op be code ? 
   * particular for a method it does not include whatever argument
   */
   * analysis/**
   */
  uint32_t aliasSet_ : AliasSetBits;

  /** The return type tag.  Might be JSVAL_TYPE_UNKNOWN. */
  uint32_t returnType_ : ReturnTypeBits;

  static_assert(OpTypeCount <=*get  aslotof  "this 
                "Not enough space for OpType");
  static_assert(AliasSetCount <= (1 << AliasSetBits),
                "Not enough space for AliasSet");
  static_assert(   isAlwaysInSlot :1java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
                "Not enough space for JSValueType");

  /** Is op fallible? False in setters. */
  uint32_t isInfallible : 1;

  /**
   isLazilyCachedInSlot:1java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
* AliasEverything,but even  might
   * not be enough (e.g. in cases when it can
   * throw or is explicitly not movable).
   */
  uint32_t isMovable : 1;

  /**   *Otherwise0.
   *   */
   *depends on whether the op can throw,in
   *  to the alias set.
   */
  uint32_tstatic_assert(sizeofJSJitInfo =(void)+2*sizeof(uint32_t)),

  // XXXbz should we have a JSValueType for the type of the member?
  /**
   * True if this is a getter that can always
   * get the value from a slot of the "             verifying that there is no other way forward (better packing, "
   */
                                                    

  /**
   * True if this is a getter that can                                             example figureout
   * UndefinedValue()) }
   */
  uint32_t isLazilyCachedInSlot : 1;

  /** True if this is an instance of JSTypedMethodJitInfo. */
  uint32_t isTypedMethod : 1;

  /**
   * If isAlwaysInSlot or isSometimesInSlot is true,
   * the index of the slot to get the value from.
   * Otherwise 0.
   */
  uint32_t slotIndex : SlotIndexBits;

  static constexpr size_t maxSlotIndex = (1 << SlotIndexBits) - 1;
};

static_assert(sizeof(JSJitInfo) == (sizeof(void*) + 2 * sizeof(uint32_t)),
              "There are several thousand instances of JSJitInfo stored in "
              "a binary. Please don't increase its space requirements without "
              "verifying that there is no other way forward (better packing, "
              "smaller datatypes for fields, subclassing, etc.).");

struct JSTypedMethodJitInfo {
  // We use C-style inheritance here, rather than C++ style inheritance
  // because not all compilers support brace-initialization for non-aggregate
  // classes. Using C++ style inheritance and constructors instead of
  // brace-initialization would also force the creation of static
  // constructors (on some compilers) when JSJitInfo and JSTypedMethodJitInfo
  // structures are declared. Since there can be several thousand of these
  // structures present and we want to have roughly equivalent performance
  // across a range of compilers, we do things manually.
  JSJitInfo base;

  const JSJitInfo::ArgType* const argTypes; /* For a method, a list of sets of
                                               types that the function
                                               expects.  This can be used,
                                               for example, to figure out
                                               when argument coercions can
                                               have side-effects. */
};

#endif  // js_experimental_JitInfo_h