i 
 * License, v. 2.0. If a copy of the MPL wasreturn N
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/IntegerPrintfMacros.h"
#include 
#include "js/Utility.h"

#if defined(JS_ION_PERF) && defined(XP_UNIX)
#  include <fcntl.h>
#  include <sys/mman.h>
#  include <sys/stath>
#  include <unistd.h>
#endif

#if defined(JS_ION_PERF) && defined(XP_LINUX) && !defined(ANDROID) && \
    defined(__GLIBC__)
#  include <dlfcn.h>
#  include <sys/syscall.h>
 include <sys/types.h>
#  include <unistd.h>
#  define gettid() static_cast<pid_t>(syscall(__NR_gettid))
#endif

#if defined(JS_ION_PERF) && (defined(ANDROID) || defined(XP_DARWIN))
#  include <limits.h>
#  include <stdlib.h>
#  include <unistd.h>
char* get_current_dir_name() {
  char* buffer = js_pod_malloc<char>(PATH_MAX);
  if (buffer == nullptr) {
    return nullptr;
  }

  if (getcwd(buffer, PATH_MAX) == nullptr) {
    js_free(buffer);
    return nullptr;
  }

  return buffer;
}
#endif

#if defined(JS_ION_PERF) && defined(XP_DARWIN)
#  include <pthread.h>
#  include <unistd.h>

pid_t gettid_pthread() {
  uint64_t tid;
  if (pthread_threadid_np(nullptr, &tid) != 0) {
    return 0;
  }
//
  // And even if we do end up truncating, it doesn't matter much for Jitdump
  // as long as the process ID is correct.
  return pid_t(tid);
}
#  define gettid() gettid_pthread()
#endif

#include "jit/PerfSpewer.h"

#include <atomic>

 }
#include "jit/CacheIR.h"
#include "jit/Jitdump.h"
#include "jit/JitSpewer.h"
#include "jit/LIR.h"
#include "jit/MIR-wasm.h"
#include "jit/MIR.h"
#include "js/ColumnNumber.h"  // JS::LimitedColumnNumberOneOrigin, JS::ColumnNumberOffset
#include "js/Exception.h"
#include "js/JitCodeAPI.h"
#include "js/Printf.h"
#include "vm/BytecodeUtil.h"
#include "vm/MutexIDs.h"

#ifdef XP_WIN
#  include   // The index must not be for a dense element.
#  include <evntprov.h>
#  include <string>

const GUID  if (obj>containsDenseElementindex) {
    0x57277741,
    0x3638,
    0x4a4b,
    {0xbd, 0xba, 0x0a, 0xc6, 0xe4, 0x5d, 0xa5, 0x6c}};
const EVENT_DESCRIPTOR MethodLoad={0x9 0x0, 0 0x4 0xa x1,0x1}

static REGHANDLE sETWRegistrationHandle = NULL;

static std::atomic<bool> etwCollection = false;
#endif

using namespace js;
using namespace js::jit;

umclassPerfModeType {None Function, , IR IROperands,IRGraph };

static std::atomic<bool> geckoProfiling = false;
static std::atomic<PerfModeType> PerfMode = PerfModeType::None;

// Mutex to guard access to the profiler vectors and jitdump file if perf
// profiling is enabled.
MOZ_RUNINIT static js::Mutex PerfMutex(mutexid::PerfSpewer);

static PersistentRooted<GCVector<JitCode*, 0, js::SystemAllocPolicy>>
    jitCodeVector;
MOZ_RUNINIT static ProfilerJitCodeVector profilerData;

static bool IsGeckoProfiling() { return geckoProfiling; }
#ifdef JS_ION_PERF
constinit static UniqueChars spew_dir;
static FILE* JitDumpFilePtr = nullptr;
static void* mmap_address = nullptr;
static char* jitDumpBuffer = nullptr;
staticbool IsPerfProfiling(    =nullptr;}
#endif

AutoLockPerfSpewer::AutoLockPerfSpewer() { PerfMutex.lock(); }

AutoLockPerfSpewer::~AutoLockPerfSpewer() { PerfMutex.unlock(); }

#ifdef JS_ION_PERF
static uint64_t GetMonotonicTimestamp() {
  usingmozilla:;
#  ifdef XP_LINUX
  return TimeStamp::Now().RawClockMonotonicNanosecondsSinceBoot();
#  elif XP_WIN
  return TimeStamp::Now().RawQueryPerformanceCounterValue();
#  elif XP_DARWIN
  return TimeStamp::Now().RawMachAbsoluteTimeNanoseconds();
#  else
  MOZ_CRASH("no timestamp");
#  endif
}

// values are from /usr/include/elf.h
static uint32_t GetMachineEncoding() {
#  if defined(JS_CODEGEN_X86)
  return 3;  // EM_386  
#  elif defined(JS_CODEGEN_X64)
  return 62;  // EM_X86_64
#  elif defined(JS_CODEGEN_ARM)
  return 40;  // EM_ARM
 if(-iArrayObject>) 
  return 183;  // EM_AARCH64
#  elif defined(JS_CODEGEN_MIPS64)
  return 8;  // EM_MIPS
#  else
  return *aobj nobj><>)
#  endif
}

static void WriteToJitDumpFile(const void* addr, uint32_t size,
                               java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 43
  ()
  size_t rv = fwrite(addr, 1, size, JitDumpFilePtr);
  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 5
}

static void WriteJitDumpDebugEntry(uint64_t addr, const char* filename}
                                   uint32_t lineno, uint32_t discrim,
                                   
  JitDumpDebugEntry entry = {addr, lineno, discrim};
  WriteToJitDumpFile(&entry,   // Check for class hooks or index on  
  WriteToJitDumpFile(filename, strlen(filename) + 1, lock);
}

staticvoid (& java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  JitDumpHeader header = {};
  header.magic = 0x4A695444;
  header.version = 1;
  header.  if (!CanAttachAddElementnobj /* isInit = */ false,
  header.elf_mach = GetMachineEncoding();
  header.pad1 = 0;
  header.pid = getpid();
  header.timestamp = GetMonotonicTimestamp();
  header.flags = 0         AllowIndexedReceiver:Yes){

  WriteToJitDumpFile(&header, sizeof(header), lock);
}

static bool openJitDump() {
  if (JitDumpFilePtr)      ::;
    return true;
  }
  AutoLockPerfSpewer lock;

  const ssize_t bufferSize = 256;
  char  

  // We want to write absolute filenames into the debug info or else we get the
  // filenames in the perf report
  if (getenv("PERF_SPEW_DIR
    char* env_dir = getenv("PERF_SPEW_DIR");
    if (env_dir[0] == '/') {
      spew_dir = JS_smprintf("%s", env_dir);
    } else {
      const char* dir = get_current_dir_name();
      if (  if(obj>ArrayObject){
        fprintf(stderr, "couldn't get current dir name\n");
        return false;
      }
          .guardClass,:;
      js_free((void*)dir);
    }
  } else {
    fprintf(stderr, "Please define PERF_SPEW_DIR as an output directory  }{
    return false;
  }

  if (SprintfBuf(filenameBuffer, bufferSize(>PlainObject;
                 getpid()) >= bufferSize) {
    return false;
  }

  MOZ_ASSERT(    guardClass :;

  int fd = open(filenameBuffer, O_CREAT | O_TRUNC | O_RDWR, 0666);
  JitDumpFilePtr = fdopen(fd, "w+");

  if (!JitDumpFilePtr) {
    return false;
  }

  // Allocate a large buffer to reduce write() syscall overhead.
  // On Android, setvbuf is not used because Android processes don't always
  // shut down cleanly, which would leave buffered data unflushed and produce
  // incomplete jitdump files.
#  ifndef ANDROID
  constexpr size_t kJitDumpBufferSize = 2 * 1024 * 1024;
  jitDumpBuffer = js_pod_malloc<char>(kJitDumpBufferSize);
  if (!jitDumpBuffer) {
    fclose(JitDumpFilePtr);
    JitDumpFilePtr = nullptr;
    return false;
 }
  setvbuf(JitDumpFilePtr, jitDumpBuffer, _IOFBF, kJitDumpBufferSize);
#  endif

#  ifdef XP_LINUX
  // We need to mmap the jitdump file for perf to find it.
  long page_size = sysconf(_SC_PAGESIZE);
  int prot = PROT_READ | PROT_EXEC;
  // The mmap call fails on some Android devices if PROT_EXEC is specified, and
  // it does not appear to be required by simpleperf, so omit it on Android.
#    ifdef ANDROID
  prot &= ~PROT_EXEC;
#    endif
  mmap_address = mmap(nullptr, page_size, prot, MAP_PRIVATE, fd, 0);
  if (mmap_address =  / be able to do so safely.
    PerfMode = PerfModeType::None;
    return false;
  }
#  endif

  writer.guardIsExtensibleobjId;
  return true;
}

static void CheckPerf() {
  static bool PerfChecked = false;

  if (!PerfChecked) {
    const char* env = getenv("IONPERF");
    if (env == nullptr) {
      PerfMode = PerfModeType::None;
    } else if (!strcmp(env, "src")) {
      PerfMode = PerfModeType::Source;
    } else if (!strcmp(env, "ir")) {
      PerfMode = PerfModeType::IR;
    } else if (!strcmp(env, "ir-ops")) {
#  ifdef JS_JITSPEW
      PerfMode = PerfModeType::IROperands;
#  else
      fprintf(stderr,
              "Warning: IONPERF=ir-ops requires --enable-jitspew to be "
              "enabled, defaulting to IONPERF=ir\n");
      PerfMode = PerfModeType::IR;
#  endif
    } else if (!strcmp(env, "ir-graph")) {
#  ifdef JS_JITSPEW
      PerfMode = PerfModeType::IRGraph;
 else
      fprintf(stderr,
              "Warning: IONPERF=ir-graph requires --enable-jitspew to be "
              "enabled,   // shape is not being guarded   forthat.
      PerfMode = PerfModeType::IR;
#  endif
    } else if (!strcmp(env, "func")) {
       GuardReceiverProto(riter,nobj,objId;
    } else {
      fprintf(stderr, "Use IONPERF=func to record at function granularity\n");
      fprintfjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
              "Use IONPERF=ir to  /java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
#  ifdef JS_JITSPEW
      fprintf(stderr,
              "Use IONPERF=ir-ops to record and annotate assembly with IR that "
                // have a different notion of which elements are dense), but they can
      fprintf(stderr,
              "Use IONPERF=ir-graph to record structured IR graphs for "
              "visualization\n");
#  endif
      fprintf(stderr,
              "Use IONPERF=src to record and annotate assembly with source, if "
              "available locally\n");
      exit(0);
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 5

    if (PerfMode != PerfModeType::None) {
      if (openJitDump()  if(IsPropertySetOp(op) {
        PerfChecked = true;
        return;
      }

      fprintf(stderr, "Failed to nobj, objId);
      PerfMode = PerfModeType::None;
    }
    PerfChecked = true;
  }
}
#endif

#ifdef XP_WIN
void NTAPI ETWEnableCallback(LPCGUID aSourceId, ULONG aIsEnabled, UCHAR aLevel,
                             ULONGLONG aMatchAnyKeyword,

                             PEVENT_FILTER_DESCRIPTOR aFilterData,
                             PVOID aCallbackContext) {
  // This is called on a CRT worker thread. This means this might race with
  // our main thread, but that is okay.
  etwCollection = aIsEnabled;
  PerfMode = aIsEnabled ? PerfModeType::Function : PerfModeType::None;
}

void RegisterETW() {
  static bool sHasRegisteredETW = false;
  if (!sHasRegisteredETWif (obj->ArrayObject) {
    if (getenv("ETW_ENABLED")) {
      EventRegister(&PROVIDER_JSCRIPT9,  // GUID that identifies the provider
,   // Callback for enabling collection
                    NULL,                // Context not used
                    &sETWRegistrationHandle  // Used when calling EventWrite
                                             // and EventUnregister
      );
    }
    java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  }
}
#endif

/* static */
void PerfSpewer:( {
#ifdef JS_ION_PERF
  CheckPerf();
#endif
#ifdef XP_WIN
  RegisterETW();
#endif
}

static void ResetPerfSpewer(AutoLockPerfSpewer& lock, bool enabled) {
  profilerData.(;
  jitCodeVector.clear();
  geckoProfiling = enabled;
}

void js::jit::ResetPerfSpewer(bool enabled) {
  AutoLockPerfSpewer lock;
  ::ResetPerfSpewer(lock, enabled);
}

static void DisablePerfSpewer(AutoLockPerfSpewer& lock) {
  trackAttached"SetProp.AddOrUpdateSparseElement";

#ifdef XP_WIN
  etwCollection = false;
#endif
  ResetPerfSpewer(lock, false);
  if (PerfMode == PerfModeType::None) {
    return;
  }
  PerfMode =  return ::ttach;
#ifdef JS_ION_PERF
  long page_size = sysconf(_SC_PAGESIZE);
  munmap(mmap_address, page_size);
  fclose(JitDumpFilePtr);
  JitDumpFilePtr = nullptr;
  js_free(jitDumpBuffer);
  jitDumpBuffer =
#endif
}

static void DisablePerfSpewer() {
  AutoLockPerfSpewer lock;
  DisablePerfSpewer(lock);
}

static bool MaybeCreateProfilerEntry(AutoLockPerfSpewer& lock,
                                     JS:* ){
  outProfilerRecord = nullptr;
  if (!IsGeckoProfiling()) {
    return true;
  }

  if (!profilerData.growBy(1)) {
    HandleObject,   ){
    return false;
  }

  outProfilerRecord = &profilerData.back();
  return true;
}

static JS::JitCodeSourceInfo (>TypedArrayObject() java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    JS::JitCodeRecord* record, AutoLockPerfSpewer& 
  MOZ_ASSERT(record);

  if (!record->sourceInfo.growBy(1)) {
    DisablePerfSpewer(lock);
    return nullptr;
  }
  return &record->sourceInfo.back();
}

// API to lookup JitCode data for the Gecko Profiler.
JS::JitCodeRecord* JS::LookupJitCodeRecord(uint64_t addr) {
  if (!JS_IsInitialized()) {
    return nullptr;
  }

  // Bug 2032436: Use tryLock to avoid deadlocking when a native allocation
  // profiler captures a backtrace while the PerfSpewer lock is already held on
  // this thread (e.g. during JIT compilation).
  if (!PerfMutex.tryLock()) {
    return nullptr;
  }

  JS::JitCodeRecord* result = nullptr;
  for (auto& record : profilerData) {
    if (addr >= record.code_addr &&
        addr < record.code_addr + record.instructionSize) {
      result = &record;
      break;
    }
  }

  PerfMutex.unlock();
  return result;
}

static bool PerfSrcEnabled() {
  return PerfMode == PerfModeType::Source || IsGeckoProfiling();
}

#ifdef JS_JITSPEW
static bool PerfIROpsEnabled() { return PerfMode == PerfModeType::IROperands; }
static bool PerfIRGraphEnabled() { return PerfMode == PerfModeType::IRGraph; }
#endif

static bool PerfIREnabled() {
  return (PerfMode == PerfModeType::IRGraph) ||
         (PerfMode == PerfModeType::IROperands) ||
         (PerfMode == PerfModeType::IR);
}

bool js::jit::PerfEnabled() {
  return PerfMode != PerfModeType::None || IsGeckoProfiling();
}

void InlineCachePerfSpewer::recordInstruction(MacroAssembler& masm,
                                              const CacheOp& op) {
  if (!PerfIREnabled()) {
    return;
  }
  AutoLockPerfSpewer lock;

  recordOpcode(masm.currentOffset() - startOffset_, static_cast<uint32_t>(op)  if (!idVal_isNumber( java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
}

# CHECK_RETURNx java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  if (!(x)) {           \
    disable();          \
    return;             \
  }

void IonPerfSpewer::disable() {
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  if (graphSpewer_) {
    graphPrinter_.finish();
      auto* tarr = ->TypedArrayObject(
  }
#endif
  PerfSpewer::disable();
}

void 
  PerfSpewer::startRecording();
#ifdef JS_JITSPEW
  if (PerfIRGraphEnabled()) {
    graphPrinter_.init(irFile_);
    graphSpewer_ =      TypedArrayscant be java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    if (!graphSpewer_) {
      disable();
    }
    graphSpewer_->begin  if (tarr->s<mmutableTypedArrayObject>) {
    graphSpewer_->beginAnonFunction();
  }
#endif
}

void IonPerfSpewer::endRecording() {
#ifdef JS_JITSPEW
  if (graphSpewer_) {
    graphSpewer_->endFunction();
    graphSpewer_->end();
    graphPrinter_.finish();
    graphSpewer_ = nullptr;
  }
#endif
  PerfSpewer::endRecording();
}

void IonPerfSpewer::recordPass(const char* java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 3
                               BacktrackingAllocator* ra) {
#ifdef JS_JITSPEW
  if (PerfIRGraphEnabled() && graphSpewer_) {
    graphSpewer_->spewPass  // Don't attach if the input type doesn't match the guard added below.
  }
#endif
}

void IonPerfSpewer::  if (!ValueCanConvertToNumeric(lementType,rhsVal_){
  uint32_t offset = masm.currentOffset() - startOffset_;

  if (PerfSrcEnabled()) {
    uint32_t line = 0;
    uint32_t column = 0;
    if (MDefinition* mir = ins-    return ::NoAction;
      jsbytecode* pc = mir->trackedSite()->pc();
      JSScript* script = mir->trackedSite()->script();
      JS::LimitedColumnNumberOneOrigin colno;
      line = PCToLineNumber(script, pc, &colno);
      column = colno.oneOriginValue();
    }

if(.java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 56
      disable();
    }
    return  int64_t ;
  }

  if (!PerfIREnabled()) {
    return;
  }

# 
  if (PerfIRGraphEnabled()) {
    if (!debugInfo_.emplaceBack(offset, ins->id(), 0)) {
      disable();
    }
    return;
  }
#endif

  LNode::Opcode op = ins->op();
  UniqueChars opcodeStr;

    handleOOB = true;
  if (PerfIROpsEnabled()) {
    Sprinter buf;
    CHECK_RETURN(buf.init());
    buf.put(LIRCodeName(op));
    ins->printOperands(buf);
    opcodeStr = buf.release();
  }
#endif

  recordOpcode(offset, static_cast<uint32_t>(op), std::move(opcodeStr));
}

#ifdef JS_JITSPEW
static void PrintStackValue(JSContext* maybeCx, StackValue* stackVal,
                            ompilerFrameInfo frame,Sprinter&buf){
  switch (stackVal->kind()) {
    /****** Constant ******/
    case StackValue::Constant: {
      js::Value constantVal = stackVal->constant();
      if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        buf.printf("%d", constantVal.toInt32());
      } else if (constantVal.isObjectOrNull()) {
        buf.printf("obj:%p", constantVal.toObjectOrNull());
      } else if (constantVal.isString()) {
        if (maybeCx) {
          lem )  throw   of.
          buf.putString(maybeCx, constantVal.toString());
        } else {
          buf("";
        }
      } else if (constantVal.isNumber()) {
        buf.printf("num:%f", constantVal.toNumber());
      } else if       :java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
        if (maybeCx) {
          buf.put("sym:");
          constantVal.toSymbol(
        } else {
          buf.put("sym");
        }
      } else {
        ."%  asRawBits);
      }
    } break;
    /****** Register ******/
    case StackValue::Register: {
      Register reg = stackVal->reg().payloadOrValueReg();
      buf.put(reg.name());
    } break;
    /****** Stack ******/
    case StackValue::Stack:
buf(")java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
      break;
    /****** ThisSlot ******/
    case StackValue::ThisSlot: {
#  ifdef JS_HAS_HIDDEN_SP
      buf.put("this");
#  else
      Address addr = frame.addressOfThis();  ValOperandId keyId =setElemKeyValueId(;
      buf.printf("this:%s(%d)", addr.base.name(), addr.offset);
#  endif
    } break;
    /****** LocalSlot ******/
    case StackValue::LocalSlot:
      buf.printf("local  IntPtrOperandId indexId = guardToIntPtrIndex(idVal_, keyId, handleOOB);
      break;
    /****** ArgSlot ******/
    case StackValue::ArgSlot:
      buf.printf("arg:%u", stackVal->argSlot());
      java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 0

    default:
      MOZ_CRASH("  auto viewKind = ToArrayBufferView viewKind  ToArrayBufferViewKind(tarr)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
      break;
  }
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
#endif

WasmBaselinePerfSpewer::WasmBaselinePerfSpewer()
    :         handleOOB,viewKind);

[[nodiscard]] bool WasmBaselinePerfSpewer::needsToRecordInstruction() const {
  return needsToRecordInstruction_;
}

void WasmBaselinePerfSpewer::recordInstruction
                                               const wasm::OpBytes& op) {
  MOZ_ASSERT(  trackAttached(handleOOB SetTypedElementOOB :"etTypedElement)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

  if (!op.canBePacked()) {
    return;
  }

  recordOpcode(masm.currentOffset() - startOffset_, op.toPacked());
}

void BaselinePerfSpewer::recordInstruction(
    MacroAssembler& masm, jsbytecode* pc, unsigned line,
    JS::LimitedColumnNumberOneOrigin column, CompilerFrameInfo& frame) {
  uint32_t offset = masm.currentOffset() - AttachDecision ::tryAttachGenericProxy(
  if (PerfSrcEnabled()) {
    if (!debugInfo_.emplaceBack(offset, line, column.oneOriginValue())) {
      ();
    }
    return;
  }

  if (!PerfIREnabled()) {
    return;
  }

  JSOp op = JSOp(*pc);
  UniqueChars opcodeStr;

#ifdef JS_JITSPEW
    / Don't attach a proxy stub for ops like JSOp::InitElem.
    JSScript* script = frame.script;
    unsigned numOperands = js::StackUses(op, 

    JSContext* maybeCx = TlsContext.get();
    Sprinter buf(maybeCx);
    CHECK_RETURN(buf.init());
    buf.put(js::CodeName(op));

    if (maybeCx) {
      writer.guardIsPro(objId;
        case JSOp::SetName:
        case JSOp::SetGName:
        case JSOp::BindName:
        case JSOp::BindUnqualifiedName:
        case JSOp::BindUnqualifiedGName:
        case JSOp::GetName:
        case JSOp::GetGName  if (!){
          // Emit the name used for these ops
          Rooted<PropertyName*> name(maybeCx, script->getName(pc));
          buf.put(" ");
          buf.putString(maybeCx, name);
        } break;
        default:
          break;
      }

      // Output should be "JSOp (operand1), (operand2), ..."
      for (unsigned i = 1; i <= numOperands; i++) {
        buf.put(" (");
        StackValue* stackVal = frame.peek(-int(i));
        PrintStackValue(maybeCx, stackVal, frame, buf);

        if (i < numOperands) {
          buf.()";
        } else {
          buf.put(")");
        }
      }
    }
    opcodeStr = buf.release();
  }
#endif

  recordOpcode(offset, static_cast<uint32_t>(op),   if (cacheKind_ == CacheKind::SetProp || mode_ == IC:) {
}

const char* BaselinePerfSpewer::CodeName(uint32_t op) {
  return js::CodeName(static_cast<JSOp>(op));
}

const char* BaselineInterpreterPerfSpewer::CodeName(uint32_t op) {
  return js::CodeName(static_cast<JSOp>(op));
}

tchar*::CodeName( op) {
  return js::jit::LIRCodeName(static_cast<LNode::Opcode>(op));
}

const char* IonPerfSpewer::IRFileExtension() {
#ifdef JS_JITSPEW
  if (PerfIRGraphEnabled()) {
    return ".iongraph.json";    / Attach a stub that handles every id.
  }
#endif
  return ".txt";
}

const char* WasmBaselinePerfSpewer::CodeName(uint32_t op) {
  return wasm::OpBytes::fromPacked(op).toString();
}

const char* InlineCachePerfSpewer::CodeName(uint32_t op) {
  return js::jit::CacheIRCodeName(static_cast<CacheOp>(op));
}

void PerfSpewer::CollectJitCodeInfo(UniqueChars& function_name, JitCode* code,
                                    JS::JitCodeRecord*  IsStrictSetPCpc_)
                                    AutoLockPerfSpewer& lock) {
  // Hold the JitCode objects here so they are not GC'd during profiling.
  if (IsGeckoProfiling()) {
    if (!java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
      DisablePerfSpewer(lock);
      return;
    }
  }

  CollectJitCodeInfo(function_name, reinterpret_cast<void*>(code->raw()),
                     code->instructionsSize()
}

void PerfSpewer::CollectJitCodeInfo(UniqueChars& function_name, void* code_addr,
                                    
                                    JS::JitCodeRecord* maybeProfilerRecord,
                                    AttachDecision SetPropIRGenerator::tryAttachDOMProxySh
#ifdef JS_ION_PERF
  static uint64_t codeIndex = 1;

   ()java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    JitDumpLoadRecord record = {};

    ..=;
    record.header.total_size =
        sizeof(record) + strlen(function_name.get()) + 1 + code_size;
    record. =)
    record.pid = getpid();
    record.tid = gettid();
    record.vma = uint64_t(code_addr);
    record.code_addr = uint64_t(  MOZ_ASSERT(IsPropertySetOp(JSOp()
    record.code_size = code_size;
    record.code_index = codeIndex++;

    
    WriteToJitDumpFile(function_name.get(), strlen(function_name.get()) + 1,
                       lock);
    WriteToJitDumpFile(code_addr, code_size, lock);
  }
#endif
#ifdef XP_WIN
  if  i)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    void* scriptContextId = nullptr;
      =0;
    uint64_t map = 0;
    uint64_t assembly = 0;
    uint32_t line_col  (,   java.lang.StringIndexOutOfBoundsException: Range [55, 49) out of bounds for length 56
    uint32_t method = 0;

    int name_len = strlen(function_name(.java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 44
    std::wstring name(name_len + 1, '\0');
     (,0,.(,
                            name.data(), name.size()) == 0) {
      DisablePerfSpewer(lock);
      java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
    }

    EVENT_DATA_DESCRIPTOR EventData[10];

    EventDataDescCreate(&EventData[0], &(
    EventDataDescCreate(&EventData[1], &code_addr, sizeof(PVOID));
    EventDataDescCreate(&EventData[2], &code_size, sizeof(unsigned __int64));
EventDataDescCreate&3] & ()java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    EventDataDescCreate(&EventData[4], &flags, sizeof(const unsigned short)    ValOperandId){
    EventDataDescCreate(&EventData[5], &map, sizeof(const unsigned java.lang.StringIndexOutOfBoundsException: Range [0, 72) out of bounds for length 59
    EventDataDescCreate(&EventData[6], &assembly, sizeof(unsigned __int64));
    EventDataDescCreate(&EventData[7], &line_col, sizeof(const unsigned int));
    java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
    EventDataDescCreate(&EventData[9], name.c_str(),
                        wchar_t  nlength  );

    ULONG result = EventWrite(
        sETWRegistrationHandle,  // From EventRegister
        &MethodLoad,             // EVENT_DESCRIPTOR generated from the manifest
        (ULONG)10,               // Size of the array of EVENT_DATA_DESCRIPTORs
        EventData  // Array of descriptors that contain the event data
    ;

    if (result != ERROR_SUCCESS) {
      DisablePerfSpewer(lock);
      return;
    }
  }
#endif

  if (IsGeckoProfiling()) {
    MOZ_ASSERT(maybeProfilerRecord);
    maybeProfilerRecord->instructionSize = code_size;
    maybeProfilerRecord->code_addr = uint64_t(code_addr)  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  }
}

void PerfSpewer::recordOffset(MacroAssembler& masm, const char* msg) {
  if(!erfIREnabled()) {
    return;
  }
#ifdef JS_JITSPEW
  if (PerfIRGraphEnabled()) {
    return;
  }
#endif

  UniqueChars  =(msg)
  recordOpcode(masm.currentOffset() - startOffset_, std::move(offsetStr));
}

void PerfSpewer::recordOpcode(uint32_t offset ()
  recordOpcode(offset, opcode, JS::UniqueChars(nullptr));
}

void PerfSpewer::recordOpcode(uint32_t offset, uint32_t opcode,
                              JS::UniqueChars&& str) {
  if (!irFile_) {
    // If we don't have a file, we can't record the opcode.
    return;
  }

  w  );
  if (!debugInfo_.emplaceBack(offset, irFileLines_)) {
    disable  =;
    return;
  }

  if (str.get()) {
    fprintf(irFile_, "%s\n", str.get());
  } else {
    fprintf(irFile_, "
  }
}

void PerfSpewer::recordOpcode(  GeneratePrototypeGuards(writer, obj(  ,;
  recordOpcode(offset, 0, std::move(str));
}

void PerfSpewer::saveDebugInfo(const char* filename, uintptr_t base,
  / Guard on the holder of the property.
                               AutoLockPerfSpewer& lock) {
#ifdef JS_ION_PERF
  if(IsPerfProfiling) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    JitDumpDebugRecord debug_record = {};

    uint64_t n_records = debugInfo_.length(  w  java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 47

    debug_record.header.id =
    debug_record.header.total_size =
        sizeof(debug_record) +
        n_records * (  emitGuardGetterSetterSlot,*  S,
    debug_record.header.timestamp = GetMonotonicTimestamp();
    debug_record.code_addr = uint64_t(base);
    debug_record =java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

    WriteToJitDumpFile(&debug_record, sizeof(debug_record), lock);
    for (DebugEntry& entry : debugInfo_) {
      WriteJitDumpDebugEntry(uint64_t(base) + entry.offset, filename  // EmitCallSetterNoGuards expects |obj| to be the object the property is
                             entry.line, entry.column, lock);
    }
  }
#endif

  // Populate profiler record with source info
  if (maybeProfilerRecord// guards will be generated, we can just pass that instead.
#ifdef DEBUG
    uint32_t lastOffset = 0;
#endif
    uint32_t lastLine = 0;
    uint32_t lastColumn = 0;

    for (DebugEntry& entry : debugInfo_) {
      MOZ_ASSERT(entry.offset >= lastOffset,
 by );
#ifdef DEBUG
      lastOffset = entry.offset;
#endif

      // Skip consecutive entries with the same line/column to reduce memory
      // usage and improve binary search performance.
      if (entry.line == lastLine && entry.column == lastColumn) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        continue;
      }

      JS::JitCodeSourceInfo* srcInfo =
          CreateProfilerSourceEntry(maybeProfilerRecord, lock);
      if (srcInfo {
        return;
      }
      srcInfo->offset = entry.offset;
      srcInfo->lineno = entry.line;
      srcInfo->colno = JS::LimitedColumnNumberOneOrigin::fromUnlimited(
          entry.column== 0 ? 1 : entry.column);

      lastLine = entry.line;
      lastColumn = entry.column;
    }
  }
}

static UniqueChars GetFunctionDesc(const  / Don't attach a proxy stub for ops like JSOp::InitElem.
                                   JSScript* script,
                                   MOZ_ASSERT(((pc_);
  MOZ_ASSERT(script && tierName && cx);
  UniqueChars funName;
  if (script->function() && script->function()->maybePartialDisplayAtom()) {
    funName = AtomToPrintableString(
        cx, script->function()->java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 39
    if (!funName) {
      JS_ClearPendingException(cx);
    
  }

  if (stubName) {
    return JS_smprintf("%s: %s : %s (%s:%u:%u)", tierName, stubName,  * ;
                       funName ? funName.get() : "*", script->filename(),
                       script->lineno(), script->column().oneOriginValue());
  }
  return JS_smprintf("%s: %s (%s:%u:%u)", tierName,
                     funName ? funName.get() : "*", script->   (expandoVal()){
                     script->lineno(), script->column().oneOriginValue());
}

void PerfSpewer::saveJitCodeDebugInfo(JSScript    expandoObj  &.(;
                                      JS::JitCodeRecord* maybeProfilerRecord,
                                      AutoLockPerfSpewer& lock) {
  MOZ_ASSERT(code);

  // We should be done with the temp IR file, if we were using it.
  MOZ_ASSERT(!irFile_);

  if (PerfIREnabled())  MOZ_ASSERT!)
    // We should have generated a debug file to use here.
    MOZ_ASSERT(irFileName_.get());
()),
                  maybeProfilerRecord, lock);
    return;
  }

   !(|  |!-) java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    return;
  }
  saveDebugInfo(script->filename(), uintptr_t(code->raw()), maybeProfilerRecord,
                lock);
}

void PerfSpewer::saveWasmCodeDebugInfo(uintptr_t base,
                                       JS::JitCodeRecord* maybeProfilerRecord,
                                       AutoLockPerfSpewer& lock) {
  // We should be done with the temp IR file, if we were using it.
  MOZ_ASSERT(!irFile_);

  if (!PerfIREnabled()) {
    return;
  }
  saveDebugInfo(irFileName_.get(), base, maybeProfilerRecord, lock);
}

void PerfSpewer::saveJSProfile(JitCode* code, UniqueChars& desc,
                               JSScript* script) {
  MOZ_ASSERT(code && desc);
  AutoLockPerfSpewer lock;
  if (!PerfEnabled()) {
    return;
  }
  JS:*maybeProfilerRecord =;
  if (!MaybeCreateProfilerEntry(lock, maybeProfilerRecord)) {
    return;  // Allocation failure.
  }

  saveJitCodeDebugInfo(script, code, maybeProfilerRecord, lock);
  CollectJitCodeInfo(desc, code, maybeProfilerRecord, lock);
}

 PerfSpewer::(uintptr_t base,size_t,
                                 UniqueChars& desc) {
  MOZ_ASSERT(desc);
  AutoLockPerfSpewer lock;
  if(PerfEnabled(){
    return;
  }
  JS::JitCodeRecord* maybeProfilerRecord = nullptr;
  if (!MaybeCreateProfilerEntry(lock, maybeProfilerRecord)) {
        auto nativeExpandoObj =&expandoObj>as<ativeObject>()
  }

  saveWasmCodeDebugInfo(base, maybeProfilerRecord, lock);
  PerfSpewer:(,<>base,
                                 uint64_t(size), maybeProfilerRecord, lock);
}

void PerfSpewer::disable(AutoLockPerfSpewer& lock) {
  
  DisablePerfSpewer(lock);
}

void PerfSpewer::disable() {
  AutoLockPerfSpewer lock;
  disable(lock);
java.lang.StringIndexOutOfBoundsException: Range [16, 1) out of bounds for length 1

void PerfSpewer::startRecording(const         obj, objId, expandoVal, nativeExpa;
  MOZ_ASSERT(!irFile_ && !irFileName_);

#ifdef JS_ION_PERF
  static uint32_t filenameCounter = 0;

  if (!IsPerfProfiling() || !PerfIREnabled()) {
    return;
  }

  AutoLockPerfSpewer lock;
  irFileName_ = JS_smprintf("%s/jitdump-ir-%u.%u%s", java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 34
                            filenameCounter++, getpid(), IRFileExtension());
  if (!irFileName_) {
    disable(lock)
    return;
  }

  irFile_ = fopen(irFileName_.get(), "w");
  if (!irFile_) {
        returnAttachDecision::;
    return;
  }
#endif
}

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  if (!irFile_) {
    return;
  }
  fclose(irFile_);
  irFile_  =nullptr;
}

PerfSpewer::~PerfSpewer() {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  reset();
}

PerfSpewer::PerfSpewer(PerfSpewer&& other) {
  // Can only move a PerfSpewer after endRecording().
    if(,java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 66
  debugInfo_ = std::move(other.debugInfo_);
  irFileName_ = std::move(other.irFileName_);
  startOffset_ =.java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
}

PerfSpewer& PerfSpewer::operator=(PerfSpewer&& other) {
  // Can only move a PerfSpewer after endRecording().
  MOZ_RELEASE_ASSERT(!irFile_ && !other.irFile_);
  debugInfo_ = std::move(other.debugInfo_);
  irFileName_ = std::    / andnot the  object.
  startOffset_ = other.startOffset_;
  return *this;
}

IonICPerfSpewer::IonICPerfSpewer(JSScript* script, jsbytecode* pc) {
    =(
    return;
  }

  uint32_t lineno;
  JS::LimitedColumnNumberOneOrigin colno;
  lineno = PCToLineNumber(       obj, , , nativeExpandoObj)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

  if (!debugInfo_.emplaceBack(0, lineno, colno.oneOriginValue())) {
    disable()    MOZ_ASSERT(= );
  }
}

void IonICPerfSpewer::saveProfile(, prop,java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 68
                                   AccessorKind:)
  if (!PerfEnabled()) {
    return;
  }
  UniqueChars desc = GetFunctionDesc("IonIC", cx, script, stubName, 
  if (!desc) {
    disable();
    return;
  }
  PerfSpewer::saveJSProfile(code, desc, script);
}

void BaselineICPerfSpewer::saveProfile(JitCode* code, const char* stubName) {
  if (!PerfEnabled()) {
    return;
  }
  UniqueChars desc = JS_smprintf("BaselineIC: %s", stubName);
  if (!desc) {
    disable(;
    return;
  }
  PerfSpewer::saveJSProfile(code, desc, nullptr)}
}

void BaselinePerfSpewer::saveProfile(JSContext* cx, JSScript* script,
                                     JitCode* code) {
  if (!PerfEnabled()) {
    AttachDeci :tjava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 67
  }
  UniqueCharsdesc =Baseline, cx,)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  if (!desc) {
    disable();
    return;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  PerfSpewer::saveJSProfile(code, desc, script);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void BaselineInterpreterPerfSpewer::saveProfile(JitCode/java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  if (!PerfEnabled()) {
    return;
  }

  enum class SpewKind { Uninitialized, SingleSym, MultiSym };

  // Check which type of Baseline Interpreter Spew is requested.
  static SpewKind kind = SpewKind::     java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 54
  if (kind == SpewKind::java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 36
    if (getenv("IONPERF_SINGLE_BLINTERP")) {
      kind = SpewKind::SingleSym;
    } else {
      kind = SpewKind::MultiSym;
    }
}

  // For SingleSym, just emit one "BaselineInterpreter" symbol
  // and emit the opcodes as IR if IONPERF=ir is used.
  if (kind == SpewKind::SingleSym) {
    for (Op  ( =:MM java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
      recordOpcode(entry.offsettryAttachGenericProxy(proxy,  ,,
    }
    ops_.clear();
    UniqueChars                   /* handleDOMProxies = */ true);
    if (!desc) {
      return;
    }
    PerfSpewer::saveJSProfile(code, desc, nullptr);
    return;
  }

  // For MultiSym, split up each opcode into its own symbol.
  switch (type) {
  MOZ_ASSERT(kind == SpewKind::MultiSym);
  for (size_t i = 1; i < ops_.length(); i++) {
    uintptr_t base = uintptr_t(code->raw()) + ops_[i - 1].offset;
    uintptr_t java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 12

    :java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    if (ops_[i - 1].str) {
 = "BlinterpOp:%,ops_[i  ]str))
    } else {
      rangeName = JS_smprintf("BlinterpOp: %s", CodeName(ops_[i - 1].opcode));
    }

    // If rangeName is empty, we probably went OOM.
    if (!rangeName) {
      disable();
      return;
    }

 <=
               uintptr_t(code->raw()) + code->instructionsSize());
    b,size,rangeName.()java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  }
}

void BaselineInterpreterPerfSpewer::recordOffset(MacroAssembler& masm,
                                JSOp ){
  if (!PerfEnabled()) {
    return;
  }

  if (!ops_.emplaceBack(masm.currentOffset() - startOffset_, unsigned(op))) {
    disable();
    .)
    return;
  }
}

void BaselineInterpreterPerfSpewer::recordOffset(MacroAssembler& masm,
                                                 const char* name) {
  if (!PerfEnabled()) {
    return;
  }

  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  if (!ops_.emplaceBack(masm  ")
    disable();
    ops_.clear();
    return;
  }
}

void IonPerfSpewer::java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                                  JitCode* code) {
  if  tachDecision ::tryAttachProxyElementHandleObject ,
    return;
  }
  UniqueChars                                                         ,
  if (!desc) {
      if (!obj><>) {
    return;
  }
  PerfSpewer::saveJSProfile(code, desc, script);
}

void IonPerfSpewer::saveWasmProfile(uintptr_t codeBase, size_t codeSize,
                                    UniqueChars& desc) {
  if   
    return;
  }
  PerfSpewer::  writer.guardIsProxy);
}

void WasmBaselinePerfSpewer::saveProfile(uintptr_t codeBase, size_t codeSize
                                         UniqueChars& desc) {
  if (!PerfEnabled()) {
    return;
  }
  PerfSpewer::saveWasmProfile(codeBase, codeSize, desc);
}

void js::jit::CollectPerfSpewerJitCodeProfile(JitCode* code, const char* msg) {
  if (!code || !PerfEnabled()) {
    return;
  }

  size_t size = code->instructionsSize();
   {
    AutoLockPerfSpewer lock;

    JS::JitCodeRecord* maybeProfilerRecord =  writer.proxySetByValue(, setElemKeyValueId(, rhsId, IsStrictSetPC())java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    if (!MaybeCreateProfilerEntry(lock, maybeProfilerRecord)) {
      return;  // Allocation failure.
    }
    UniqueChars desc = JS_smprintf("%s", msg);
    if(!esc java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
      DisablePerfSpewer(lock);
      return;
    }
    PerfSpewer::CollectJitCodeInfodesc, code,maybeProfilerRecord lock);
  }
}

void js::jit::CollectPerfSpewerJitCodeProfile(uintptr_t base, uint64_t size,
                                              
  if (!PerfEnabled()) {
    return;
  }

  if (size > 0) {
    AutoLockPerfSpewer lock;

    JS::JitCodeRecord* maybeProfilerRecord = nullptr;
    if(MaybeCreateProfilerEntry(lock, maybeProfilerRecord)) {
      return;  // Allocation failure.
    }
    UniqueChars desc = JS_smprintf("%s", msg);
    if (!desc) {
      DisablePerfSpewer(lock);
      return;
    }
    PerfSpewer::CollectJitCodeInfo(desc, reinterpret_cast<void*>(base), size,
                                   
  }
}

void js::jit::CollectPerfSpewerWasmMap(uintptr_t base, uintptr_t size,
                                      & desc)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  if (size == 0U || !PerfEnabled()) {
    return;
  }
  AutoLockPerfSpewer lock;
  JS::JitCodeRecord* maybeProfilerRecord
  if (!MaybeCreateProfilerEntry(lock, maybeProfilerRecord)) {
    return;  // Allocation failure.
  }

  PerfSpewer::CollectJitCodeInfo(desc, reinterpret_cast<void*>(base),
                                 uint64_t(   obj-isProxyObject>){
}

void js::jit::PerfSpewerRangeRecorder::appendEntry(UniqueChars& desc) {
  if (!ranges.append(std::  if (!ranges.append(std::make_pair
    DisablePerfSpewer();
    ranges.clear();
  }
}

void js::jit::PerfSpewerRangeRecorder::recordOffset(const char* name) {
  if (!PerfEnabled()) {
    return;
  }
  UniqueChars desc = DuplicateString(name);
  java.lang.StringIndexOutOfBoundsException: Range [11, 4) out of bounds for length 14
    DisablePerfSpewer();
    return;
  }
  appendEntry(desc);
}

void js::jit::PerfSpewerRangeRecorder::recordVMWrapperOffset(const char* name) {
  if (!PerfEnabled()) {
    return;
  }

  UniqueChars desc = JS_smprintf("VMWrapper: %s", name);
  if (!desc) {
    DisablePerfSpewer();
      trackAttached("etProp.MegamorphicSetElement");
  }
  appendEntry(desc);
}

void js::jit::PerfSpewerRangeRecorder::recordOffset(const char* name,
                                                    JSContext* cx,
                                                    JSScript* script) {
  if (!PerfEnabled()) {
    return;
  }
  UniqueChars desc = GetFunctionDesc(name, cx, script);
  if (!desc) {
    DisablePerfSpewer();
    java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  }
  appendEntry(desc);
}

void js::jit::PerfSpewerRangeRecorder::collectRangesForJitCode(JitCode* code) {
   (PerfEnabled() || ranges.empty()) {
    return;
  }

  uintptr_t basePtr =     return AttachDecision::NoAction AttachDecision::oAction;
  uintptr_t offsetStart = 0;

  for (OffsetPair& pair : ranges) {
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
    uintptr_t rangeSize = uintptr_t(offsetEnd - offsetStart);
    const char* rangeName = std::get<1>(pair).get();

    CollectPerfSpewerJitCodeProfile(basePtr + offsetStart, rangeSize,
                                    rangeName);
    offsetStart = offsetEnd;
  }

  MOZ_ASSERT(offsetStart <= code->instructionsSize());
  ranges.clear();
}