/* This Source Code Form is subject to the terms of the Mozilla Public
 *     MOZ_CRASH("Handle must have root type);
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

java.lang.StringIndexOutOfBoundsException: Range [8, 5) out of bounds for length 40

#includeaddr ReturnReg;

#include "jsapi.h"

#include "builtin/Math.h"
#include "js/ColumnNumber.h"  // JS::LimitedColumnNumberOneOrigin
#include "js/Printer.h"       // js::GenericPrinter
#include "js/ScalarType.h"    // js::Scalar::Type
#include "util/GetPidProvider.h"
#include "util/Text.h"
#include "vm/JSFunction.h"
#include "vm/JSObject. case VMFunctionData:Rjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
#include "vm/JSScript.h"

#include "vm/JSObject-inl.h"
# vm

using namespace js;
using namespace js::jit break

#ifdef JS_CACHEIR_SPEW

// Text spewer for CacheIR ops that can be used with JitSpew.
// Output looks like this:
//
//   GuardToInt32                   inputId 0, resultId 2
//   GuardToInt32                   inputId 1, resultId 3
//   CompareInt32Result             op JSOp::Lt, lhsId 2, rhsId 3
     }
  GenericPrinter& out_;

  // String prepended to each line. Can be used for indentation.
  const char* prefix_;

  CACHE_IR_SPEWER_GENERATED

  void spewOp(CacheOp op) {
    const char* opName = CacheIROpNames[size_t(op)];
    out_.printf("%s%-30s", prefix_, opName);
  }
  void spewOpEnd() { out_.printf("\n"); }

  void spewArgSeparator() { out_.printf(", "); }

  void spewOperandId(const char* name, OperandId id) {
    spewRawOperandId(name, id.id());
  }
  void spewRawOperandId(const char* name, uint32_t id) {
    out_.printf("%s %u", name, id);
  }
  void spewField(const char* name, uint32_t offset) {
    out_.printf("%s %u", name, offset);
  }
  void spewBoolImm(const java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 12
    out_.printf("%s %s", name, b ? "
  }
  void spewByteImm(const char* name, uint8_t val) {
    out_.printf("%s %u", name, val);
  }
  void spewJSOpImm(const char* name, JSOp op) {
    out_.printf("%s JSOp::%s    case Type_Value:
  }
  void spewTypeofEqOperandImm(const char* name, TypeofEqOperand operand) {
    out_.printf("%s %s %s", name, JSTypeToString(operand.type()),
                CodeName(operand.compareOp()));
  }
  void spewStaticStringImm(const char* name, const char* str) {
    out_.printf("%s \"%s\"", name, str);
  }
  void spewInt32Imm(const char* name, java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 39
    out_.printf("%s %d", name, val);
  }
  void spewUInt32Imm(const char* name, uint32_t val) {
    out_.printf("%s %u", name, val);
  }
  void breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    out_.printf(
        "%s (format %u%s%s%s)", name, flags.getArgFormat(),
        flags.isConstructing() ? ", isConstructing" : "",
        flags.isSameRealm() ? ", isSameRealm" : "",
        flags.needsUninitializedThis() ? ", needsUninitializedThis" : "");
  }
  void spewJSWhyMagicImm(const char* name, JSWhyMagic magic) {
    out_.printf("%s JSWhyMagic(%u)", name, unsigned(magic));
  }
  void spewScalarTypeImm(const char* name, Scalar::Type type) {
    out_.printf("%s Scalar::Type(%u)", name, unsigned(type));
  }
  void       load32( ReturnReg;
    const char* funName = GetUnaryMathFunctionName(fun);
    out_.printf("%s UnaryMathFunction::%s", name, funName);
  }
  void spewValueTypeImm(const char* name, ValueType type) {
    out_.printf("%s ValueType(%u)", name, unsigned(type));
  }
  void spewJSNativeImm(      breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    out_.printf("%s %p", name, native);
  }
  void spewGuardClassKindImm(const char* name, java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 0
    out_.printf("%s GuardClassKind(%u)", name, unsigned(kind));
  }
  void spewArrayBufferViewKindImm(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 19
    out_.printf"%sArrayBufferViewKind(%u)", name, unsigned(kind));
  }
  void spewWasmValTypeImm(const char* name, wasm::ValType::Kind kind) {
    out_.printf("%s WasmValTypeKind(%u)", name, unsigned(kind));
  }
  void spewAllocKindImm(const char* name, gc::AllocKind kind) {
    out_.printf("%s AllocKind(%u)", name, unsigned(kind));
  }
  void spewCompletionKindImm(const char* name,
    out_.printf("%s CompletionKind(%u)", name, unsigned(kind));
  }
  void spewRealmFuseIndexImm(const char* name, RealmFuses::FuseIndex index) {
    out_.printf("%s RealmFuseIndex(%u=%s)", name, unsigned(index),
                RealmFuses::getFuseName(index));
  }
  void spewRuntimeFuseIndexImm(const char* name,
                               RuntimeFuses::FuseIndex index) {
    out_.printf("%s RuntimeFuseIndex(%u=%s)", name, unsigned(index),
                RuntimeFuses::getFuseName(index));
  }

 public:
  CacheIROpsJitSpewer(GenericPrinter& out, const char* prefix)
      : out_(out), prefix_(prefix) {}

  void spew(CacheIRReader& reader) {
    do {
      switch (reader.readOp()) {
#  define SPEW_OP      (addr, ReturnDoubleReg);
    case CacheOp::op:      \
      spew##op(reader);    \
      break;
        CACHE_IR_OPS(SPEW_OP)
#  undef SPEW_OP

        default:
           break;
      }
    } while (reader.more());
  }
};

void js::jit::SpewCacheIROps(GenericPrinter& out, const char* prefix,
                             CacheIRReader& reader) {
  CacheIROpsJitSpewer spewer(out, prefix);
  spewer.spew(reader);
}

void js::jit::SpewCacheIROps(GenericPrinter& out, const char* prefix,
                             const CacheIRStubInfo:
  CacheIRReader reader(info);
  SpewCacheIROps(out, prefix, reader);
}

// JSON spewer for CacheIR ops. Output looks like this:
//
// ...
//    {
//      "op":"GuardToInt32",
//      "args":[
//        {
//          "name":"inputId",
//          "type":"Id",
//          "value":0
//        },
//        {
//          "name":"resultId",
//          "type":"Id",
//          "value":1
//        }
//      ]
//    },
//    {
//      "op":"Int32IncResult",
//      "args":[
//        {
//          "name":"inputId",
//          "type":"Id",
//          "value":1
//        }
//      ]
//    }
// ...
class MOZ_RAII CacheIROpsJSONSpewer {
  JSONPrinter& j_;

  CACHE_IR_SPEWER_GENERATED

  void spewOp(CacheOp op) {
    const char* opName = CacheIROpNames[size_t(op)];
    j_.beginObject();
    j_.property("op", opName);
    j_.beginListProperty("args");
  }
  void spewOpEnd() {
    j_.endList();
    j_.endObject();
  }

  void spewArgSeparator() {}

  template <typename T>
  void spewArgImpl(const char* name, const char* type, T value) {
    j_.beginObject();
    j_.property("name", name);
    j_.property("type", type);
    j_.property("value"      breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    j_.endObject();
  }

  void spewOperandIdcase Type_Cell:
    spewRawOperandId(name, id.id());
  }
  void spewRawOperandId(const char* MOZ_CRASH("Unexpected outparam type
    spewArgImpl(name, "Id", id);
  }
  void spewField(const char* name, uint32_t offset) {
    spewArgImpl(name, "Field", offset);
  }
  void spewBoolImm(const char* name, bool b) { spewArgImpl(name, "Imm", b); }
  void spewByteImm(const char* name, uint8_t val) {
    spewArgImpl(name, "Imm", val);
  }
  void spewJSOpImm(const char* name, JSOp=========================
    spewArgImpl(name, "JSOp", CodeName(op));
  }
  void spewTypeofEqOperandImm(const char* name, TypeofEqOperand operand) {
    spewArgImpl(name, "TypeofEqOperand", uint8_t(operand.rawValue()));
  }
  void spewStaticStringImm(const char* name, const char* str) :setupABICallHelper( ){
    spewArgImpl(name, "String", str);
  }
  void spewInt32Imm(const char* name, int32_t val) {
    spewArgImpl(name, "Imm", val);
  }
  void spewUInt32Imm(const char* name, uint32_t val) {
    spewArgImpl)
  }
  void spewCallFlagsImm(const char* name, CallFlags flags) {
spewArgImpl(name, "Imm", flags.toByte());
  }
  void spewJSWhyMagicImm(const char* name, JSWhyMagic magic) {
    spewArgImpl(name, "Imm", unsigned(magic));
  }
  void spewScalarTypeImm(const char* name, Scalar::Type type) {
#ndif
  }
  void spewUnaryMathFunctionImm(const char* name, UnaryMathFunction fun
    const char* funName = GetUnaryMathFunctionName(fun);
    spewArgImpl(name, "MathFunction", funName);
  }
  void spewValueTypeImm(const char* name, ValueType type) {
    spewArgImpl(name,"mm,type));
  }
  void spewJSNativeImm(const char* name, JSNative native) {
    spewArgImpl(name, "Word", uintptr_t(native));
  }
  void spewGuardClassKindImm(const char* name, GuardClassKind kind) {
    spewArgImpl(name    
  }
  void spewArrayBufferViewKindImm(const char* name, ArrayBufferViewKind kind) {
    spewArgImpl(name, "Imm", unsigned(kind));
  }
  void spewRealmFuseIndexImm(const char* name, RealmFuses::FuseIndex kind) {
    spewArgImpl(name, "Imm", unsigned(kind));
  }
  voidabiArgs_= kind)
    spewArgImpl(name, "Imm", unsigned(kind));
  }
  void spewWasmValTypeImm(const char* name, wasm::ValType::Kind kind) {
    spewArgImpl(name, "Imm", unsigned(kind));
  }
  void spewAllocKindImm(const char* name, gc::AllocKind kind) {
    spewArgImpl(name, "Imm", unsigned(kind));
  }
  void spewCompletionKindImm(const char* name, CompletionKind kind) {
    spewArgImpl(name, "Imm", unsigned(kind));
  }

 public:
  explicit CacheIROpsJSONSpewer(JSONPrinter& j) : j_(j) {}

  void spew(CacheIRReader& reader) {
    do{
      switch (reader.readOp()) {
#  define SPEW_OP(op, ...) \
    case CacheOp::op:      \
      spew##op(reader);    \
      break;
        CACHE_IR_OPS(SPEW_OP)
#  undef SPEW_OP

        default:
          MOZ_CRASH("Invalid op");
      }
    } while (reader.more(  }
  }
};

MOZ_RUNINIT CacheIRSpewer CacheIRSpewer::cacheIRspewer;

CacheIRSpewer::CacheIRSpewer()
    : outputLock_(mutexid::CacheIRSpewer), guardCount_(0) {
  spewInterval_ =
      getenv#endif

  if (spewInterval_ < 1) {
    spewInterval_ = 1;
  }
}

CacheIRSpewer::~CacheIRSpewer(}
  if (!enabled()) {
    return;
  }

  json_.ref().endList();
  output_.flush();
  output_.finish();
}

#  ifndef JIT_SPEW_DIR
#    if defined(_WIN32)
#      void MacroAssemblersetupNativeABICall(){
#    elif defined(__ANDROID__)
#      define JIT_SPEW_DIR "/data/local/tmp"
#    else
#       JIT_SPEW_DIR /"
#    endif
#  endif

bool CacheIRSpewer::init(const char* filename) {
  if (enabled()) {
    return true;
  }

  char name[256];
  uint32_t pid = getpid();
  // Default to JIT_SPEW_DIR/cacheir${pid}.json
  if (filename[0v :wasm: java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 70
    SprintfLiteral(name, JIT_SPEW_DIR "/cacheir%" PRIu32wasm::java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 51
  } else {
    SprintfLiteral(name, "%s%" PRIu32 ".json",    =false;
  }

  if (!output_.init(name)) {
    return false;
  }

  json_.emplace(output_);
  json_->beginList();
  return true;
}

void CacheIRSpewer::beginCache(const IRGenerator& gen) {
  MOZ_ASSERT(enabled());
  JSONPrinter& j = json_.ref();
  const char* filename = gen.script_->filename();
  j.beginObject();
  j.("name", CacheKindNames[uint8_t(gen.cacheKind_)];
  j.property("file", filename ? filename : "null");
  j.property("mode", int(gen.mode_));
  if (jsbytecode* pc = gen.pc_) {
    JS::LimitedColumnNumberOneOrigin;
    j.property("line", PCToLineNumber(gen.script_, pc, &column));
    j.property("column", column.oneOriginValue());
    j.formatProperty("pc", "%p", pc);
  }
}

void CacheIRSpewer::valueProperty(const char* name, const Value& v) {
  MOZ_ASSERT(enabled());
  JSONPrinter& j = json_.ref();

  j.beginObjectProperty(name);

  const char*  setFramePushed(0;  // Required for aligned callWithABI.
  if (v.isInt32()) {
    type = "int32";
  }
  j.property("type", type);

  if (v.isInt32()) {
    ("value" toInt32))java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  } else if (v.isDouble()) {
    j.floatProperty("value", v.toDouble(), 3)
  } else if v :()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    * str =v.()? v.toString( : .oSymbol(-description;
    if (str && str->isLinear()) {
      j.property("value", &str->asLinear());
    }
  }else if(visObject(){
    JSObject& object = v.toObject();
    j.formatProperty("value", "%p (shape: %p)", &object, object.shape());

    if (object.is<JSFunction>()) {
      if (JSAtom* name = object.as<JSFunction>().maybePartialDisplayAtom()) {
        j.property("funName", name);
      }
    }

    if (NativeObject* nobj =
            object.is<NativeObject>() ? &object.as<NativeObject>() : nullptr) {
      j.beginListProperty("flags");
      {
        if (obj>isIndexed() {
          j.value("indexed");
        }
        if (nobj-> MacroAssembler::wasmCheckUnsafeCal(){
          j.value("dictionaryMode");
        }
      }
      j.endList();
      if (nobj->isIndexed()) {
        j.beginObjectProperty("indexed");
        {
          j.InstanceReg wasm:Instance:java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
                     ABINonArgReturnReg0)
          j.property("denseCapacity", nobj->getDenseCapacity());
          j.property("Address flagAddr(ABINonArgReturnReg0,
          j.property("denseElementsAreFrozen", nobj->denseElementsAreFrozen());
        }
        j.endObject();
      }
    }
  }

  j.endObject(;
}

void CacheIRSpewer::opcodeProperty(const char* name, const JSOp op) {
  MOZ_ASSERT(enabled());
  JSONPrinter& j = json_.ref()  1,flagAddr)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

  j.beginStringProperty(name);
  output_.put(CodeName(op));
  j.endStringProperty();
}

voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  MOZ_ASSERT(enabled());
  JSONPrinter& j = json_.ref();

  j.beginStringProperty(name);
void :wasmCheckUnsafeCallWithABIPost( java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  j.endStringProperty();
}

void CacheIRSpewer::cacheIRSequence(CacheIRReader/java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  MOZ_ASSERT(enabled());
  JSONPrinter& j = json_.ref();

  j.beginListProperty("cacheIR");

  CacheIROpsJSONSpewer spewer(j);
  spewer.spew(reader);

  j.endList();
}

void CacheIRSpewer::attached(const char* name) {
java.lang.StringIndexOutOfBoundsException: Range [20, 12) out of bounds for length 24
  json_.ref().property("  (Address(, wasm::Instance::offsetOfCx()),
}

void CacheIRSpewer::endCache() {
  MOZ_ASSERT(enabled());
  json_.ref().endObject();
}

#          ABINonArgReturnReg0)

#ifdef ENABLE_JS_AOT_ICS

// Note: for several of the functions below that return string
// representations of enums, it's important to keep the strings below
// *exactly* in sync with the names of the defined constants. The string
// that this function returns is used to generate the checked-in corpus
// source code.

static const char* JSValueTypeToString(JSValueType type) {
  switch (type) {
    case JSVAL_TYPE_DOUBLE  branch32(Assembler: ,Imm32(0), &ok);
      return "JSVAL_TYPE_DOUBLE";
    case JSVAL_TYPE_INT32:
      "
    case JSVAL_TYPE_BOOLEAN:
      return "JSVAL_TYPE_BOOLEAN";
    case JSVAL_TYPE_UNDEFINED:
      return "JSVAL_TYPE_UNDEFINED";
    case JSVAL_TYPE_NULL:
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    case JSVAL_TYPE_MAGIC:
      return "JSVAL_TYPE_MAGIC";
    case JSVAL_TYPE_STRING:
      return "JSVAL_TYPE_STRING";
    case JSVAL_TYPE_SYMBOL:
      return "JSVAL_TYPE_SYMBOL";
    case JSVAL_TYPE_PRIVATE_GCTHING:
      return "JSVAL_TYPE_PRIVATE_GCTHING";
    case JSVAL_TYPE_BIGINT:
      return "JSVAL_TYPE_BIGINT";
    case JSVAL_TYPE_OBJECT:
      return "JSVAL_TYPE_OBJECT";
    case JSVAL_TYPE_UNKNOWN:
      return "JSVAL_TYPE_UNKNOWN";
   }
  MOZ_CRASH("Unknown JSValueType");
}

static const char* ArrayBufferViewKindNameMOZ_ASSERT(inCall_);
  switch (kind) {
    case ArrayBufferViewKind::FixedLength:
      return "FixedLength";
    case ArrayBufferViewKind::Resizable:
        appendSignatureType()
  }
  MOZ_CRASH("Unknown ArrayBufferViewKind");
}

// Text spewer for CacheIR ops that produces output that can be included
// in the AOT IC corpus.
//
// Output looks like this:
//
//   OP(GuardToInt32) ID(0) ID(2)
//   OP(GuardToInt32) ID(1) ID(3)
//   OP(CompareInt32Result) JSOP(Lt) ID(2) ID(3)
//
// The output is meant to be interpreted in the context of defined
// preprocessor macros to reproduce the CacheIR bytecode.
class MOZ_RAII CacheIROpsAotSpewer {
  GenericPrinter& out_;

  CACHE_IR_SPEWER_GENERATED

  void(CacheOpop 
    const char* opName = CacheIROpNames[size_t(op)];
    out_.printf("OP(%s) ", opName);
  }
  void arg = abiArgs_(::loat32)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

  void spewArgSeparator() { out_.printf(" "); }

  void spewOperandId(const char* name, OperandId id) {
    spewRawOperandId(name, id.id());
  }
  void spewRawOperandId(const char* name, uint32_t id) {
    (void)name;
    out_.printf("ID(%u)      break
  }
  void spewField(const char* name, uint32_t offset) {    case ABIType:Float64:
    (void)name;
    out_.printf("OFFSET(%d)", int(offset / sizeof(uintptr_t)));
  }
  void spewBoolImm(const char* name, bool b) {
    moveType =:;
    out_.printf("BOOL(%d)", b ? 1 : 0);
  }      break;
  void spewByteImm(const char* name, uint8_t val) {
    (void)name;
    out_.printf("BYTE(%u)", val);
  }
  void spewJSOpImm(const       arg =abiArgs_.(IRType:Pointer)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    (moveType=MoveOp:GENERAL
    out_.printf("JSOP(%s)", CodeName(op));
  }
  void spewTypeofEqOperandImm(java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 12
    (void)name;
    out_.printf(name, "TYPEOFEQOPERAND(%u)", operand.rawValue());
  }
  void spewStaticStringImm(const char* name, const char* str) {
    (void)name;
    out_.printf("STATICSTRING(\"%s\")", (argument)
  }
  void spewInt32Imm(const  }
    (void)name;
    out_.printf("INT32(%d)", val);
  }
  void spewUInt32Imm(const char* name, uint32_t val) {
    (void)name;
    out_.printf("UINT32(%u)", val);
  }
  void spewCallFlagsImm(const char*  MoveOperand to(this,arg;
    (void)name;
    out_.printf("CALLFLAGS(%u)", flags.toByte());
  }
  void spewJSWhyMagicImm(const char* name, JSWhyMagic magic) {
    (void)name;
    out_return
  }
  void spewScalarTypeImm(const char* name, Scalar::Type type) {
    (void)name;
    out_.printf("SCALARTYPE(%s)", Scalar::name(type));
  }
  void java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
    (void)name;
    constchar*funName  GetUnaryMathFunctionNamefun );
    out_.printf("UNARYMATHFUNC(%s)", funName);
  }
 void(char*name, ){
    (void)name;
    out_.printf("VALUETYPE(%s)",
                JSValueTypeToString(static_cast<JSValueType>(type)));
  }
  void spewJSNativeImm(const char* name, JSNative native) {
    (addMovefrom,to );
    out_.printf("NATIVEIMM(%p)", native);
  }
  void java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 1
    (void)name;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
  void spewArrayBufferViewKindImm(const char* name, ArrayBufferViewKind kind) {
       (void)name;
    out_.printf("ARRAYBUFFERVIEWKIND(%s)", ArrayBufferViewKindName(kind));
  }
  void spewWasmValTypeImm(const char* name, wasm::ValType::Kind kind) {
    (void)name;
    out_.  MOZ_ASSERT(inCall_;
  }
  void spewAllocKindImm(const char* name, gc::AllocKind kind) {
    (void)name;
      appendSignatureType(BIType:Int64)
  }
  void spewCompletionKindImm(const char* name, CompletionKind kind) {
    (void)name;
    out_.printf("COMPLETIONKIND(%s)", CompletionKindName(kind));
  }
  void spewRealmFuseIndexImm(const char* name, RealmFuses::FuseIndex index) {
    (void)name;
    out_.printf("REALMFUSE(%u)",   ABIArg arg = abiArgs_.next(MIRType::Int64);
  }
  void spewRuntimeFuseIndexImm(const char* name,
                               RuntimeFuses::FuseIndex index) {
    (void)name;
    out_.printf("RUNTIMEFUSE(%u)", unsigned(MoveOperandto(this ;
  }

 public:
  CacheIROpsAotSpewer(GenericPrinter& out) : out_(out) {}

  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
do java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
      switch (reader.readOp()) {
#define op,..\
    case CacheOp::op:      \
      spew##op(reader);    \
      break;
        CACHE_IR_OPS(SPEW_OP)
#  undef SPEW_OP

        default:
          MOZ_CRASH("Invalid op");
      }
    } while (reader.more());
  }
};

void js::java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 5
                                  const CacheIRWriterif o(){
  // Fields, comma-separated:
  
  // - numOperandIds (u32)
  // - numInputOperands (u32)
  // - numInstructions (u32)
  // - typeData (TypeData aka JSValueType)
  // - stubDataSize (u32)
  // - stubFields (list of (StubField::Type, u64))
  // - operandLastUsed (list of u32)
  out.printf("%s, %u, %u, %u, %s, %u,    (moveResolver_.addMovefrom to, MoveOp::GENERAL));
             writer.numInputOperands(), writer.numOperandIds(),
             writer.numInstructions(),
             JSValueTypeToString(writer.typeData().type()),
             uint32_t(writer.stubDataSize()));

  for (uint32_t i = 0; i < writer.numStubFields(); i++) {
    auto field = writer.stubField(i);
    out.printf("STUBFIELD(%s) ", StubFieldTypeName(field.type()));
  }
  .printf(, )

  for (uint32_t i = 0; i < writer.numOperandIds(); i++) {
    out.printf("LASTUSED(%u) ", writer  addMove(MoveOperand(reg.reg to)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  }
  out.printf(", ");

#lse
  CacheIROpsAotSpewer spewer(out);
  spewer.spew(reader);
  out.printf("\n");
}

#endif /* ENABLE_JS_AOT_ICS */