Diff
Modified: trunk/Source/_javascript_Core/ChangeLog (230825 => 230826)
--- trunk/Source/_javascript_Core/ChangeLog 2018-04-19 22:55:12 UTC (rev 230825)
+++ trunk/Source/_javascript_Core/ChangeLog 2018-04-19 23:30:47 UTC (rev 230826)
@@ -1,3 +1,45 @@
+2018-04-19 Mark Lam <mark....@apple.com>
+
+ Apply pointer profiling to Signal pointers.
+ https://bugs.webkit.org/show_bug.cgi?id=184790
+ <rdar://problem/39301369>
+
+ Reviewed by Michael Saboff.
+
+ 1. Change stackPointer, framePointer, and instructionPointer accessors to
+ be a pair of getter/setter functions.
+ 2. Add support for USE(PLATFORM_REGISTERS_WITH_PROFILE) to allow use of a
+ a pointer profiling variants of these accessors.
+ 3. Also add a linkRegister accessor only for ARM64 on OS(DARWIN).
+
+ * _javascript_CorePrefix.h:
+ * runtime/MachineContext.h:
+ (JSC::MachineContext::stackPointerImpl):
+ (JSC::MachineContext::stackPointer):
+ (JSC::MachineContext::setStackPointer):
+ (JSC::MachineContext::framePointerImpl):
+ (JSC::MachineContext::framePointer):
+ (JSC::MachineContext::setFramePointer):
+ (JSC::MachineContext::instructionPointerImpl):
+ (JSC::MachineContext::instructionPointer):
+ (JSC::MachineContext::setInstructionPointer):
+ (JSC::MachineContext::linkRegisterImpl):
+ (JSC::MachineContext::linkRegister):
+ (JSC::MachineContext::setLinkRegister):
+ * runtime/SamplingProfiler.cpp:
+ (JSC::SamplingProfiler::takeSample):
+ * runtime/VMTraps.cpp:
+ (JSC::SignalContext::SignalContext):
+ (JSC::VMTraps::tryInstallTrapBreakpoints):
+ * tools/CodeProfiling.cpp:
+ (JSC::profilingTimer):
+ * tools/SigillCrashAnalyzer.cpp:
+ (JSC::SignalContext::dump):
+ (JSC::installCrashHandler):
+ (JSC::SigillCrashAnalyzer::analyze):
+ * wasm/WasmFaultSignalHandler.cpp:
+ (JSC::Wasm::trapHandler):
+
2018-04-19 David Kilzer <ddkil...@apple.com>
Enable Objective-C weak references
Modified: trunk/Source/_javascript_Core/_javascript_CorePrefix.h (230825 => 230826)
--- trunk/Source/_javascript_Core/_javascript_CorePrefix.h 2018-04-19 22:55:12 UTC (rev 230825)
+++ trunk/Source/_javascript_Core/_javascript_CorePrefix.h 2018-04-19 23:30:47 UTC (rev 230826)
@@ -1,3 +1,32 @@
+/*
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if __has_include(<WebKitAdditions/_javascript_CorePrefix.h>)
+#include <WebKitAdditions/_javascript_CorePrefix.h>
+#endif
+
#ifdef __cplusplus
#define NULL __null
#else
Modified: trunk/Source/_javascript_Core/runtime/MachineContext.h (230825 => 230826)
--- trunk/Source/_javascript_Core/runtime/MachineContext.h 2018-04-19 22:55:12 UTC (rev 230825)
+++ trunk/Source/_javascript_Core/runtime/MachineContext.h 2018-04-19 23:30:47 UTC (rev 230826)
@@ -1,5 +1,6 @@
/*
* Copyright (C) 2017 Yusuke Suzuki <utatane....@gmail.com>.
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@@ -27,20 +28,25 @@
#include "GPRInfo.h"
#include "LLIntPCRanges.h"
+#include "MacroAssemblerCodeRef.h"
#include <wtf/PlatformRegisters.h>
+#include <wtf/PointerPreparations.h>
#include <wtf/StdLibExtras.h>
namespace JSC {
namespace MachineContext {
-void* stackPointer(const PlatformRegisters&);
+template<typename T = void*> T stackPointer(const PlatformRegisters&);
#if OS(WINDOWS) || HAVE(MACHINE_CONTEXT)
-void*& stackPointer(PlatformRegisters&);
-void*& framePointer(PlatformRegisters&);
-void* framePointer(const PlatformRegisters&);
-void*& instructionPointer(PlatformRegisters&);
-void* instructionPointer(const PlatformRegisters&);
+template<typename T = void*> void setStackPointer(PlatformRegisters&, T);
+template<typename T = void*> T framePointer(const PlatformRegisters&);
+template<typename T = void*> void setFramePointer(PlatformRegisters&, T);
+inline MacroAssemblerCodePtr<CFunctionPtrTag> linkRegister(const PlatformRegisters&);
+inline void setLinkRegister(PlatformRegisters&, MacroAssemblerCodePtr<CFunctionPtrTag>);
+inline MacroAssemblerCodePtr<CFunctionPtrTag> instructionPointer(const PlatformRegisters&);
+inline void setInstructionPointer(PlatformRegisters&, MacroAssemblerCodePtr<CFunctionPtrTag>);
+
template<size_t N> void*& argumentPointer(PlatformRegisters&);
template<size_t N> void* argumentPointer(const PlatformRegisters&);
#if ENABLE(JIT)
@@ -47,13 +53,22 @@
void*& llintInstructionPointer(PlatformRegisters&);
void* llintInstructionPointer(const PlatformRegisters&);
#endif // ENABLE(JIT)
+
#if HAVE(MACHINE_CONTEXT)
-void*& stackPointer(mcontext_t&);
-void* stackPointer(const mcontext_t&);
-void*& framePointer(mcontext_t&);
-void* framePointer(const mcontext_t&);
-void*& instructionPointer(mcontext_t&);
-void* instructionPointer(const mcontext_t&);
+
+#if !USE(PLATFORM_REGISTERS_WITH_PROFILE)
+static inline void*& stackPointerImpl(mcontext_t&);
+static inline void*& framePointerImpl(mcontext_t&);
+static inline void*& instructionPointerImpl(mcontext_t&);
+#endif // !USE(PLATFORM_REGISTERS_WITH_PROFILE)
+
+template<typename T = void*> T stackPointer(const mcontext_t&);
+template<typename T = void*> void setStackPointer(mcontext_t&, T);
+template<typename T = void*> T framePointer(const mcontext_t&);
+template<typename T = void*> void setFramePointer(mcontext_t&, T);
+inline MacroAssemblerCodePtr<CFunctionPtrTag> instructionPointer(const mcontext_t&);
+inline void setInstructionPointer(mcontext_t&, MacroAssemblerCodePtr<CFunctionPtrTag>);
+
template<size_t N> void*& argumentPointer(mcontext_t&);
template<size_t N> void* argumentPointer(const mcontext_t&);
#if ENABLE(JIT)
@@ -64,7 +79,9 @@
#endif // OS(WINDOWS) || HAVE(MACHINE_CONTEXT)
#if OS(WINDOWS) || HAVE(MACHINE_CONTEXT)
-inline void*& stackPointer(PlatformRegisters& regs)
+
+#if !USE(PLATFORM_REGISTERS_WITH_PROFILE)
+static inline void*& stackPointerImpl(PlatformRegisters& regs)
{
#if OS(DARWIN)
#if __DARWIN_UNIX03
@@ -110,26 +127,50 @@
#endif
#elif HAVE(MACHINE_CONTEXT)
- return stackPointer(regs.machineContext);
+ return stackPointerImpl(regs.machineContext);
#endif
}
+#endif // !USE(PLATFORM_REGISTERS_WITH_PROFILE)
-inline void* stackPointer(const PlatformRegisters& regs)
+template<typename T>
+inline T stackPointer(const PlatformRegisters& regs)
{
- return stackPointer(const_cast<PlatformRegisters&>(regs));
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ void* value = WTF_READ_PLATFORM_REGISTERS_SP_WITH_PROFILE(regs);
+ assertIsNotTagged(value);
+ return bitwise_cast<T>(value);
+#else
+ return bitwise_cast<T>(stackPointerImpl(const_cast<PlatformRegisters&>(regs)));
+#endif
}
+
+template<typename T>
+inline void setStackPointer(PlatformRegisters& regs, T value)
+{
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ assertIsNotTagged(bitwise_cast<void*>(value));
+ WTF_WRITE_PLATFORM_REGISTERS_SP_WITH_PROFILE(regs, bitwise_cast<void*>(value));
+#else
+ stackPointerImpl(regs) = bitwise_cast<void*>(value);
+#endif
+}
+
#else // not OS(WINDOWS) || HAVE(MACHINE_CONTEXT)
+
+template<typename T>
inline void* stackPointer(const PlatformRegisters& regs)
{
- return regs.stackPointer;
+ return bitwise_cast<T>(regs.stackPointer);
}
#endif // OS(WINDOWS) || HAVE(MACHINE_CONTEXT)
#if HAVE(MACHINE_CONTEXT)
-inline void*& stackPointer(mcontext_t& machineContext)
+
+#if !USE(PLATFORM_REGISTERS_WITH_PROFILE)
+static inline void*& stackPointerImpl(mcontext_t& machineContext)
{
#if OS(DARWIN)
- return stackPointer(machineContext->__ss);
+ return stackPointerImpl(machineContext->__ss);
#elif OS(FREEBSD)
#if CPU(X86)
@@ -163,16 +204,37 @@
#endif
#endif
}
+#endif // !USE(PLATFORM_REGISTERS_WITH_PROFILE)
-inline void* stackPointer(const mcontext_t& machineContext)
+template<typename T>
+inline T stackPointer(const mcontext_t& machineContext)
{
- return stackPointer(const_cast<mcontext_t&>(machineContext));
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ void* value = WTF_READ_MACHINE_CONTEXT_SP_WITH_PROFILE(machineContext);
+ assertIsNotTagged(value);
+ return bitwise_cast<T>(value);
+#else
+ return bitwise_cast<T>(stackPointerImpl(const_cast<mcontext_t&>(machineContext)));
+#endif
}
+
+template<typename T>
+inline void setStackPointer(mcontext_t& machineContext, T value)
+{
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ assertIsNotTagged(bitwise_cast<void*>(value));
+ WTF_WRITE_MACHINE_CONTEXT_SP_WITH_PROFILE(machineContext, bitwise_cast<void*>(value));
+#else
+ stackPointerImpl(machineContext) = bitwise_cast<void*>(value);
+#endif
+}
#endif // HAVE(MACHINE_CONTEXT)
#if OS(WINDOWS) || HAVE(MACHINE_CONTEXT)
-inline void*& framePointer(PlatformRegisters& regs)
+
+#if !USE(PLATFORM_REGISTERS_WITH_PROFILE)
+static inline void*& framePointerImpl(PlatformRegisters& regs)
{
#if OS(DARWIN)
@@ -219,22 +281,43 @@
#endif
#elif HAVE(MACHINE_CONTEXT)
- return framePointer(regs.machineContext);
+ return framePointerImpl(regs.machineContext);
#endif
}
+#endif // !USE(PLATFORM_REGISTERS_WITH_PROFILE)
-inline void* framePointer(const PlatformRegisters& regs)
+template<typename T>
+inline T framePointer(const PlatformRegisters& regs)
{
- return framePointer(const_cast<PlatformRegisters&>(regs));
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ void* value = WTF_READ_PLATFORM_REGISTERS_FP_WITH_PROFILE(regs);
+ assertIsNotTagged(value);
+ return bitwise_cast<T>(value);
+#else
+ return bitwise_cast<T>(framePointerImpl(const_cast<PlatformRegisters&>(regs)));
+#endif
}
+
+template<typename T>
+inline void setFramePointer(PlatformRegisters& regs, T value)
+{
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ assertIsNotTagged(bitwise_cast<void*>(value));
+ WTF_WRITE_PLATFORM_REGISTERS_FP_WITH_PROFILE(regs, bitwise_cast<void*>(value));
+#else
+ framePointerImpl(regs) = bitwise_cast<void*>(value);
+#endif
+}
#endif // OS(WINDOWS) || HAVE(MACHINE_CONTEXT)
#if HAVE(MACHINE_CONTEXT)
-inline void*& framePointer(mcontext_t& machineContext)
+
+#if !USE(PLATFORM_REGISTERS_WITH_PROFILE)
+static inline void*& framePointerImpl(mcontext_t& machineContext)
{
#if OS(DARWIN)
- return framePointer(machineContext->__ss);
+ return framePointerImpl(machineContext->__ss);
#elif OS(FREEBSD)
#if CPU(X86)
@@ -272,16 +355,37 @@
#error Need a way to get the frame pointer for another thread on this platform
#endif
}
+#endif // !USE(PLATFORM_REGISTERS_WITH_PROFILE)
-inline void* framePointer(const mcontext_t& machineContext)
+template<typename T>
+inline T framePointer(const mcontext_t& machineContext)
{
- return framePointer(const_cast<mcontext_t&>(machineContext));
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ void* value = WTF_READ_MACHINE_CONTEXT_FP_WITH_PROFILE(machineContext);
+ assertIsNotTagged(value);
+ return bitwise_cast<T>(value);
+#else
+ return bitwise_cast<T>(framePointerImpl(const_cast<mcontext_t&>(machineContext)));
+#endif
}
+
+template<typename T>
+inline void setFramePointer(mcontext_t& machineContext, T value)
+{
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ assertIsNotTagged(bitwise_cast<void*>(value));
+ WTF_WRITE_MACHINE_CONTEXT_FP_WITH_PROFILE(machineContext, bitwise_cast<void*>(value));
+#else
+ framePointerImpl(machineContext) = bitwise_cast<void*>(value);
+#endif
+}
#endif // HAVE(MACHINE_CONTEXT)
#if OS(WINDOWS) || HAVE(MACHINE_CONTEXT)
-inline void*& instructionPointer(PlatformRegisters& regs)
+
+#if !USE(PLATFORM_REGISTERS_WITH_PROFILE)
+static inline void*& instructionPointerImpl(PlatformRegisters& regs)
{
#if OS(DARWIN)
#if __DARWIN_UNIX03
@@ -322,22 +426,39 @@
#endif
#elif HAVE(MACHINE_CONTEXT)
- return instructionPointer(regs.machineContext);
+ return instructionPointerImpl(regs.machineContext);
#endif
}
+#endif // !USE(PLATFORM_REGISTERS_WITH_PROFILE)
-inline void* instructionPointer(const PlatformRegisters& regs)
+inline MacroAssemblerCodePtr<CFunctionPtrTag> instructionPointer(const PlatformRegisters& regs)
{
- return instructionPointer(const_cast<PlatformRegisters&>(regs));
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ void* value = WTF_READ_PLATFORM_REGISTERS_PC_WITH_PROFILE(regs);
+#else
+ void* value = instructionPointerImpl(const_cast<PlatformRegisters&>(regs));
+#endif
+ return MacroAssemblerCodePtr<CFunctionPtrTag>(value);
}
+
+inline void setInstructionPointer(PlatformRegisters& regs, MacroAssemblerCodePtr<CFunctionPtrTag> value)
+{
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ WTF_WRITE_PLATFORM_REGISTERS_PC_WITH_PROFILE(regs, value.executableAddress());
+#else
+ instructionPointerImpl(regs) = value.executableAddress();
+#endif
+}
#endif // OS(WINDOWS) || HAVE(MACHINE_CONTEXT)
#if HAVE(MACHINE_CONTEXT)
-inline void*& instructionPointer(mcontext_t& machineContext)
+
+#if !USE(PLATFORM_REGISTERS_WITH_PROFILE)
+static inline void*& instructionPointerImpl(mcontext_t& machineContext)
{
#if OS(DARWIN)
- return instructionPointer(machineContext->__ss);
+ return instructionPointerImpl(machineContext->__ss);
#elif OS(FREEBSD)
#if CPU(X86)
@@ -375,15 +496,60 @@
#error Need a way to get the instruction pointer for another thread on this platform
#endif
}
+#endif // !USE(PLATFORM_REGISTERS_WITH_PROFILE)
-inline void* instructionPointer(const mcontext_t& machineContext)
+inline MacroAssemblerCodePtr<CFunctionPtrTag> instructionPointer(const mcontext_t& machineContext)
{
- return instructionPointer(const_cast<mcontext_t&>(machineContext));
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ void* value = WTF_READ_MACHINE_CONTEXT_PC_WITH_PROFILE(machineContext);
+#else
+ void* value = instructionPointerImpl(const_cast<mcontext_t&>(machineContext));
+#endif
+ return MacroAssemblerCodePtr<CFunctionPtrTag>(value);
}
+
+inline void setInstructionPointer(mcontext_t& machineContext, MacroAssemblerCodePtr<CFunctionPtrTag> value)
+{
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ WTF_WRITE_MACHINE_CONTEXT_PC_WITH_PROFILE(machineContext, value.executableAddress());
+#else
+ instructionPointerImpl(machineContext) = value.executableAddress();
+#endif
+}
#endif // HAVE(MACHINE_CONTEXT)
#if OS(WINDOWS) || HAVE(MACHINE_CONTEXT)
+
+#if OS(DARWIN) && __DARWIN_UNIX03 && CPU(ARM64)
+#if !USE(PLATFORM_REGISTERS_WITH_PROFILE)
+inline void*& linkRegisterImpl(PlatformRegisters& regs)
+{
+ return reinterpret_cast<void*&>(regs.__lr);
+}
+#endif // USE(PLATFORM_REGISTERS_WITH_PROFILE)
+
+
+inline MacroAssemblerCodePtr<CFunctionPtrTag> linkRegister(const PlatformRegisters& regs)
+{
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ void* value = WTF_READ_PLATFORM_REGISTERS_PC_WITH_PROFILE(regs);
+#else
+ void* value = linkRegisterImpl(const_cast<PlatformRegisters&>(regs));
+#endif
+ return MacroAssemblerCodePtr<CFunctionPtrTag>(value);
+}
+
+inline void setLinkRegister(PlatformRegisters& regs, MacroAssemblerCodePtr<CFunctionPtrTag> value)
+{
+#if USE(PLATFORM_REGISTERS_WITH_PROFILE)
+ WTF_WRITE_PLATFORM_REGISTERS_PC_WITH_PROFILE(regs, value.executableAddress());
+#else
+ linkRegisterImpl(regs) = value.executableAddress();
+#endif
+}
+#endif // OS(DARWIN) && __DARWIN_UNIX03 && CPU(ARM64)
+
#if HAVE(MACHINE_CONTEXT)
template<> void*& argumentPointer<1>(mcontext_t&);
#endif
Modified: trunk/Source/_javascript_Core/runtime/SamplingProfiler.cpp (230825 => 230826)
--- trunk/Source/_javascript_Core/runtime/SamplingProfiler.cpp 2018-04-19 22:55:12 UTC (rev 230825)
+++ trunk/Source/_javascript_Core/runtime/SamplingProfiler.cpp 2018-04-19 23:30:47 UTC (rev 230826)
@@ -356,7 +356,7 @@
m_jscExecutionThread->getRegisters(registers);
machineFrame = MachineContext::framePointer(registers);
callFrame = static_cast<ExecState*>(machineFrame);
- machinePC = MachineContext::instructionPointer(registers);
+ machinePC = MachineContext::instructionPointer(registers).untaggedExecutableAddress();
llintPC = removeCodePtrTag(MachineContext::llintInstructionPointer(registers));
assertIsNotTagged(machinePC);
}
Modified: trunk/Source/_javascript_Core/runtime/VMTraps.cpp (230825 => 230826)
--- trunk/Source/_javascript_Core/runtime/VMTraps.cpp 2018-04-19 22:55:12 UTC (rev 230825)
+++ trunk/Source/_javascript_Core/runtime/VMTraps.cpp 2018-04-19 23:30:47 UTC (rev 230826)
@@ -36,6 +36,8 @@
#include "MachineContext.h"
#include "MachineStackMarker.h"
#include "MacroAssembler.h"
+#include "MacroAssemblerCodeRef.h"
+#include "PtrTag.h"
#include "VM.h"
#include "VMInspector.h"
#include "Watchdog.h"
@@ -58,12 +60,10 @@
, trapPC(MachineContext::instructionPointer(registers))
, stackPointer(MachineContext::stackPointer(registers))
, framePointer(MachineContext::framePointer(registers))
- {
- assertIsNotTagged(trapPC);
- }
+ { }
PlatformRegisters& registers;
- void* trapPC;
+ MacroAssemblerCodePtr<CFunctionPtrTag> trapPC;
void* stackPointer;
void* framePointer;
};
@@ -87,7 +87,7 @@
// This must be the initial signal to get the mutator thread's attention.
// Let's get the thread to break at invalidation points if needed.
VM& vm = this->vm();
- void* trapPC = context.trapPC;
+ void* trapPC = context.trapPC.untaggedExecutableAddress();
// We must ensure we're in JIT/LLint code. If we are, we know a few things:
// - The JS thread isn't holding the malloc lock. Therefore, it's safe to malloc below.
// - The JS thread isn't holding the CodeBlockSet lock.
@@ -94,7 +94,6 @@
// If we're not in JIT/LLInt code, we can't run the C++ code below because it
// mallocs, and we must prove the JS thread isn't holding the malloc lock
// to be able to do that without risking a deadlock.
- assertIsNotTagged(trapPC);
if (!isJITPC(trapPC) && !LLInt::isLLIntPC(trapPC))
return;
@@ -189,11 +188,11 @@
installSignalHandler(Signal::BadAccess, [] (Signal, SigInfo&, PlatformRegisters& registers) -> SignalAction {
SignalContext context(registers);
- assertIsNotTagged(context.trapPC);
- if (!isJITPC(context.trapPC))
+ void* trapPC = context.trapPC.untaggedExecutableAddress();
+ if (!isJITPC(trapPC))
return SignalAction::NotHandled;
- CodeBlock* currentCodeBlock = DFG::codeBlockForVMTrapPC(context.trapPC);
+ CodeBlock* currentCodeBlock = DFG::codeBlockForVMTrapPC(trapPC);
if (!currentCodeBlock) {
// Either we trapped for some other reason, e.g. Wasm OOB, or we didn't properly monitor the PC. Regardless, we can't do much now...
return SignalAction::NotHandled;
Modified: trunk/Source/_javascript_Core/tools/CodeProfiling.cpp (230825 => 230826)
--- trunk/Source/_javascript_Core/tools/CodeProfiling.cpp 2018-04-19 22:55:12 UTC (rev 230825)
+++ trunk/Source/_javascript_Core/tools/CodeProfiling.cpp 2018-04-19 23:30:47 UTC (rev 230826)
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@@ -72,7 +72,7 @@
{
PlatformRegisters& platformRegisters = WTF::registersFromUContext(static_cast<ucontext_t*>(uap));
CodeProfiling::sample(
- MachineContext::instructionPointer(platformRegisters),
+ MachineContext::instructionPointer(platformRegisters).untaggedExecutableAddress(),
reinterpret_cast<void**>(MachineContext::framePointer(platformRegisters)));
}
#endif
Modified: trunk/Source/_javascript_Core/tools/SigillCrashAnalyzer.cpp (230825 => 230826)
--- trunk/Source/_javascript_Core/tools/SigillCrashAnalyzer.cpp 2018-04-19 22:55:12 UTC (rev 230825)
+++ trunk/Source/_javascript_Core/tools/SigillCrashAnalyzer.cpp 2018-04-19 23:30:47 UTC (rev 230826)
@@ -127,14 +127,18 @@
}
ASSERT(i < 29);
log("x%d: %016llx fp: %016llx lr: %016llx",
- i, registers.__x[i], registers.__fp, registers.__lr);
+ i, registers.__x[i],
+ MachineContext::framePointer<uint64_t>(registers),
+ MachineContext::linkRegister(registers).untaggedExecutableAddress<uint64_t>());
log("sp: %016llx pc: %016llx cpsr: %08x",
- registers.__sp, registers.__pc, registers.__cpsr);
+ MachineContext::stackPointer<uint64_t>(registers),
+ MachineContext::instructionPointer(registers).untaggedExecutableAddress<uint64_t>(),
+ registers.__cpsr);
#endif
}
PlatformRegisters& registers;
- void* machinePC;
+ MacroAssemblerCodePtr<CFunctionPtrTag> machinePC;
void* stackPointer;
void* framePointer;
};
@@ -145,8 +149,8 @@
installSignalHandler(Signal::Ill, [] (Signal, SigInfo&, PlatformRegisters& registers) {
SignalContext context(registers);
- assertIsNotTagged(context.machinePC);
- if (!isJITPC(context.machinePC))
+ void* machinePC = context.machinePC.untaggedExecutableAddress();
+ if (!isJITPC(machinePC))
return SignalAction::NotHandled;
SigillCrashAnalyzer& analyzer = SigillCrashAnalyzer::instance();
@@ -165,7 +169,7 @@
void dump() { }
- void* machinePC;
+ MacroAssemblerCodePtr<CFunctionPtrTag> machinePC;
void* stackPointer;
void* framePointer;
};
@@ -217,7 +221,7 @@
}
auto& locker = expectedLocker.value();
- void* pc = context.machinePC;
+ void* pc = context.machinePC.untaggedExecutableAddress();
auto isInJITMemory = inspector.isValidExecutableMemory(locker, pc);
if (!isInJITMemory) {
log("ERROR: Timed out: not able to determine if pc %p is in valid JIT executable memory", pc);
Modified: trunk/Source/_javascript_Core/wasm/WasmFaultSignalHandler.cpp (230825 => 230826)
--- trunk/Source/_javascript_Core/wasm/WasmFaultSignalHandler.cpp 2018-04-19 22:55:12 UTC (rev 230825)
+++ trunk/Source/_javascript_Core/wasm/WasmFaultSignalHandler.cpp 2018-04-19 23:30:47 UTC (rev 230826)
@@ -56,7 +56,7 @@
static SignalAction trapHandler(Signal, SigInfo& sigInfo, PlatformRegisters& context)
{
- void* faultingInstruction = MachineContext::instructionPointer(context);
+ void* faultingInstruction = MachineContext::instructionPointer(context).untaggedExecutableAddress();
dataLogLnIf(WasmFaultSignalHandlerInternal::verbose, "starting handler for fault at: ", RawPointer(faultingInstruction));
dataLogLnIf(WasmFaultSignalHandlerInternal::verbose, "JIT memory start: ", RawPointer(reinterpret_cast<void*>(startOfFixedExecutableMemoryPool)), " end: ", RawPointer(reinterpret_cast<void*>(endOfFixedExecutableMemoryPool)));
@@ -86,7 +86,7 @@
break;
dataLogLnIf(WasmFaultSignalHandlerInternal::verbose, "found stub: ", RawPointer(exceptionStub.code().executableAddress()));
MachineContext::argumentPointer<1>(context) = reinterpret_cast<void*>(ExceptionType::OutOfBoundsMemoryAccess);
- MachineContext::instructionPointer(context) = exceptionStub.code().executableAddress();
+ MachineContext::setInstructionPointer(context, exceptionStub.code().retagged<CFunctionPtrTag>());
return SignalAction::Handled;
}
}
