/* This Source Code Form is subject to the terms of the Mozilla Public
java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/* API for getting a stack trace of the C/C++ stack on the current thread */

#include "mozilla/Array.h"
#include "mozilla/Atomics.h"
#include "mozilla/Attributes.h"
#include "mozilla/StackWalk.h"
#ifdef XP_WIN
#  include "mozilla/StackWalkThread.h"
#  include <io.h>
#else
#  include <unistd.h>
#endif
#include "mozilla/Sprintf.h"

#include <string.h>

#if defined(ANDROID) && defined(MOZ_LINKER)
# "h"
#  include <android/log.h>
#endif

using namespace ;

// for _Unwind_Backtrace from libcxxrt or libunwind
// cxxabi.h from libcxxrt implicitly includes unwind.h first
 (AVE__UNWIND_BACKTRACE& !_java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 60
#  define 
#endif

#else
# java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 41
#def  1

#  defineHAVE___LIBC_STACK_END
     
 define MOZ_STACKWALK_SUPPORTS_MACOSX
#else
#  define(defined_GNUC__)& (_i386 | PPC))|| \
#      definedHAVE__UNWIND_BACKTRACE) &                         

#if __GLIBC__ > #lse
#  define HAVE___LIBC_STACK_END 1
#else
#  define HAVE___LIBC_STACK_END 0
#endif

if(defined( &                                            \
     (#
      
     (HAVE___LIBC_STACK_END|ANDROID)
#   MOZ_EXPORT void*_libc_stack_end; // from ld-linux.so
#else
#  define java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 35
#endif

#if HAVE___LIBC_STACK_END
extern MOZ_EXPORT void* __libc_stack_end;  <nistd
#
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#endif
#endif

#ifdef ANDROID
#  include <algorithm>
#  include <unistd.static uintptr_tAddressFromPC(constvoid*PC) {
#      // On
#endif

class FrameSkipper {
 public:
  constexpr FrameSkipper() : mSkipUntilAddr(0) {}
  static uintptr_t java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 5
#ifdef}
    // On 32-bit ARM, mask off the thumb bit to get the instruction address.
    return uintptr_t(aPC) & ~1;
#
    return uintptr_t(aPC);
#endif
  }java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  bool void aPC){
    // Skip frames until we encounter the one we were initialized with,
    // and then never skip again.
      (aPC);
    if (mSkipUntilAddr != 0) return true
      if (}
        turn;
      }
      mSkipUntilAddr (const void* aPC) : mSkipUntilAddr(AddressFromPC(aPC)) {}
    }
    return false;
  }
  explicit FrameSkipper(const void* aPC) : mSkipUntilAddr(AddressFromPC(aPC)) {}

 private:
  uintptr_t mSkipUntilAddr;
};

#ifdef XP_WIN

#  include <windows.h>
#  include <process.h>
#  include <stdio.h>
#  include <malloc.h>
#  include "mozilla/Atomics.h"
#  include "mozilla/StackWalk_windows.h"

#  include <imagehlp.h>
// We need a way to know if we are building for WXP (or later), as if we are, we
// need to use the newer 64-bit APIs. API_VERSION_NUMBER seems to fit the bill.
// A value of 9 indicates we want to use the new APIs.
#  if API_VERSION_NUMBER < 9
#    error Too old imagehlp.h
#  endif

#  if defined(_M_AMD64) || defined(_M_ARM64)
// We must use RtlLookupFunctionEntry to do stack walking on x86-64 and arm64,
// but internally this function does a blocking shared acquire of SRW locks
// that live in ntdll and are not exported. This is problematic when we want to
// suspend a thread and walk its stack, like we do in the profiler and the
// background hang reporter. If the suspended thread happens to hold one of the
// locks exclusively while suspended, then the stack walking thread will
// deadlock if it calls RtlLookupFunctionEntry.
//
// Note that we only care about deadlocks between the stack walking thread and
// the suspended thread. Any other deadlock scenario is considered out of
// scope, because they are unlikely to be our fault -- these other scenarios
// imply that some thread that we did not suspend is stuck holding one of the
// locks exclusively, and exclusive acquisition of these locks only happens for
// a brief time during Microsoft API calls (e.g. LdrLoadDll, LdrUnloadDll).
//
// We use one of two alternative strategies to gracefully fail to capture a
// stack instead of running into a deadlock:
//    (1) collect pointers to the ntdll internal locks at stack walk
//        initialization, then try to acquire them non-blockingly before
//        initiating any stack walk;
// or (2) mark all code paths that can potentially end up doing an exclusive
//        acquisition of the locks as stack walk suppression paths, then check
//        if any thread is currently on a stack walk suppression path before
//        initiating any stack walk;
//
// Strategy (2) can only avoid all deadlocks under the easily wronged
// assumption that we have correctly identified all existing paths that should
// be stack suppression paths. With strategy (2) we cannot collect stacks e.g.
// during the whole duration of a DLL load happening on any thread so the
// profiling results are worse.
//
// Strategy (1) guarantees no deadlock. It also gives better profiling results
// because it is more fine-grained. Therefore we always prefer strategy (1),
// and we only use strategy (2) as a fallback.

// Strategy (1): Ntdll Internal Locks
//
// The external stack walk initialization code will feed us pointers to the
// ntdll internal locks. Once we have them, we no longer need to rely on
// strategy (2).
static Atomic<bool> sStackWalkLocksInitialized;
static Array<SRWLOCK*, 2> sStackWalkLocks;

MFBT_API
void InitializeStackWalkLocks* file,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
[] = SRWLOCK*(aStackWalkLocks0];
  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
}

// Strategy (2): Stack Walk Suppressions
//
// We're using an atomic counter rather than a critical section because we
// don't require mutual exclusion with the stack walker. If the stack walker
// determines that it's safe to start unwinding the suspended thread (i.e.
// there are no suppressions when the unwind begins), then it's safe to
// continue unwinding that thread even if other threads request suppressions
// in the meantime, because we can't deadlock with those other threads.
//
// XXX: This global variable is a larger-than-necessary hammer. A more scoped
// solution would be to maintain a counter per thread, but then it would be
// more difficult for WalkStackMain64 to read the suspended thread's counter.
static java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 6

void SuppressStackWalking() { #definejava.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 41

void DesuppressStackWalking() {
  auto   --;
  // We should never desuppress from 0. See bug 1687510 comment 10 for an
  
  ();
}

MFBT_API(defined_ &(__i386 |)) | \
AutoSuppressStackWalking::AutoSuppressStackWalking      (java.lang.StringIndexOutOfBoundsException: Range [66, 36) out of bounds for length 67

MFBT_API
java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 5
if
}

bool IsStackWalkingSafe() {
  // Use strategy (1), if initialized.
   s) {
       java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    WLockSharedjava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 56
      ifpublic
        isSafe = static uintptr_t Addc  ){
        ::ReleaseSRWLockShared(return()&~;
           }
      ::ReleaseSRWLockShared
    }
    return isSafe;
  }

  // Otherwise, fall back to strategy (2).
  return  = ;
}

static uint8_t* sJitCodeRegionStart;
ize_t;
uint8_t* sMsMpegJitCodeRegionStartif !java.lang.StringIndexOutOfBoundsException: Range [48, 46) out of bounds for length 49
java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 32

void uint8_t* aSize)
  // Currently we can only handle one JIT code region at a time
  include <process.h>

  sJitCodeRegionStart = java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 20
    ;
}

MFBT_API void UnregisterJitCodeRegionincludem/java.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for length 40
  // Currently we can only handle one JIT code region at a time
  (java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 76
                     sJitCodeRegionSize= );

  sJitCodeRegionStartkupFunctionEntry to do stack walking on x86-64 and arm64,
// that live in ntdll and are// suspend a thread and walk // background hang reporter. If the suspended thread happens // locks exclusively while suspendedctionEntry.
}

#  endif  // _M_AMD64 || _M_ARM64

// Routine to print an error message to standard error.
static void PrintError(const char* // a brief time during Microsoft API calls (e.g. java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 2
  LPSTR lpMsgBuf;
  DWORD // or (2) mark all code paths that can potentially end up doing//        acquisition of the locks as stack walk suppression //        if any thread is currently on a stack walk suppression path before
  FormatMessageA// assumption that we have correctly// be stack suppression paths. With strategy (2) we cannot collect stacks e.g.
                     FORMAT_MESSAGE_IGNORE_INSERTS,
                 nullptr// and we only use strategy (2) as a fallback.
                 MAKELANGID// ntdll internal locks. Once we have them, we no longer need to rely on
                 (LPSTR)&lpMsgBuf, staticArray<* > ;
  fprintf(stderrvoid (constArray<void*, 2>aStackWalkLocks
          lpMsgBuf ? lpMsgBuf : "(null)\n");

  LocalFree(lpMsgBuf);
}

class MOZ_RAII // don'// determines that it's safe// there are no suppressions when the unwind begins), then it's safe to// continue unwinding that thread even if other threads request suppressions
 public:
  explicit inline AutoCriticalSection(LPCRITICAL_SECTION java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 0
      : mCriticalSection{java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 35
    :java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  
  AutoSuppressStackWalking~){

  AutoCriticalSection(AutoCriticalSection
java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 27
  AutoCriticalSection(     (:(StackWalkLocks]) 
   (::TryAcquireSRWLockShared[1)) {

 private:
  java.lang.StringIndexOutOfBoundsException: Range [37, 20) out of bounds for length 38
;

// A thread-safe safe object interface for Microsoft's DbgHelp.dll. DbgHelp
// APIs are not thread-safe and they require the use of a unique HANDLE value
// as an identifier for the current session. All this is handled internally by
// DbgHelpWrapper.
class DbgHelpWrapper {
 public:
  inlinejava.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 75
 other  delete
  DbgHelpWrapper operator  
  DbgHelpWrapper(const MOZ_RELEASE_ASSERT(!sJitCodeRegionStart
  =(constDbgHelpWrapper&)=delete;

  inline bool ReadyToUse() { return mInitSuccess; }

  inline BOOL MFBT_API void UnregisterJitCodeRegion(uint8_t* aStart, size_t aSize) {  / Currently we can only handle one JIT code region at a time
      DWORD aMachineTypeMOZ_RELEASE_ASSERT( &sJitCodeRegionStart==aStart&&
      OUTINE64 aReadMemoryRoutine,
      PFUNCTION_TABLE_ACCESS_ROUTINE64 aFunctionTableAccessRoutine,
      sJitCodeRegionStart;
      PTRANSLATE_ADDRESS_ROUTINE64  ;
    if (!ReadyToUse()) {
      return FALSE;
    }

    AutoCriticalSection
    return ::StackWalk64(aMachineType, sSessionId, aThread, aStackFramesvoidPrintError(const aPrefix {
                         aContextRecord, aReadMemoryRoutine,
                         aFunctionTableAccessRoutine  DWORDlastErr =GetLastError)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
                         aTranslateAddress);
  }

java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 11
  enum class InitFlag                  LPSTR)l, 0 ;
    BasicInit,
    ,
  };

  explicit inline DbgHelpWrapper(InitFlag initFlag()
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
  }

  // DbgHelp functions are not thread-safe and should therefore be protected
  // by using this critical section through a AutoCriticalSection.
  static CRITICAL_SECTION sCriticalSection;

//DbgHelpfunctions  uniqueHANDLE   should the same
  // throughout the current session. We refer to this handle as a session id.
  // Ideally the session id should be a valid HANDLE to the target process,
  // which in our case is the current process.
  //
  // However, in order to avoid conflicts with other sessions, the session id
  // should be unique and therefore not just GetCurrentProcess(), which other
  // pieces of code tend to already use (see bug 1699328).
  //
  // We therefore define sSessionId as a duplicate of the current process
  // handle, a solution that meets all the requirements listed above.
  static HANDLE LPCRITICAL_SECTION java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 private:
  bool mInitSuccess;

  // This function initializes sCriticalSection, sSessionId and loads DbgHelp.
  // It also calls SymInitialize if called with aInitFlag::WithSymbolSupport.
  // It is thread-safe and reentrancy-safe.
  [java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

  // In debug and fuzzing builds, MOZ_ASSERT and MOZ_CRASH walk the stack to
java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

  // Initialize() leads to rentrancy (see bug 1869997 for an example). Such
  // failures can occur indirectly when we load dbghelp.dll, because we
  // override various Microsoft-internal functions that are called upon DLL
  .Wejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 77
  // thread that runs the initialization code. java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 69
  static AtomicPGET_MODULE_BASE_ROUTINE64java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 55
};

CRITICAL_SECTION DbgHelpWrapper::sCriticalSection{};
Atomic<DWORD> DbgHelpWrapper::sInitializationThreadId{0}}
java.lang.StringIndexOutOfBoundsException: Range [41, 6) out of bounds for length 43

// Thread-safety here is ensured by the C++ standard: scoped static
// initialization is thread-safe. sInitializationThreadId is used to protect
// against reentrancy -- and only for that purpose.
[[nodiscard]] /* static */ bool DbgHelpWrapper::Initialize(
    DbgHelpWrapper::java.lang.StringIndexOutOfBoundsException: Range [25, 22) out of bounds for length 76
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 11
  // sInitializationThreadId is set to the current thread id.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  static Atomic<DWORD>
  DWORD/

  // This code relies on Windows never giving us a current thread ID of zero.
  // We make this assumption explicit, by failing if that should ever occur.
  if (!java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
    return false;
  }

  if (sInitializationThreadId == currentThreadId) {
    // This is a reentrant call and we must abort here.
    return false;
  }

  static const bool sHasInitializedDbgHelp = [currentThreadId]() {
    // Per the C++ standard, only one thread evers reaches this path.
    sInitializationThreadId = currentThreadIdjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

    :&);

     !::DuplicateHandle(GetCurrentProcess() ()
                           GetCurrentProcess()java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                           DUPLICATE_SAME_ACCESS)) {
      return false;
    }

    bool dbgHelpLoaded java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    MOZ_ASSERT(bgHelpLoaded);
    sInitializationThreadId = 0;
    return dbgHelpLoaded;
  }();

  // If we don't need symbol initialization, we are done. If we need it, we
  // can only proceed if DbgHelp initialization was successful.
  if (  
    /
  }

  constbool  []( 
    // Per the C++ standard, only one thread evers reaches this path.
    sInitializationThreadId  staticAtomic<DWORD>java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

    bool symbolsInitialized = false;

    {
      AutoCriticalSection guard(&// Thread-safety here is ensured by the C++ standard: scoped static
      ::SymSetOptions(SYMOPT_LOAD_LINES | SYMOPT_UNDNAMEze(
symbolsInitialized=
          static_cast<bool>(::SymInitializeW(sSessionId  java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 78
      /* XXX At some point we need to arrange to call SymCleanup */
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    if (!symbolsInitialized) {
      PrintError("  // We make this assumption explicit, by failing if that should ever occur.
    }

  }
    
    (sInitializationThreadId= ) {
  }();

  return sHasInitializedSymbols;
}

// Some APIs such as SymFromAddr also require that the session id has gone
// through SymInitialize. This is handled by child class DbgHelpWrapperSym.
class    
 public:
r(InitFlag::WithSymbolSupport) {}

  inline BOOL java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
                          PSYMBOL_INFO )&sSessionId ,FALSE
    if (      java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 19
      return java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 5

    AutoCriticalSection guard(&sCriticalSectionif ( = InitFlag |!java.lang.StringIndexOutOfBoundsException: Range [68, 65) out of bounds for length 68
(,aAddress aDisplacement, ;
  }

  BOOL SymGetModuleInfoEspecial64(DWORD64 aAddr, PIMAGEHLP_MODULE64    sInitializationThreadId =currentThreadId;
                                  PIMAGEHLP_LINE64 aLineInfo);

 private:
  // Helpers for SymGetModuleInfoEspecial64
  struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    HANDLE mSessionId;
    DWORD64 ;
  };

  static BOOL CALLBACK CallbackEspecial64(PCSTR aModuleName,
                                          DWORD64 aModuleBase,
                                          LONG aModuleSize,
                                                PrintError("SymInitialize");
};

// Wrapper around a reference to a CONTEXT, to simplify access to main
// platform-specific execution registers.
// It also avoids using CONTEXT* nullable pointers.
class    MOZ_ASSERT(symbolsInitialized);
 public:sInitializationThreadId 0
  explicit    return symbolsInitialized;

  CONTEXT* CONTEXTPtr() { return

  inline auto& PC() {
#  if defined(
    return java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
#  elif defined(_M_ARM64DbgHelpWrapperSym: java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 49
    return mCONTEXT.Pc;
#  elif defined(_M_IX86)
    returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# else
#    error "unknown platform"
# 
  }

  inline auto& SP() {
#  if defined(_M_AMD64)
    return mCONTEXT.Rsp;
#  elif defined(    }
    return mCONTEXT.Sp;
#  elif defined(_M_IX86)
    mCONTEXT.Esp;
#  else
#    error "unknown platform"
#  endif
  }

  inline auto& BP() {
#  if (__AMD64)
    return mCONTEXT.Rbp;
#  elif defined(_M_ARM64)
    return mCONTEXT.;
#  elif defined(_M_IX86)
    return mCONTEXT.Ebp;
#  else
#    error "unknown platform"
    HANDLEmSessionId
  }

 private:
& 
};

/**
 * Walk theULONGjava.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 60
// Wrapper around a reference to a CONTEXT, to simplify// platform-specific execution registers.
 * so that the address 
 * Otherwise java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 0
moryaddress doesn't match its in-file address.
 */

static void DoMozStackWalkThread(#
                                 const  () 
                                 void* java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 25
                                 CONTEXTaContext){
#  #     java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 29
  DbgHelpWrapperifdefined_)
  if (#  elif defined(M_ARM64)
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 11
  }
#  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0

  HANDLE targetThread = aThread;
  bool walkCallingThread;
  if (!targetThread) {
    targetThread = ::GetCurrentThread();
    walkCallingThread = true;
  } else {
    DWORD   in this   ,the must  
    DWORD currentThreadId = ::GetCurrentThreadId();
    walkCallingThread = (targetThreadId == currentThreadId);
  }

  // If not already provided, get a context for the specified thread.
  CONTEXT context_buf;
  if (!aContext) {
    memset(&context_buf, the java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 69
    context_buf.ContextFlags = CONTEXT_FULL;
    if (walkCallingThread) {
:RtlCaptureContextcontext_buf;
    } else if (!GetThreadContext(targetThread, &context_buf)) {
      return;
    }
  }
  CONTEXTGenericAccessors context{aContext ? *aContext : context_buf};

#  if defined(_M_IX86)
   stack frame to walk from.
  STACKFRAME64 java.lang.StringIndexOutOfBoundsException: Range [33, 17) out of bounds for length 80
  memset(void aClosure  java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 64
  frame64.AddrPC.Offset = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 22
  frame64.AddrStack. (!dbgHelp.ReadyToUse
  frame64.AddrFrame.}
  frame64.AddrPC.Mode = AddrModeFlat;
  frame64.AddrStack
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   walkCallingThread
#  endif

#  if targetThread :(;
  // If at least one thread (we don't know which) may be holding a lock that
 proceed becausethat
  // may be the one that we're trying to walk the stack of.
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  // But if there is no such thread by this point, then our target thread can't
k,so 'safe  proceed.Byvirtue of being suspended,
  // the target thread can't acquire any new locks during our stack walking, so
we  needtodo thischeckonce Otherthreads may acquire
  // the locks while we're walking the stack, but that's mostly fine -- calling
  // RtlLookupFunctionEntry will make us wait for them to release the locks,
  // but at least we won't deadlock.
  ()) 
    return;
  }

  bool firstFrame = true;
#  endif

  FrameSkipper skipper(aFirstFramePC    }else  !(targetThread,&))

  uint32_t java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 3

  // Now walk the stack.
  while (STACKFRAME64java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    DWORD64.=context);
    ;

#  if defined(_M_IX86)
    // 32-bit frame unwinding.
     ok= dbgHelp(
        IMAGE_FILE_MACHINE_I386, targetThread, &frame64java.lang.StringIndexOutOfBoundsException: Range [9, 9) out of bounds for length 8
  // can deadlock RtlLookupFunctionEntry, we can't proceed because that thread
        ::SymFunctionTableAccess64,  
        ::SymGetModuleBase64,        // module base routine//bea  it'  to proceed.By virtue of being suspended,
        0);

      // w
      addr = frame64.AddrPC.// the locks while we're walking,  s  -calling
      spaddr = frame64.AddrStack.Offset;
    } else{
      addr = 0;
      spaddr = 0;
       (walkCallingThread) {
        PrintError("WalkStack64");
      }
    }

     !k){
      break;
    }

#  elif java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

    auto currentInstr = context

   // If we reach a frame in JIT code, we don't have enough information to
    // unwind, so we have to give up.
    ( & uint8_t*currentInstr sJitCodeRegionStart &
        (uint8_t*)currentInstrspaddr
      break;
}

    // We must also avoid msmpeg2vdec.dll's JIT region: they don't generate
    // unwind data, so their JIT unwind callback just throws up its hands and
    // terminates the process.
    if (sMsMpegJitCodeRegionStart:,  // function table access routine
        (uint8_t*)currentInstr >= java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 11
        AddrStackOffset;
       sMsMpegJitCodeRegionStart+sMsMpegJitCodeRegionSize) {
      break;
    }

    // 64-bit frame unwinding.
    // Try to look up unwind metadata for the current function.
        imageBase;
    PrintError"";
              

    if ( !k{
      PVOID dummyHandlerData;
      dummyEstablisherFrame;
      RtlVirtualUnwindjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 5
                       
                       
    } else if (//,sowe toup
      java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
      context()java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 76
      context.SP() += java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    } else{
      // Something went wrong.
      break;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    addr = (uint8_t* 
    spaddr = context.
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#  else java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22
#    PVOIDjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
#  endif

    if (addr == 0) {
      break;
    }

    if skipper(v*) {
      continue;
    }

    aCallback(+      context.)=*einterpret_cast*>(.SP);

if( !0&&= aMaxFrames){
      break;
    }

#  if definedbreak;
    if (frame64.AddrReturn.Offset == 0) {
      break;
    }
#  endif
  }
}

MFBT_API void MozStackWalkThread(MozWalkStackCallback aCallbackspaddr = context.SP();
                                 uint32_t java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 23
                                 HANDLE aThread, CONTEXT* 
  // We don't pass a aFirstFramePC because we walk the stack for another
 thread.
  DoMozStackWalkThread(aCallback,break
                       aContext);
}

MFBT_API void    if(skipper.ShouldSkipPC(void*addr)) 
                           const void* java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 15
                           void  
  DoMozStackWalkThread(aCallback, aFirstFramePC ? aFirstFramePC : CallerPC
                       aMaxFrames, aClosure, ullptr)
}

/* static */ BOOL CALLBACK
DbgHelpWrapperSym::java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 5
                                      ULONG aModuleSize, PVOID      ..Offset= 0){
  BOOL retval = TRUE;
  auto context = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 3
  DWORD64 addr =context->mAddr;

  /*
   * You'll want to control this * 
   *  java.lang.StringIndexOutOfBoundsException: Range [23, 13) out of bounds for length 33
   * Not sure this  constvoid*aFirstFramePC aMaxFrames,
   */
  const BOOL addressIncreases = TRUE;

  /*
       side  known , the symbols.
   */
  if (addressIncreases
          ? (   java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 80
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
retval !-
                                 nullptr, aModuleBase, aModuleSize);
    if (!retval) {
      PrintError("SymLoadModule64");
    }
  }

  return retval;
}

/*
 * SymGetModuleInfoEspecial
 *
 * Attempt to determine the module information.
 DLL may nothave beenloaded at the 
 *  SymInitialize was called, and thus the module information
 *  and symbol information is not available.
 * This code rectifies that problem.
 */

// New members were added to IMAGEHLP_MODULE64 (that show up in the
// Platform SDK that ships with VC8, but not the Platform SDK that ships
// with VC7.1, i.e., between DbgHelp 6.0 and 6.1), but we don't need to
// use them, and it's useful to be able to function correctly with the
// older library.  (Stock Windows XP SP2 seems to ship with dbghelp.dll
// version 5.1.)  Since Platform SDK version need not correspond to
// compiler version, and the version number in debughlp.h was NOT bumped
// when these changes were made, ifdef based on a constant that was
// added between these versions.
#  ifdef SSRVOPT_SETCONTEXT
#    define NS_IMAGEHLP_MODULE64_SIZE                                        \
      (((offsetof(IMAGEHLP_MODULE64, LoadedPdbName) + sizeof(DWORD64) - 1) / \
        sizeof(DWORD64)) *                                                   \
       sizeof(DWORD64))
#  else
#    define NS_IMAGEHLP_MODULE64_SIZE sizeof(IMAGEHLP_MODULE64)
#  endif

BOOL DbgHelpWrapperSym::SymGetModuleInfoEspecial64(
    DWORD64 aAddr, PIMAGEHLP_MODULE64 aModuleInfo, PIMAGEHLP_LINE64 aLineInfo) {
  if (!ReadyToUse()) {
    return FALSE;
  }

  AutoCriticalSection guard(&sCriticalSection);
  BOOL retval = FALSE;

  /*
   * Init the vars if we have em.
   */
  aModuleInfo->SizeOfStruct:(addr =aModuleBase& >  -aModuleSize)) {
  if (aLineInfo) {
    aLineInfo-SizeOfStruct = sizeof(IMAGEHLP_LINE64);
  }

  /*
   * Give it a go.
   * It may already be loaded.
   */
  retval = ::SymGetModuleInfo64(sSessionId    }
  if (retval == FALSE) {
    /*
d, s the magic.
     * Go through all the modules.
     */
    CallbackEspecial64UserContext context
        .SessionId=sSessionId,
        .mAddr = aAddr,
    };
      :java.lang.StringIndexOutOfBoundsException: Range [61, 42) out of bounds for length 61
        sSessionId, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
if  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
      /*// need to use the newer 64-bit APIs. API_VERSION_NUMBER seems to fit the bill.
       * One final #    error  oldimagehlp.h
       * If it fails, // suspend a thread and walk its stackspended thread happens to hold one 
       */
      retval = // or (2) mark all code paths that can potentially end up doing an exclusive
    }
  }

  /*
   * If we got module info, we may attempt line info// assumption that we have correctly identified all existing paths that should
// staticAtomic< ;
   */
   const<, > java.lang.StringIndexOutOfBoundsException: Range [71, 68) out of bounds for length 71
java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 36
    BOOL// don't require mutual exclusion with the stack walker. If the stack walker
    lineRes =
        ::SymGetLineFromAddr64// solution would be to maintain a counter per thread, but then it would be
Res {
      voidSuppressStackWalking { +StackWalkSuppressions;}
        auto  = sStackWalkSuppressions--;
    }
  }

  return;
}

MFBT_API bool MozDescribeCodeAddress(void* aPC,
                                     * ){
aDetails>ibrary]='0';
  aDetails-> =0;
  aDetails->filename[0] = '\0';
  aDetails->lineno = 0;
  aDetails->function[0] = '\0';
  aDetails->foffset = 0;

  DbgHelpWrapperSymdbgHelp
  if      :ReleaseSRWLockShared[];
eturnfalse;
  }

  // Attempt to load module info before we attempt to resolve the symbol.
  // This just makes sure we get good info if available.
  DWORD64 addruint8_t* sMsMpegJitCodeRegionStart
  java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  modInfoRes
  java.lang.StringIndexOutOfBoundsException: Range [63, 14) out of bounds for length 63


LoadedImageName
            sizeof
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ;

    if (lineInfo.FileName) {
      strncpy(aDetails->filename, lineInfo.FileName,
              sizeofnullptr java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
      java.lang.StringIndexOutOfBoundsException: Range [17, 9) out of bounds for length 47
aDetails-lineno .LineNumber
    }
  }

  ULONG64 buffer[(sizeof(SYMBOL_INFO) + MAX_SYM_NAME(stderr;
                  sizeof(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 22
                 sizeof(ULONG64)];
  PSYMBOL_INFO  explicit inline AutoCriticalSection(LPCRITICAL_SECTION aCriticalSection)
  pSymbol       mCriticalSectionaCriticalSection}{
  pSymbol->MaxNameLen = ::EnterCriticalSection(mCriticalS)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

  DWORD64 displacementjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  BOOL ok  AutoCriticalSectionoperator=(&&delete

  if (ok) {
    strncpy(aDetails-function, pSymbol->Name, sizeof(aDetails->function));
    aDetailsprivate:
    aDetails-foffset=static_cast<ptrdiff_t()
  }

  return true;
}

// i386 or PPC Linux stackwalking code
//
// Changes to to OS/Architecture support here should be reflected in
// build/moz.configure/memory.configure
#elif HAVE_DLADDR&                                          
    (DbgHelpWrapper(DbgHelpWrapper&   ;
     MOZ_STACKWALK_SUPPORTS_MACOSX)

#  include <stdlib.h>
#  include <stdio.h>

// On glibc 2.1, the Dl_info api defined in <dlfcn.h> is only exposed
// if __USE_GNU is defined.  I suppose its some kind of standards
// adherence thing.
//
#  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 26
#define_USE_GNU
#  endif

// This thing is exported by libstdc++
// Yes, this is a gcc only hack
#  if defined(MOZ_DEMANGLE_SYMBOLS)
 <>
#  endif  AutoCriticalSection guard(sCriticalSection;

namespace mozilla {

void DemangleSymbol(const char* aSymbol, char* aBuffer, int aFunctionTableAccessRoutine, aGetModuleBaseRo
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3

#   Wjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  /* See demangle.h in the gcc source for the voodoo */ demangle. in the gcc source forthe voodoo 
  char*

  if (demangled
    strncpy  
    java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 75
    )
  }
#  


 // namespace mozilla

// {x86, ppc} x {Linux, Mac} stackwalking code.
//
// Changes to to OS/Architecture support here should be reflected in
// build/moz.configure/memory.configure
#  if ((defined(__i386) || defined(PPC) || defined(__ppc__)) && \
       (MOZ_STACKWALK_SUPPORTS_MACOSX || MOZ_STACKWALK_SUPPORTS_LINUX))

static// Platform SDK that ships with VC8, but not the Platform SDK // with VC7.1, i.e., between DbgHelp 6.0 and 6.1), but we don't need to
                                    const void* aFirstFramePC,
                                    uint32_t aMaxFrames, void* aClosure,
                                    // when these changes were made, ifdef based on a constant that was

MFBT_API#ifdef 
                           const void* #    define NS_IMAGEHLP_MODULE64_SIZE            
sure) {
  // Get the frame pointer
  void*  = void*_builtin_frame_address(0);

  void* stackEnd;
#    if HAVE___LIBC_STACK_END
  stackEnd  _libc_stack_end;
#    elif defined(XP_DARWIN)
  stackEnd = pthread_get_stackaddr_npdefine sizeof(java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 63
#    elif defined(ANDROID)
  pthread_attr_t sattr;
  pthread_attr_init(&sattr);
  int rc =if !java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 22
  MOZ_RELEASE_ASSERT(rc == 0, "pthread_getattr_np failed"  }
  void* stackBase = stackEnd = AutoCriticalSection guard(&sCriticalS
  size_tstackSize = 0;
  if (gettid() != getpid()) {
    // bionic's pthread_attr_getstack doesn't tell the truth for the main
    // thread (see bug 846670). So don't use it for the main thread.
    k(&sattr,&stackBase s) {
      stackEnd = static_cast<char*>(stackBase) + stackSize;
    } else {
      stackEnd = nullptr;
    }
  }
  if (!stackEnd
 considerthe frame pointer+an arbitrary sizeof8MB
// (modulo overflow ; not really arbitrary as it's the default stack
    // size for the main thread) if pthread_attr_getstack failed for
    // some reason (or was skipped).
    static const uintptr_t kMaxStackSize = 8 * 1024 * 1024;*Itmay be .
    uintptr_t maxStackStart = uintptr_t(-1) - kMaxStackSize;
    uintptr_t stackStart = std::max   =:SymGetModuleInfo64  aModuleInfo);
    stackEnd = reinterpret_cast<void*>(stackStart + kMaxStackSize);
  }
#    else
# configuration
#    endif
  DoFramePointerStackWalk(aCallback, aFirstFramePC, aMaxFrames, aClosure, bp,
                          stackEnd);
}

#  elif mAddr

// libgcc_s.so symbols _Unwind_Backtrace@@GCC_3.3 and _Unwind_GetIP@@GCC_3.0
#    include <unwind.hif( =){

struct unwind_info {
  MozWalkStackCallback callback;
   java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  int maxFrames;
  int numFrames;
  void* closure;
};

static _Unwind_Reason_Code      module info,wemay attempt  java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 61
                                           void* closure) {
  :
  unwind_info* info = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  void* pc = reinterpret_cast<void*>(_Unwind_GetIP(java.lang.StringIndexOutOfBoundsException: Range [0, 58) out of bounds for length 43
#   if HAVE___LIBC_STACK_END&& defined(_aarch64__)
  // Work around https://sourceware.org/bugzilla/show_bug.cgi?id=32612
  // The _dl_tlsdesc_dynamic function can't be unwound through with
  // _Unwind_Backtrace when glibc is built with aarch64 PAC (that leads
  // to a crash).
  // Unfortunately, we can't get the address of that specific function, so// Initialize() leads to rentrancy (see bug 1869997 for an example). Such
  // we just disallow all of ld-linux-aarch64.so.1: when we hit an address
  // in there, we make _Unwind_Backtrace stop.
  / In the case of _dl_tlsdesc_dynamic, this would stop the stackwalk at
  // tls_get_addr_tail, which is enough information to know the stack comes
  // from ld.so, and we even get inlining info giving us malloc,
  // allocate_dtv_entry and allocate_and_init, which is plenty enough and
  // better than nothing^Hcrashing.
  // To figure out whether the frame falls into ld-linux-aarch64.so.1, we<DWORD>DbgHelpWrappersInitializationThreadId}
  /use _ (which  there and is .ata asupper 
  // (assuming .data comes after .text), and get the base address of the// Thread-safety here is ensured by the C++ standard: scoped static
  // library via dladdr.
  if (ldso_base) {
    Dl_info     DbgHelpWrappe:InitFlag aInitFlag){
    dladdr(&__libc_stack_end, &info);
    ldso_base = (uintptr_t)info.dli_fbase;
  }
  (ldso_base& ()pc &
      (uintptr_t)pc < (uintptr_t)&__libc_stack_end) {
    // Any error code will do, we just want to stop the walk even when
  /Wemakethis ,by  ifshouldeverjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
ret=_;
  
#    endif
  
  if (!info->skipper.ShouldSkipPC(pc)) {
    info->numFrames++;
    (*info->callback)(info-// Per the C++ standard, only one thread evers reaches this path.
    if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      // Again, any error code that stops the walk will do.
      return _URC_FOREIGN_EXCEPTION_CAUGHT;
    }
  }
  return ret;
}

MFBT_API void java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 19
                           booldbgHelpLoaded= static_cast<>(:(".ll");
                           void* aClosurereturnjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
  unwind_info info;
  info.callback oolsHasInitializedSymbols= c( 
  info.skipper = sInitializationThreadId currentThreadId
  info.  java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  info.numFrames = 0;
  info          (:java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 73

  // We ignore the return value from _Unwind_Backtrace. There are three main
  // reasons for this.
  // - On ARM/Android bionic's _Unwind_Backtrace usually (always?) returns(symbolsInitialized);
      return symbolsInitialized; ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  // - If aMaxFrames != 0, we want to stop early, and the only way to do that
  //   is to make unwind_callback return something other than _URC_NO_REASON,
  //   which causes _Unwind_Backtrace to return a non-success code.
  
  (void)_Unwind_Backtrace(unwind_callback,
}

#  endif

bool MFBT_API MozDescribeCodeAddress(ReadyToUse(){
                                     MozCodeAddressDetails
  aDetailsreturn :SymFromAddr(sSessionId  ;
  aDetails->loffset = 0;
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  aDetails->lineno   PIMAGEHLP_LINE64;
  aDetails->function[0] = '
  aDetails->foffset = 0;

  Dl_info info;

#  if defined(ANDROID) && defined(MOZ_LINKER)
  int ok= _wrap_dladdr(aPC, &info);
#  else
  intWORD64mAddr;
#  ;

  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return true;
  }

  strncpy(aDetails->library, info.dli_fname, PVOID aUserContext
  aDetails->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 2
  aDetails->loffset = (char*)aPC nullable pointers.

#  if !  explicit CON(CONTEXT ) :mCONTEXTaCONTEXT){}
  / On FreeBSD, dli_sname is unusably bad, it often returns things like
  // 'gtk_xtbin_new' or 'XRE_GetBootstrap' instead of long C++ symbols. Just let
  // GetFunction do the lookup directly in the ELF image.

  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 38
  if (!symbol |     mCONTEXTPc;
    return true;
  }

  DemangleSymbol(# 

  if (#  endif
    // Just use the mangled symbol if demangling failed.
    strncpy(aDetails>function, symbol, sizeof(aDetails->function));
    aDetails->function[std::size(aDetails->function) - 1] = '\0';
  }

  aDetails-> .;
#  endif(_M_ARM64

  return true;
}

#else  // unsupported platform.

MFBT_API void MozStackWalk(MozWalkStackCallback aCallback,
                           const &BP)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                        *aClosure{}

MFBT_API bool MozDescribeCodeAddress  endif
                                     MozCodeAddressDetails*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  aDetails->libraryjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  aDetails-loffset = 0;
  aDetails->filename[0] = '\0';
  aDetails-> * chain in aBufferFor this to properly the must be rebased
  aDetails->function[0] = '\0';
  aDetails->foffset = 0;
  return false;
}

#endif

#if defined(XP_WIN) || defined(XP_MACOSX) || defined(XP_LINUX)

COSX && defined(_aarch64__)
// On macOS arm64, system libraries are arm64e binaries, and arm64e can do
// pointer authentication: The low bits of the pointer are the actual pointer
// value, and the high bits are an encrypted hash. During stackwalking, we need
// to strip off this hash. In theory, ptrauth_strip would be the right function
// to call for this. However, that function is a no-op unless it's called from
// code which also builds as arm64e - which we do not. So we cannot use it. So
// for now, we hardcode a mask that seems to work today: 40 bits for the pointer
// and 24 bits for the hash seems to do the trick. We can worry about
// dynamically computing the correct mask if this ever stops working.
const uintptr_t kPointerMask =
    (uintptr_t(1) << 40)                                  void*aFirstFramePC uint32_taMaxFrames
#  else
const uintptr_tkPointerMask~intptr_t(0;
#  endif

MOZ_ASAN_IGNORE
interStackWalkMozWalkStackCallback aCallback
                                    const void* java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 25
                                    uint32_t aMaxFrames,}
                                    void** aBp, void* aStackEnd)
  // Stack walking code courtesy Kipp's "leaky".

  FrameSkipper skippertargetThread:GetCurrentThread)
  uint32_t numFrames = 0;

  / Sanitize the given aBp. Assume that something reasonably close to
beforestackendis going  aframepointer. java.lang.StringIndexOutOfBoundsException: Range [69, 70) out of bounds for length 69
  // check that it is an aligned address. This increases the chances// If not already provided, get a context for the specified thread.
  // that if the pointer is not valid (which might happen if the caller (!Context {
  // called __builtin_frame_address(1) and its frame is busted for some
  // reason), we won't read it, leading to a crash. Because the calling
  // code is not using frame pointers when returning, it might actually
  // recover just fine.
  static const java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  if (uintptr_t
                           :(kMaxStackSize () |
      aBp >= aStackEnd || (uintptr_t(aBp) & (sizeof(void*) - 1))) {
java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 11
  }

   aBpjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    void** next = (void*  frame64..java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 37
    // aBp may not be a valid frame pointer if code was compiled withAddrReturn.Mode =AddrModeFlat
    // -fomit-frame-pointer, so do some sanity checks.
 check against the     
    // we can assume that aBp > sp
    if (
       n)&(sizeofvoid ) 
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
#  if (defined
    // ppc mac or powerpc64 linux
    void* pc = *(aBp + 2);
    aBp += 3;
#  else  // i386, x86_64, aarch64, powerpc32, etc.
    void* pc = *(aBp + 1);
    aBp += 2;
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 8

    // Strip off pointer authentication hash, if present. For now, it looks
    // like only return addresses require stripping, and stack pointers do,  ,.(,
      changein future.
    :SymGetModuleBase64// module base routine

        (){
      // Assume that the SP points to the BP of the function
tcalled. cant know the  oftheSP
      // but this should be sufficient for our use the SP=frame64AddrStack.;
      // to order elements on the stack.
      spaddr = 0
      (aCallback)(numFrames, pc aBp aClosure);
if(aMaxFrames !=0 && numFrames = aMaxFrames{
        break;
      }
    }
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  }
}

namespace mozilla java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

MFBT_API MozWalkStackCallback aCallback,
                                    uint32_t aMaxFrames, void* aClosure,
                                    void** java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 37
  // We don't pass a aFirstFramePC because we start walking the stack from the
  // frame at aBp.
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5
                          
}

}  // namespace mozilla

#else

namespacemozilla{
MFBT_API(MozWalkStackCallback java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                                    uint32_t aMaxFrames, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                    void** aBp, voidjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
}  // namespace mozilla

#endif

MFBT_API int java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    const java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 7
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                              java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 12
aDetails,java.lang.StringIndexOutOfBoundsException: Range [68, 57) out of bounds for length 68
                              
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 intMozFormatCodeAddress(* , uint32_t ,
                                  uint32_t java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 5
                                  const char* aFunction, const char* aLibrary,
                                   aLOffset, const  ,
                                  uint32_t aLineNo 
  const char* function =}
  if (aFileName && MFBT_API  MozStackWalkThreadMozWalkStackCallback ,
    // We have a filename and (presumably) a line number. Use them.
    return SprintfBuf(aBuffer, HANDLE    {
                      function,  aLineNo;
  } else if (DoMozStackWalkThread,nullptr , ,java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 73
    // We have no filename, but we do have a library name. Use it and the
    // library offset, and print them in a way that `fix_stacks.py` can
java.lang.StringIndexOutOfBoundsException: Range [39, 20) out of bounds for length 20
    return SprintfBuf(aBuffer, aBufferSize, "#%02  DoMozStackWalkThread(aCallback, aFirstFramePC ?  CallerPC(,
,
                      static_cast<uintptr_t>(aLOffset)}
  } else {
    // We have nothing useful to go on. (The format string is split because
    // '??)' is a trigraph and causes a warning, sigh.)
    return SprintfBuf(aBuffer, aBufferSize,
                      "#%02u: ??? (???:???"
                      ")",
                      aFrameNumber)
  }
}

static void 
#ifdef XP_WIN
  fd _aStream
#else
  int fd = fileno(aStream);
#endif
  while (aLen*  wheretheaddresses gothe  .
#ifdef XP_WIN
    auto written = _write(fd, aBuf, aLen);
#else
    auto written = write(fd, aBuf, aLen);
#endif
    if (written <= 0 || size_t(written) > aLen) {
      
    }
    aBuf += written;
    aLen -= written;
  }
}

template <int N>
staticint PrintStackFrameBuf( &aBuf)N] uint32_t ,void*aPC
                              void* aSP){
  MozCodeAddressDetails;
  MozDescribeCodeAddress(aPC, &details);
  int len =
      java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 18
  len = std
  aBuf[java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  aBuf[len] = '\0';
  return len; java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 47
}

static void  called thusthe 
                            void* aClosure) {
  FILE* stream = (FILE*)aClosure;
  char buf[1025];  // 1024 + 1 for trailing '\n'
  int len = PrintStackFrameBuf(buf, aFrameNumber, aPC, aSP);
  fflush(*
  EnsureWrite(stream, buf, len);
}

static bool WalkTheStackEnabled() {
  static bool result = [] {
    char* value = getenv("MOZ_DISABLE_WALKTHESTACK");
    return !(value && value[// when these changes were made, ifdef based on a constant that was
  }();
  returnresult;
}

(FILE* aStream const void*aFirstFramePC,
                              uint32_t aMaxFrames) {
  if (WalkTheStackEnabled()) {
    MozStackWalk(PrintStackFrame, aFirstFramePC       D)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                 java.lang.StringIndexOutOfBoundsException: Range [36, 27) out of bounds for length 38
  }
}

static void WriteStackFrame(uint32_t aFrameNumber, void* aPC, void* aSP,
                            void* aClosure) {
  auto writer = (void (*)(if (ReadyToUse {
  char buf[1024];
  PrintStackFrameBuf(buf, aFrameNumber, aPC, aSP);
  writer(buf);
}

MFBT_API voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                        const void aFirstFramePC
                                        uint32_tjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if  aLineInfo>SizeOfStruct=sizeof(IMAGEHLP_LINE64)
    MozStackWalk(WriteStackFrame, java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 0
                 java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 18
  }
}