Changeset 215269 in webkit for trunk/Source/JavaScriptCore


Ignore:
Timestamp:
Apr 12, 2017, 9:59:26 AM (8 years ago)
Author:
Yusuke Suzuki
Message:

[JSC] Clean up heap/MachineStackMarker by introducing USE(MACHINE_CONTEXT)
​https://bugs.webkit.org/show_bug.cgi?id=170770

Reviewed by Mark Lam.

Source/JavaScriptCore:

We use USE(MACHINE_CONTEXT) to clean up runtime/MachineContext.h. And
we clean up heap/MachineStackMarker.cpp by using MachineContext functions.

  • heap/MachineStackMarker.cpp:

(JSC::MachineThreads::MachineThread::Registers::stackPointer):
(JSC::MachineThreads::MachineThread::Registers::framePointer):
(JSC::MachineThreads::MachineThread::Registers::instructionPointer):
(JSC::MachineThreads::MachineThread::Registers::llintPC):

  • heap/MachineStackMarker.h:
  • runtime/MachineContext.h:

(JSC::MachineContext::stackPointer):
(JSC::MachineContext::framePointer):
(JSC::MachineContext::instructionPointer):
(JSC::MachineContext::argumentPointer<1>):
(JSC::MachineContext::llintInstructionPointer):

Source/WTF:

We add a new define USE_MACHINE_CONTEXT, which becomes true if mcontext_t exists
and we know the way to retrieve values from mcontext_t.

  • wtf/Platform.h:
  • wtf/PlatformRegisters.h:
  • wtf/ThreadingPthreads.cpp:

(WTF::Thread::getRegisters):

Location:
trunk/Source/JavaScriptCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r215265 r215269  
     12017-04-12  Yusuke Suzuki  <[email protected]>
     2
     3        [JSC] Clean up heap/MachineStackMarker by introducing USE(MACHINE_CONTEXT)
     4        https://bugs.webkit.org/show_bug.cgi?id=170770
     5
     6        Reviewed by Mark Lam.
     7
     8        We use USE(MACHINE_CONTEXT) to clean up runtime/MachineContext.h. And
     9        we clean up heap/MachineStackMarker.cpp by using MachineContext functions.
     10
     11        * heap/MachineStackMarker.cpp:
     12        (JSC::MachineThreads::MachineThread::Registers::stackPointer):
     13        (JSC::MachineThreads::MachineThread::Registers::framePointer):
     14        (JSC::MachineThreads::MachineThread::Registers::instructionPointer):
     15        (JSC::MachineThreads::MachineThread::Registers::llintPC):
     16        * heap/MachineStackMarker.h:
     17        * runtime/MachineContext.h:
     18        (JSC::MachineContext::stackPointer):
     19        (JSC::MachineContext::framePointer):
     20        (JSC::MachineContext::instructionPointer):
     21        (JSC::MachineContext::argumentPointer<1>):
     22        (JSC::MachineContext::llintInstructionPointer):
     23
    1242017-04-12  Yusuke Suzuki  <[email protected]>
    225

  • trunk/Source/JavaScriptCore/heap/MachineStackMarker.cpp

    r215265 r215269  
    227227void* MachineThreads::MachineThread::Registers::stackPointer() const
    228228{
    229 #if OS(DARWIN) || OS(WINDOWS) || ((OS(FREEBSD) || defined(__GLIBC__)) && ENABLE(JIT))
    230229    return MachineContext::stackPointer(regs);
    231 #elif USE(PTHREADS)
    232     return regs.stackPointer;
    233 #else
    234 #error Need a way to get the stack pointer for another thread on this platform
    235 #endif
    236230}
    237231
    … …  
    239233void* MachineThreads::MachineThread::Registers::framePointer() const
    240234{
    241 #if OS(DARWIN) || OS(WINDOWS) || (OS(FREEBSD) || defined(__GLIBC__))
     235#if OS(WINDOWS) || USE(MACHINE_CONTEXT)
    242236    return MachineContext::framePointer(regs);
    243237#else
    … …  
    248242void* MachineThreads::MachineThread::Registers::instructionPointer() const
    249243{
    250 #if OS(DARWIN) || OS(WINDOWS) || (OS(FREEBSD) || defined(__GLIBC__))
     244#if OS(WINDOWS) || USE(MACHINE_CONTEXT)
    251245    return MachineContext::instructionPointer(regs);
    252246#else
    … …  
    258252{
    259253    // LLInt uses regT4 as PC.
    260 #if OS(DARWIN) || OS(WINDOWS) || (OS(FREEBSD) || defined(__GLIBC__))
     254#if OS(WINDOWS) || USE(MACHINE_CONTEXT)
    261255    return MachineContext::llintInstructionPointer(regs);
    262256#else

  • trunk/Source/JavaScriptCore/heap/MachineStackMarker.h

    r215265 r215269  
    6464            void* llintPC() const;
    6565#endif // ENABLE(SAMPLING_PROFILER)
    66             WTF::PlatformRegisters regs;
     66            PlatformRegisters regs;
    6767        };
    6868

  • trunk/Source/JavaScriptCore/runtime/MachineContext.h

    r213904 r215269  
    2828#include "GPRInfo.h"
    2929#include "LLIntPCRanges.h"
     30#include <wtf/PlatformRegisters.h>
    3031#include <wtf/StdLibExtras.h>
    31 
    32 #if OS(DARWIN) || OS(FREEBSD) || defined(__GLIBC__)
    33 #include <signal.h>
    34 // Using signal.h didn't make mcontext_t and ucontext_t available on FreeBSD.
    35 // This bug has been fixed in FreeBSD 11.0-CURRENT, so this workaround can be
    36 // removed after FreeBSD 10.x goes EOL.
    37 // https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=207079
    38 #if OS(FREEBSD)
    39 #include <ucontext.h>
    40 #endif
    41 #endif
    42 
    43 #if OS(DARWIN)
    44 #include <mach/thread_act.h>
    45 #endif
    4632
    4733namespace JSC {
    4834namespace MachineContext {
    4935
    50 #if OS(DARWIN)
    51 
    52 #if CPU(X86)
    53 typedef i386_thread_state_t PlatformRegisters;
    54 #elif CPU(X86_64)
    55 typedef x86_thread_state64_t PlatformRegisters;
    56 #elif CPU(PPC)
    57 typedef ppc_thread_state_t PlatformRegisters;
    58 #elif CPU(PPC64)
    59 typedef ppc_thread_state64_t PlatformRegisters;
    60 #elif CPU(ARM)
    61 typedef arm_thread_state_t PlatformRegisters;
    62 #elif CPU(ARM64)
    63 typedef arm_thread_state64_t PlatformRegisters;
    64 #else
    65 #error Unknown Architecture
    66 #endif
    67 
    68 #elif OS(WINDOWS)
    69 
    70 typedef CONTEXT PlatformRegisters;
    71 
    72 #endif
    73 
    74 
    75 #if OS(DARWIN) || OS(WINDOWS)
     36
     37void*& stackPointer(PlatformRegisters&);
     38void* stackPointer(const PlatformRegisters&);
     39
     40#if OS(WINDOWS) || USE(MACHINE_CONTEXT)
     41void*& framePointer(PlatformRegisters&);
     42void* framePointer(const PlatformRegisters&);
     43void*& instructionPointer(PlatformRegisters&);
     44void* instructionPointer(const PlatformRegisters&);
     45template<size_t N> void*& argumentPointer(PlatformRegisters&);
     46template<size_t N> void* argumentPointer(const PlatformRegisters&);
     47#if ENABLE(JIT)
     48void*& llintInstructionPointer(PlatformRegisters&);
     49void* llintInstructionPointer(const PlatformRegisters&);
     50#endif // ENABLE(JIT)
     51#if USE(MACHINE_CONTEXT)
     52void*& stackPointer(mcontext_t&);
     53void* stackPointer(const mcontext_t&);
     54void*& framePointer(mcontext_t&);
     55void* framePointer(const mcontext_t&);
     56void*& instructionPointer(mcontext_t&);
     57void* instructionPointer(const mcontext_t&);
     58template<size_t N> void*& argumentPointer(mcontext_t&);
     59template<size_t N> void* argumentPointer(const mcontext_t&);
     60#if ENABLE(JIT)
     61void*& llintInstructionPointer(mcontext_t&);
     62void* llintInstructionPointer(const mcontext_t&);
     63#endif // ENABLE(JIT)
     64#endif // USE(MACHINE_CONTEXT)
     65#endif // OS(WINDOWS) || USE(MACHINE_CONTEXT)
     66
    7667inline void*& stackPointer(PlatformRegisters& regs)
    7768{
    … …  
    119110#endif
    120111
    121 #endif // OS(DARWIN)
     112#elif USE(MACHINE_CONTEXT)
     113    return stackPointer(regs.machineContext);
     114#else
     115    return regs.stackPointer;
     116#endif
    122117}
    123118
    … …  
    126121    return stackPointer(const_cast<PlatformRegisters&>(regs));
    127122}
    128 #endif // OS(DARWIN) || OS(WINDOWS)
    129 
    130 
    131 #if OS(DARWIN) || ((OS(FREEBSD) || defined(__GLIBC__)) && (CPU(X86) || CPU(X86_64) || CPU(ARM) || CPU(ARM64) || CPU(MIPS)))
     123
     124
     125#if USE(MACHINE_CONTEXT)
    132126inline void*& stackPointer(mcontext_t& machineContext)
    133127{
    … …  
    172166    return stackPointer(const_cast<mcontext_t&>(machineContext));
    173167}
    174 #endif // OS(DARWIN) || ((OS(FREEBSD) || defined(__GLIBC__)) && (CPU(X86) || CPU(X86_64) || CPU(ARM) || CPU(ARM64) || CPU(MIPS)))
    175 
    176 
    177 #if OS(DARWIN) || OS(WINDOWS)
     168#endif // USE(MACHINE_CONTEXT)
     169
     170
     171#if OS(WINDOWS) || USE(MACHINE_CONTEXT)
    178172inline void*& framePointer(PlatformRegisters& regs)
    179173{
    … …  
    222216#endif
    223217
    224 #endif // OS(DARWIN)
     218#elif USE(MACHINE_CONTEXT)
     219    return framePointer(regs.machineContext);
     220#endif
    225221}
    226222
    … …  
    229225    return framePointer(const_cast<PlatformRegisters&>(regs));
    230226}
    231 #endif // OS(DARWIN) || OS(WINDOWS)
    232 
    233 
    234 #if OS(DARWIN) || ((OS(FREEBSD) || defined(__GLIBC__)) && (CPU(X86) || CPU(X86_64) || CPU(ARM) || CPU(ARM64) || CPU(MIPS)))
     227#endif // OS(WINDOWS) || USE(MACHINE_CONTEXT)
     228
     229
     230#if USE(MACHINE_CONTEXT)
    235231inline void*& framePointer(mcontext_t& machineContext)
    236232{
    … …  
    279275    return framePointer(const_cast<mcontext_t&>(machineContext));
    280276}
    281 #endif // OS(DARWIN) || ((OS(FREEBSD) || defined(__GLIBC__)) && (CPU(X86) || CPU(X86_64) || CPU(ARM) || CPU(ARM64) || CPU(MIPS)))
    282 
    283 
    284 #if OS(DARWIN) || OS(WINDOWS)
     277#endif // USE(MACHINE_CONTEXT)
     278
     279
     280#if OS(WINDOWS) || USE(MACHINE_CONTEXT)
    285281inline void*& instructionPointer(PlatformRegisters& regs)
    286282{
    … …  
    323319#endif
    324320
    325 #endif // OS(DARWIN)
     321#elif USE(MACHINE_CONTEXT)
     322    return instructionPointer(regs.machineContext);
     323#endif
    326324}
    327325
    … …  
    330328    return instructionPointer(const_cast<PlatformRegisters&>(regs));
    331329}
    332 #endif // OS(DARWIN) || OS(WINDOWS)
    333 
    334 
    335 #if OS(DARWIN) || ((OS(FREEBSD) || defined(__GLIBC__)) && (CPU(X86) || CPU(X86_64) || CPU(ARM) || CPU(ARM64) || CPU(MIPS)))
    336 
     330#endif // OS(WINDOWS) || USE(MACHINE_CONTEXT)
     331
     332
     333#if USE(MACHINE_CONTEXT)
    337334inline void*& instructionPointer(mcontext_t& machineContext)
    338335{
    … …  
    381378    return instructionPointer(const_cast<mcontext_t&>(machineContext));
    382379}
    383 #endif // OS(DARWIN) || ((OS(FREEBSD) || defined(__GLIBC__)) && (CPU(X86) || CPU(X86_64) || CPU(ARM) || CPU(ARM64) || CPU(MIPS)))
    384 
    385 
    386 #if OS(DARWIN) || OS(WINDOWS)
    387 template<size_t N>
    388 void*& argumentPointer(PlatformRegisters&);
     380#endif // USE(MACHINE_CONTEXT)
     381
     382
     383#if OS(WINDOWS) || USE(MACHINE_CONTEXT)
     384#if USE(MACHINE_CONTEXT)
     385template<> void*& argumentPointer<1>(mcontext_t&);
     386#endif
    389387
    390388template<>
    … …  
    432430#endif
    433431
    434 #endif // OS(DARWIN)
     432#elif USE(MACHINE_CONTEXT)
     433    return argumentPointer<1>(regs.machineContext);
     434#endif
    435435}
    436436
    … …  
    440440    return argumentPointer<N>(const_cast<PlatformRegisters&>(regs));
    441441}
    442 #endif // OS(DARWIN) || OS(WINDOWS)
    443 
    444 
    445 #if OS(DARWIN) || ((OS(FREEBSD) || defined(__GLIBC__)) && (CPU(X86) || CPU(X86_64) || CPU(ARM) || CPU(ARM64) || CPU(MIPS)))
    446 template<unsigned N>
    447 void*& argumentPointer(mcontext_t&);
    448 
     442#endif // OS(WINDOWS) || USE(MACHINE_CONTEXT)
     443
     444#if USE(MACHINE_CONTEXT)
    449445template<>
    450446inline void*& argumentPointer<1>(mcontext_t& machineContext)
    … …  
    495491    return argumentPointer<N>(const_cast<mcontext_t&>(machineContext));
    496492}
    497 #endif // OS(DARWIN) || ((OS(FREEBSD) || defined(__GLIBC__)) && (CPU(X86) || CPU(X86_64) || CPU(ARM) || CPU(ARM64) || CPU(MIPS)))
     493#endif // USE(MACHINE_CONTEXT)
    498494
    499495#if ENABLE(JIT)
    500 #if OS(DARWIN) || OS(WINDOWS)
     496#if OS(WINDOWS) || USE(MACHINE_CONTEXT)
    501497inline void*& llintInstructionPointer(PlatformRegisters& regs)
    502498{
    … …  
    551547#endif
    552548
    553 #endif // OS(DARWIN)
     549#elif USE(MACHINE_CONTEXT)
     550    return llintInstructionPointer(regs.machineContext);
     551#endif
    554552}
    555553
    … …  
    558556    return llintInstructionPointer(const_cast<PlatformRegisters&>(regs));
    559557}
    560 #endif // OS(DARWIN) || OS(WINDOWS)
    561 
    562 
    563 #if OS(DARWIN) || ((OS(FREEBSD) || defined(__GLIBC__)) && (CPU(X86) || CPU(X86_64) || CPU(ARM) || CPU(ARM64) || CPU(MIPS)))
     558#endif // OS(WINDOWS) || USE(MACHINE_CONTEXT)
     559
     560
     561#if USE(MACHINE_CONTEXT)
    564562inline void*& llintInstructionPointer(mcontext_t& machineContext)
    565563{
    … …  
    609607    return llintInstructionPointer(const_cast<mcontext_t&>(machineContext));
    610608}
    611 #endif // OS(DARWIN) || ((OS(FREEBSD) || defined(__GLIBC__)) && (CPU(X86) || CPU(X86_64) || CPU(ARM) || CPU(ARM64) || CPU(MIPS)))
     609#endif // USE(MACHINE_CONTEXT)
    612610#endif // ENABLE(JIT)
    613611
Note: See TracChangeset for help on using the changeset viewer.