{

RELEASE_ASSERT(signal == Signal::AccessFault);

auto instructionPointer = MachineContext::instructionPointer(context);

if (!instructionPointer)

return SignalAction::NotHandled;

void* faultingInstruction = instructionPointer->untaggedPtr();

dataLogLnIf(WasmFaultSignalHandlerInternal::verbose, "starting handler for fault at: ", RawPointer(faultingInstruction));

#if ENABLE(JIT)

dataLogLnIf(WasmFaultSignalHandlerInternal::verbose, "JIT memory start: ", RawPointer(startOfFixedExecutableMemoryPool()), " end: ", RawPointer(endOfFixedExecutableMemoryPool()));

#endif

dataLogLnIf(WasmFaultSignalHandlerInternal::verbose, "WasmIPInt memory start: ", RawPointer(untagCodePtr<void*, CFunctionPtrTag>(LLInt::wasmIPIntPCRangeStart)), " end: ", RawPointer(untagCodePtr<void*, CFunctionPtrTag>(LLInt::wasmIPIntPCRangeEnd)));

// First we need to make sure we are in JIT code or Wasm IPInt code before we can aquire any locks. Otherwise,

// we might have crashed in code that is already holding one of the locks we want to aquire.

assertIsNotTagged(faultingInstruction);

if (isJITPC(faultingInstruction) || LLInt::isWasmIPIntPC(faultingInstruction)) {

std::optional<Wasm::ExceptionType> exception;

{

void* faultingAddress = sigInfo.faultingAddress;

dataLogLnIf(WasmFaultSignalHandlerInternal::verbose, "checking faulting address: ", RawPointer(faultingAddress), " is in an active fast memory");

// Trapping null access for WasmGC Array / Struct.

if (std::bit_cast<uintptr_t>(faultingAddress) < lowestAccessibleAddress())

exception = ExceptionType::NullAccess;

else if (Wasm::Memory::addressIsInGrowableOrFastMemory(faultingAddress))

exception = ExceptionType::OutOfBoundsMemoryAccess;

}

if (exception) {

dataLogLnIf(WasmFaultSignalHandlerInternal::verbose, "found active fast memory for faulting address");

auto didFaultInWasm = [](void* faultingInstruction) -> std::tuple<bool, Wasm::Callee*> {

if (LLInt::isWasmIPIntPC(faultingInstruction))

return { true, nullptr };

auto& calleeRegistry = NativeCalleeRegistry::singleton();

Locker locker { calleeRegistry.getLock() };

for (auto* callee : calleeRegistry.allCallees()) {

if (callee->category() != NativeCallee::Category::Wasm)

continue;

auto* wasmCallee = uncheckedDowncast<Wasm::Callee>(callee);

auto [start, end] = wasmCallee->range();

dataLogLnIf(WasmFaultSignalHandlerInternal::verbose, "function start: ", RawPointer(start), " end: ", RawPointer(end));

if (start <= faultingInstruction && faultingInstruction < end) {

dataLogLnIf(WasmFaultSignalHandlerInternal::verbose, "found match");

return { true, wasmCallee };

}

}

return { false, nullptr };

};

auto [isWasm, callee] = didFaultInWasm(faultingInstruction);

if (isWasm) {

auto* instance = downcast<JSWebAssemblyInstance>(static_cast<JSCell*>(MachineContext::wasmInstancePointer(context)));

instance->setFaultPC(exception.value(), faultingInstruction);

#if CPU(ARM64E) && HAVE(HARDENED_MACH_EXCEPTIONS)

if (g_wtfConfig.signalHandlers.useHardenedHandler) {

MachineContext::setInstructionPointer(context, presignedTrampoline);

return SignalAction::Handled;

}

#endif

MachineContext::setInstructionPointer(context, LLInt::getCodePtr<CFunctionPtrTag>(wasm_throw_from_fault_handler_trampoline_reg_instance));

return SignalAction::Handled;

}

}

}

return SignalAction::NotHandled;

{

static std::once_flag once;

std::call_once(once, [] {

if (!Wasm::isSupported())

return;

if (!Options::useWasmFaultSignalHandler())

return;

activateSignalHandlersFor(Signal::AccessFault);

});

{

static std::once_flag once;

std::call_once(once, [] {

if (!Wasm::isSupported())

return;

if (!Options::useWasmFaultSignalHandler())

return;

#if CPU(ARM64E) && HAVE(HARDENED_MACH_EXCEPTIONS)

presignedTrampoline = g_wtfConfig.signalHandlers.presignReturnPCForHandler(LLInt::getCodePtr<NoPtrTag>(wasm_throw_from_fault_handler_trampoline_reg_instance));

#endif

addSignalHandler(Signal::AccessFault, [] (Signal signal, SigInfo& sigInfo, PlatformRegisters& ucontext) {

return trapHandler(signal, sigInfo, ucontext);

});

});

{

#if CPU(ADDRESS64)

if (!Options::useWasmFaultSignalHandler())

return 0;

ptrdiff_t address = lowestAccessibleAddress();

ptrdiff_t nullValue =JSValue::encode(jsNull());

ptrdiff_t accessed = sizeof(v128_t) * 2; // Paired v128_t access.

if (address < (nullValue + accessed))

return 0;

return address - nullValue - accessed;

#else

return 0;

#endif