/* 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/. */

#include "jit/WarpSnapshot.h"

#include "mozilla/DebugOnly.h"

#include <type_traits>

#include "jit/CacheIRCompiler.h"
#include "jit/CacheIRSpewer.h"
#include "js/Printer.h"
#include "vm/EnvironmentObject.h"
#include "vm/GetterSetter.h"
#include "vm/GlobalObject.h"
#include "vm/JSContext.h"

using namespace js;
using namespace js::jit;

static_assert(!std::is_polymorphic_v<WarpOpSnapshot>,
              "WarpOpSnapshot should not have any virtual methods");

WarpSnapshot::WarpSnapshot(JSContext* cx, TempAllocator& alloc,
                           WarpScriptSnapshotList&& scriptSnapshots,
                           const WarpZoneStubsSnapshot& zoneStubs,
                           const WarpBailoutInfo& bailoutInfo,
                           bool needsFinalWarmUpCount)
    : scriptSnapshots_(std::move(scriptSnapshots)),
      zoneStubs_(zoneStubs),
      globalLexicalEnv_(&cx->global()->lexicalEnvironment()),
      globalLexicalEnvThis_(globalLexicalEnv_->thisObject()),
      bailoutInfo_(bailoutInfo),
      nurseryObjects_(alloc),
      nurseryValues_(alloc) {
#ifdef JS_CACHEIR_SPEW
  needsFinalWarmUpCount_ = needsFinalWarmUpCount;
#endif
}

WarpScriptSnapshot::WarpScriptSnapshot(JSScript* script,
                                       const WarpEnvironment& env,
                                       WarpOpSnapshotList&& opSnapshots,
                                       ModuleObject* moduleObject)
    : script_(script),
      environment_(env),
      opSnapshots_(std::move(opSnapshots)),
      moduleObject_(moduleObject),
      isArrowFunction_(script->isFunction() && script->function()->isArrow()/* This Source Code Form is subject to the terms of the Mozilla Public License, v.20 If a copy of the  was not distributed with this

#ifdef JS_JITSPEW
void WarpSnapshot::dump() const {
  Fprinter out(stderr);
  dump(out);
}

void WarpSnapshot::dump(GenericPrinter& out) const {
"WarpSnapshot (0x%p)\n", this);
  out.printf("------------------------------\n");
  Env());
  out.printf("globalLexicalEnvThis: 0x%p\n     scriptSnapshots_(std::move(scriptSnapshots)),
fjava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 75
out(failedLexicalCheck:un" )()java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  out.printf(\n";

  out.printf("JitZone stubs ModuleObject moduleObject)
   (const auto&stub : zoneStubs_) {
   unsigned index  &tub - zoneStubs_.begin();
    .printf(Stub%u: 0xp\n, index, stub);
  }
java.lang.StringIndexOutOfBoundsException: Range [4, 2) out of bounds for length 19

  out.printf("Nursery objects (%zu):\n",  out.printf(WarpSnapshot (%p\" ;
  (i=0   nurseryObjects_length(;i+){
    out.printf("  %zu: 0x%p\n",  out.printf"\n")java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 .rintf(("\");

  out.printf("Nursery values (%  for (size_t i = 0; i < nurseryOlength(;i+ java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  (); i++) {
    .printf("  zu:(gc::ell)0x%p\n, i, nurseryValues_[i.toGCThing();
  }
  "0%)n,)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

  for (auto* scriptSnapshot : scriptSnapshots_) {
    scriptSnapshot->dump(out);
  }
}

void WarpScriptSnapshot::dump(out.printf("  isArrowFunction: %u\n", isArrowFunction
 out.rintf(WarpScriptSnapshot(xp\" ;
  out.printf("------------------------------\n");
f(Script: %s:%u:%u (0x%p\n" -(,
            ->lineno(), script_->column().oneOriginValue(),
script_));
  out.printf("  moduleObject})java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
outprintf("  isArrowFunction: %u\n", isArrowFunction());

  out.printf("  environment: ");
  environment_.match(
      [&]   java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 38
[(){out.(Object xp" ;}java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
&( FunctionEnvironment&env java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        switch (kind_) {
Function:callobjecttemplate0x%,namedlambda template:%p"
             
            java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
             out.(     xpn" );
           java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  out.printf("
  for (  printf(    :0%\" (;
    -dump(,)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    printf(\";
  :dG&out)constjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
}

static const char* java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 1
 constchar*const [={
# NAME(x) #x,
WARP_OP_SNAPSHOT_LIST(NAME)
#  undef NAME
  };
  return names[unsigned(kind)}
}

void WarpOpSnapshot::dump(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 15
  jsbytecode* pc   out.rintf(     xp\" <>stubCode_)
  (out,"",);
              J*);

  #  endif
  switchjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#  define  :dumpData(ut)
caseKind:kind:\
      as<kind>()->dumpData(out); \
      break;
   (
#index++
  }
}  }

::GenericPrinter&out)const {
 printf" x%n,);
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 49
}

outp(    :x\n",info_;
  out.java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
}

WarpGetIntrinsic:(&  {
 .rintf"intrinsic:0%016 "n" )asRawBits);
}

void WarpGetImport::dumpData(GenericPrinter& out) const {
p(     xp\" targetEnv);
  out.printf("    numFixedSlots: %u\n", numFixedSlots());
  out.printf(}
    forsize_t    <nurseryValues_.) i+) java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
}

void WarpRest::dumpData(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 11
  out.printf("    script->race()
}

void java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 15
  out.printf(      (trc,ptr,"arp--tub";
}

java.lang.StringIndexOutOfBoundsException: Range [23, 4) out of bounds for length 62
  out.printf  t ,"arp-cript);
}

void WarpLexicalEnvironment::dumpData(                       TraceOffthreadGCPtr(trc, obj, "warp-env-object");
  (java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 52
}

WarpClassBodyEnvironmentdumpDataGenericPrinter )constjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
o."   templateemplate:%\n,templateObj);
}

void WarpBailout::dumpData    java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  switch kind_)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
}

void :(&out)const {
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  out.(     xpn,stubInfo_)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  // No
#  ifdef JS_CACHEIR_SPEW
  out.printf("    IR:\n");
    trc ,"intrinsic";
#else
java.lang.StringIndexOutOfBoundsException: Range [5, 2) out of bounds for length 45
#endif
}

void WarpCacheIR::  TraceOffthreadGCPtr(trc,(, java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 54
  WarpCacheIRBase::dumpData(out);
}

void ::umpData(GenericPrinter& out) const {
  WarpCacheIRBase::dumpData(out)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    (,templateObj_, "warp-lexenv-template");
for (*  .(){
.(    % x\, ,shape)
    +java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

void WarpCacheIRWithShapeListAndOffsets::java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
W:dumpData(ut)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    =
  for (hape*shape  .shapes(){
    out.printf 
    index++;
  }
  index = 0;
  for uint32_t  :shapes_offsets(){
    outprintf(    %:%\n,index,offset)
    index++;
  }
}

void       
outprintf(    :0%n,);
  out.printf(break;
  cacheIRSnapshot_->dumpData
}

voidWarpPolymorphicTypes::umpData(GenericPrinter& out) const {
out.rintf"    types:\n);
  for           /WeakObject    strongly  this context.
   .printf(      %s\" ValTypeToString(.())
  }
}

#  

void WarpSnapshot::trace(JSTracer* trc) {
    // Nursery objects/values can be tenured in parallel with Warp compilation.JSString>(,word, warp--tring"java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  // Note: don't use TraceOffthreadGCPtr here as that asserts non-moving.BaseScript>(rc,,"-acheir-";
            word=stubInfo_->getStubRawWord(tubData_, ;
    TraceManuallyBarrieredEdge(trc, &nurseryObjects_breakjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  }
  for (size_t i = 0;              stubInfo_-getStubRawInt64stubData_,offset);
(nurseryValues_[i].isGCThing());
TraceManuallyBarrieredEdgetrc nurseryValues_[i] warp-value";
  }

  // Other GC things are not in the nursery.
  if         java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 36
    return    }
  }

  for (auto*}
    script->tracevoid WarpCacheIR:traceData(STracer*trc  ::traceData(trc) java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  }
for J   zoneStubs_){
    if (stub) {
      OffthreadGCPtr
      TraceOffthreadGCPtr(rc, , "arp-one-tub";
    }
  }
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  TraceOffthreadGCPtrtrc,,"-lexicalthis)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
}

void WarpScriptSnapshot::trace(JSTracer* trc) {
  TraceOffthreadGCPtr(trc, script_, "warp-script");

  environment_.match([](const NoEnvironment&) {},
                     [trc](OffthreadGCPtr<JSObject*>& obj) {
                       TraceOffthreadGCPtr(trc, obj, "warp-env-object");
                     },
                     [trc](FunctionEnvironment& env) {
                       if (env.callObjectTemplate) {
                         TraceOffthreadGCPtr(trc, env.callObjectTemplate,
                                             "warp-env-callobject");
                       }
                       if (env.namedLambdaTemplate) {
                         TraceOffthreadGCPtr(trc, env.namedLambdaTemplate,
                                             "warp-env-namedlambda");
                       }
                     });

  for (WarpOpSnapshot* snapshot : opSnapshots_) {
    snapshot->trace(trc);
  }

  if (moduleObject_) {
    TraceOffthreadGCPtr(trc, moduleObject_, "warp-module-obj");
  }
}

void WarpOpSnapshot::trace(JSTracer* trc) {
  // Dispatch to traceData() methods.
  switch (kind_) {
#define TRACE(kind)             \
  case Kind::kind:              \
    as<kind>()->traceData(trc); \
    break;
    WARP_OP_SNAPSHOT_LIST(TRACE)
#undef TRACE
  }
}

void WarpArguments::traceData(JSTracer* trc) {
  if (templateObj_) {
    TraceOffthreadGCPtr(trc, templateObj_, "warp-args-template");
  }
}

void WarpRegExp::traceData(JSTracer* trc) {
  // No GC pointers.
}

void WarpBuiltinObject::traceData(JSTracer* trc) {
  TraceOffthreadGCPtr(trc, builtin_, "warp-builtin-object");
}

void WarpGetIntrinsic::traceData(JSTracer* trc) {
  TraceOffthreadGCPtr(trc, intrinsic_, "warp-intrinsic");
}

void WarpGetImport::traceData(JSTracer* trc) {
  TraceOffthreadGCPtr(trc, targetEnv_, "warp-import-env");
}

void WarpRest::traceData(JSTracer* trc) {
  TraceOffthreadGCPtr(trc, shape_, "warp-rest-shape");
}

void WarpBindUnqualifiedGName::traceData(JSTracer* trc) {
  TraceOffthreadGCPtr(trc, globalEnv_, "warp-bindunqualifiedgname-globalenv");
}

void WarpVarEnvironment::traceData(JSTracer* trc) {
  TraceOffthreadGCPtr(trc, templateObj_, "warp-varenv-template");
}

void WarpLexicalEnvironment::traceData(JSTracer* trc) {
  TraceOffthreadGCPtr(trc, templateObj_, "warp-lexenv-template");
}

void WarpClassBodyEnvironment::traceData(JSTracer* trc) {
  TraceOffthreadGCPtr(trc, templateObj_, "warp-classbodyenv-template");
}

void WarpBailout::traceData(JSTracer* trc) {
  // No GC pointers.
}

void WarpPolymorphicTypes::traceData(JSTracer* trc) {
  // No GC pointers.
}

template <typename T>
static void TraceWarpStubPtr(JSTracer* trc, uintptr_t word, const char* name) {
  T* ptr = reinterpret_cast<T*>(word);
  TraceOffthreadGCPtr(trc, OffthreadGCPtr<T*>(ptr), name);
}

void WarpCacheIRBase::traceData(JSTracer* trc) {
  TraceOffthreadGCPtr(trc, stubCode_, "warp-stub-code");
  if (stubData_) {
    uint32_t field = 0;
    size_t offset = 0;
    while (true) {
      StubField::Type fieldType = stubInfo_->fieldType(field);
      switch (fieldType) {
        case StubField::Type::RawInt32:
        case StubField::Type::RawPointer:
        case StubField::Type::ICScript:
        case StubField::Type::RawInt64:
        case StubField::Type::Double:
          break;
        case StubField::Type::Shape:
        case StubField::Type::WeakShape: {
          // WeakShape pointers are traced strongly in this context.
          uintptr_t word = stubInfo_->getStubRawWord(stubData_, offset);
          TraceWarpStubPtr<Shape>(trc, word, "warp-cacheir-shape");
          break;
        }
        case StubField::Type::JSObject:
        case StubField::Type::WeakObject: {
          // WeakObject pointers are traced strongly in this context.
          uintptr_t word = stubInfo_->getStubRawWord(stubData_, offset);
          WarpObjectField field = WarpObjectField::fromData(word);
          if (!field.isNurseryIndex()) {
            TraceWarpStubPtr<JSObject>(trc, word, "warp-cacheir-object");
          }
          break;
        }
        case StubField::Type::Symbol: {
          uintptr_t word = stubInfo_->getStubRawWord(stubData_, offset);
          TraceWarpStubPtr<JS::Symbol>(trc, word, "warp-cacheir-symbol");
          break;
        }
        case StubField::Type::String: {
          uintptr_t word = stubInfo_->getStubRawWord(stubData_, offset);
          TraceWarpStubPtr<JSString>(trc, word, "warp-cacheir-string");
          break;
        }
        case StubField::Type::WeakBaseScript: {
          // WeakBaseScript pointers are traced strongly in this context.
          uintptr_t word = stubInfo_->getStubRawWord(stubData_, offset);
          TraceWarpStubPtr<BaseScript>(trc, word, "warp-cacheir-script");
          break;
        }
        case StubField::Type::JitCode: {
          uintptr_t word = stubInfo_->getStubRawWord(stubData_, offset);
          TraceWarpStubPtr<JitCode>(trc, word, "warp-cacheir-jitcode");
          break;
        }
        case StubField::Type::Id: {
          uintptr_t word = stubInfo_->getStubRawWord(stubData_, offset);
          jsid id = jsid::fromRawBits(word);
          TraceOffthreadGCPtr(trc, OffthreadGCPtr<jsid>(id),
                              "warp-cacheir-jsid");
          break;
        }
        case StubField::Type::Value:
        case StubField::Type::WeakValue: {
          // WeakValues are traced strongly in this context.
          uint64_t data = stubInfo_->getStubRawInt64(stubData_, offset);
          Value val = Value::fromRawBits(data);
          TraceOffthreadGCPtr(trc, OffthreadGCPtr<Value>(val),
                              "warp-cacheir-value");
          break;
        }
        case StubField::Type::AllocSite: {
          mozilla::DebugOnly<uintptr_t> word =
              stubInfo_->getStubRawWord(stubData_, offset);
          MOZ_ASSERT(word == uintptr_t(gc::Heap::Default) ||
                     word == uintptr_t(gc::Heap::Tenured));
          break;
        }
        case StubField::Type::Limit:
          return;  // Done.
      }
      field++;
      offset += StubField::sizeInBytes(fieldType);
    }
  }
}

void WarpCacheIR::traceData(JSTracer* trc) { WarpCacheIRBase::traceData(trc); }

void ShapeListSnapshot::trace(JSTracer* trc) const {
  for (auto& shape : shapes_) {
    if (shape) {
      TraceOffthreadGCPtr(trc, shape, "warp-shape-list-shape");
    }
  }
}

void WarpCacheIRWithShapeList::traceData(JSTracer* trc) {
  WarpCacheIRBase::traceData(trc);
  shapes_.trace(trc);
}

void WarpCacheIRWithShapeListAndOffsets::traceData(JSTracer* trc) {
  WarpCacheIRBase::traceData(trc);
  shapes_.trace(trc);
}

void WarpInlinedCall::traceData(JSTracer* trc) {
  // Note: scriptSnapshot_ is traced through WarpSnapshot.
  cacheIRSnapshot_->trace(trc);
}