Changeset 150109 in webkit


Ignore:
Timestamp:
May 15, 2013 8:05:24 AM (11 years ago)
Author:
mark.lam@apple.com
Message:

Refactor JITStubs.cpp to move CPU specific parts out into their own files.
https://bugs.webkit.org/show_bug.cgi?id=116135.

Reviewed by Michael Saboff.

This mod only moves the CPU specific parts out. There is no code change.
Tested on debug builds of X86, X86_64, ARM and ARMv7. The SH4 and MIPS
ports are untested. Windows port also not tested.

(JSC::performPlatformSpecificJITAssertions):

  • jit/JITStubsARM.h: Added.

(JSC::ctiTrampoline):
(JSC::ctiTrampolineEnd):
(JSC::ctiVMThrowTrampoline):
(JSC::ctiOpThrowNotCaught):
(JSC::performARMJITAssertions):

  • jit/JITStubsARMv7.h: Added.

(JSC::ctiTrampoline):
(JSC::ctiVMThrowTrampoline):
(JSC::ctiOpThrowNotCaught):
(JSC::performARMv7JITAssertions):

  • jit/JITStubsMIPS.h: Added.

(JSC::performMIPSJITAssertions):

  • jit/JITStubsSH4.h: Added.
  • jit/JITStubsX86.h: Added.
  • jit/JITStubsX86_64.h: Added.
Location:
branches/dfgFourthTier/Source/JavaScriptCore
Files:
6 added
6 edited

Legend:

Unmodified
Added
Removed
  • branches/dfgFourthTier/Source/JavaScriptCore/ChangeLog

    r150086 r150109  
     12013-05-14  Mark Lam  <mark.lam@apple.com>
     2
     3        Refactor JITStubs.cpp to move CPU specific parts out into their own files.
     4        https://bugs.webkit.org/show_bug.cgi?id=116135.
     5
     6        Reviewed by Michael Saboff.
     7
     8        This mod only moves the CPU specific parts out. There is no code change.
     9        Tested on debug builds of X86, X86_64, ARM and ARMv7. The SH4 and MIPS
     10        ports are untested. Windows port also not tested.
     11
     12        * GNUmakefile.list.am:
     13        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
     14        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
     15        * JavaScriptCore.xcodeproj/project.pbxproj:
     16        * jit/JITStubs.cpp:
     17        (JSC::performPlatformSpecificJITAssertions):
     18        * jit/JITStubsARM.h: Added.
     19        (JSC::ctiTrampoline):
     20        (JSC::ctiTrampolineEnd):
     21        (JSC::ctiVMThrowTrampoline):
     22        (JSC::ctiOpThrowNotCaught):
     23        (JSC::performARMJITAssertions):
     24        * jit/JITStubsARMv7.h: Added.
     25        (JSC::ctiTrampoline):
     26        (JSC::ctiVMThrowTrampoline):
     27        (JSC::ctiOpThrowNotCaught):
     28        (JSC::performARMv7JITAssertions):
     29        * jit/JITStubsMIPS.h: Added.
     30        (JSC::performMIPSJITAssertions):
     31        * jit/JITStubsSH4.h: Added.
     32        * jit/JITStubsX86.h: Added.
     33        * jit/JITStubsX86_64.h: Added.
     34
    1352013-05-14  Mark Hahnenberg  <mhahnenberg@apple.com>
    236
  • branches/dfgFourthTier/Source/JavaScriptCore/GNUmakefile.list.am

    r149946 r150109  
    472472        Source/JavaScriptCore/jit/JITStubs.cpp \
    473473        Source/JavaScriptCore/jit/JITStubs.h \
     474        Source/JavaScriptCore/jit/JITStubsARM.h \
     475        Source/JavaScriptCore/jit/JITStubsARMv7.h \
     476        Source/JavaScriptCore/jit/JITStubsMIPS.h \
     477        Source/JavaScriptCore/jit/JITStubsSH4.h \
     478        Source/JavaScriptCore/jit/JITStubsX86.h \
     479        Source/JavaScriptCore/jit/JITStubsX86_64.h \
    474480        Source/JavaScriptCore/jit/JITThunks.cpp \
    475481        Source/JavaScriptCore/jit/JITThunks.h \
  • branches/dfgFourthTier/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj

    r148697 r150109  
    22422242                                >
    22432243                        </File>
     2244                        <File
     2245                                RelativePath="..\..\jit\JITStubsX86.h"
     2246                                >
     2247                        </File>
    22442248            <File
    22452249                                RelativePath="..\..\jit\JITThunks.cpp"
  • branches/dfgFourthTier/Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj

    r148697 r150109  
    569569    <ClInclude Include="..\jit\JITStubRoutine.h" />
    570570    <ClInclude Include="..\jit\JITStubs.h" />
     571    <ClInclude Include="..\jit\JITStubsX86.h" />
     572    <ClInclude Include="..\jit\JITStubsX86_64.h" />
    571573    <ClInclude Include="..\jit\JITThunks.h" />
    572574    <ClInclude Include="..\jit\JITWriteBarrier.h" />
  • branches/dfgFourthTier/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

    r149946 r150109  
    939939                FE4A332015BD2E07006F54F3 /* VMInspector.h in Headers */ = {isa = PBXBuildFile; fileRef = FE4A331E15BD2E07006F54F3 /* VMInspector.h */; settings = {ATTRIBUTES = (Private, ); }; };
    940940                FED287B215EC9A5700DA8161 /* LLIntOpcode.h in Headers */ = {isa = PBXBuildFile; fileRef = FED287B115EC9A5700DA8161 /* LLIntOpcode.h */; settings = {ATTRIBUTES = (Private, ); }; };
     941                FEF6835E174343CC00A32E25 /* JITStubsARM.h in Headers */ = {isa = PBXBuildFile; fileRef = FEF6835A174343CC00A32E25 /* JITStubsARM.h */; settings = {ATTRIBUTES = (Private, ); }; };
     942                FEF6835F174343CC00A32E25 /* JITStubsARMv7.h in Headers */ = {isa = PBXBuildFile; fileRef = FEF6835B174343CC00A32E25 /* JITStubsARMv7.h */; settings = {ATTRIBUTES = (Private, ); }; };
     943                FEF68360174343CC00A32E25 /* JITStubsX86_64.h in Headers */ = {isa = PBXBuildFile; fileRef = FEF6835C174343CC00A32E25 /* JITStubsX86_64.h */; settings = {ATTRIBUTES = (Private, ); }; };
     944                FEF68361174343CC00A32E25 /* JITStubsX86.h in Headers */ = {isa = PBXBuildFile; fileRef = FEF6835D174343CC00A32E25 /* JITStubsX86.h */; settings = {ATTRIBUTES = (Private, ); }; };
    941945/* End PBXBuildFile section */
    942946
     
    19481952                FE4A331E15BD2E07006F54F3 /* VMInspector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = VMInspector.h; sourceTree = "<group>"; };
    19491953                FED287B115EC9A5700DA8161 /* LLIntOpcode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LLIntOpcode.h; path = llint/LLIntOpcode.h; sourceTree = "<group>"; };
     1954                FEF6835A174343CC00A32E25 /* JITStubsARM.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JITStubsARM.h; sourceTree = "<group>"; };
     1955                FEF6835B174343CC00A32E25 /* JITStubsARMv7.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JITStubsARMv7.h; sourceTree = "<group>"; };
     1956                FEF6835C174343CC00A32E25 /* JITStubsX86_64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JITStubsX86_64.h; sourceTree = "<group>"; };
     1957                FEF6835D174343CC00A32E25 /* JITStubsX86.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JITStubsX86.h; sourceTree = "<group>"; };
    19501958/* End PBXFileReference section */
    19511959
     
    22672275                                14A23D6C0F4E19CE0023CDAD /* JITStubs.cpp */,
    22682276                                14A6581A0F4E36F4000150FD /* JITStubs.h */,
     2277                                FEF6835A174343CC00A32E25 /* JITStubsARM.h */,
     2278                                FEF6835B174343CC00A32E25 /* JITStubsARMv7.h */,
     2279                                FEF6835C174343CC00A32E25 /* JITStubsX86_64.h */,
     2280                                FEF6835D174343CC00A32E25 /* JITStubsX86.h */,
    22692281                                0F5EF91B16878F78003E5C25 /* JITThunks.cpp */,
    22702282                                0F5EF91C16878F78003E5C25 /* JITThunks.h */,
     
    31823194                                0F63945515D07057006A597C /* ArrayProfile.h in Headers */,
    31833195                                BC18C3E70E16F5CD00B34460 /* ArrayPrototype.h in Headers */,
     3196                                FEF6835F174343CC00A32E25 /* JITStubsARMv7.h in Headers */,
     3197                                FEF68360174343CC00A32E25 /* JITStubsX86_64.h in Headers */,
     3198                                FEF6835E174343CC00A32E25 /* JITStubsARM.h in Headers */,
     3199                                FEF68361174343CC00A32E25 /* JITStubsX86.h in Headers */,
    31843200                                86E3C61D167BABEE006D760A /* JSVirtualMachineInternal.h in Headers */,
    31853201                                BC18C5240E16FC8A00B34460 /* ArrayPrototype.lut.h in Headers */,
  • branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubs.cpp

    r149655 r150109  
    7676using namespace std;
    7777
     78#if CPU(ARM_TRADITIONAL)
     79#include "JITStubsARM.h"
     80#elif CPU(ARM_THUMB2)
     81#include "JITStubsARMv7.h"
     82#elif CPU(MIPS)
     83#include "JITStubsMIPS.h"
     84#elif CPU(SH4)
     85#include "JITStubsSH4.h"
     86#elif CPU(X86)
     87#include "JITStubsX86.h"
     88#elif CPU(X86_64)
     89#include "JITStubsX86_64.h"
     90#else
     91#error "JIT not supported on this platform."
     92#endif
     93
    7894namespace JSC {
    79 
    80 #if USE(JSVALUE32_64)
    81 
    82 #if COMPILER(GCC) && CPU(X86)
    83 
    84 // These ASSERTs remind you that, if you change the layout of JITStackFrame, you
    85 // need to change the assembly trampolines below to match.
    86 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) % 16 == 0x0, JITStackFrame_maintains_16byte_stack_alignment);
    87 COMPILE_ASSERT(offsetof(struct JITStackFrame, savedEBX) == 0x3c, JITStackFrame_stub_argument_space_matches_ctiTrampoline);
    88 COMPILE_ASSERT(offsetof(struct JITStackFrame, callFrame) == 0x58, JITStackFrame_callFrame_offset_matches_ctiTrampoline);
    89 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) == 0x50, JITStackFrame_code_offset_matches_ctiTrampoline);
    90 
    91 asm (
    92 ".text\n"
    93 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
    94 HIDE_SYMBOL(ctiTrampoline) "\n"
    95 SYMBOL_STRING(ctiTrampoline) ":" "\n"
    96     "pushl %ebp" "\n"
    97     "movl %esp, %ebp" "\n"
    98     "pushl %esi" "\n"
    99     "pushl %edi" "\n"
    100     "pushl %ebx" "\n"
    101     "subl $0x3c, %esp" "\n"
    102     "movl 0x58(%esp), %edi" "\n"
    103     "call *0x50(%esp)" "\n"
    104     "addl $0x3c, %esp" "\n"
    105     "popl %ebx" "\n"
    106     "popl %edi" "\n"
    107     "popl %esi" "\n"
    108     "popl %ebp" "\n"
    109     "ret" "\n"
    110 ".globl " SYMBOL_STRING(ctiTrampolineEnd) "\n"
    111 HIDE_SYMBOL(ctiTrampolineEnd) "\n"
    112 SYMBOL_STRING(ctiTrampolineEnd) ":" "\n"
    113 );
    114 
    115 asm (
    116 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
    117 HIDE_SYMBOL(ctiVMThrowTrampoline) "\n"
    118 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
    119     "movl %esp, %ecx" "\n"
    120     "call " LOCAL_REFERENCE(cti_vm_throw) "\n"
    121     "int3" "\n"
    122 );
    123    
    124 asm (
    125 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
    126 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
    127 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
    128     "addl $0x3c, %esp" "\n"
    129     "popl %ebx" "\n"
    130     "popl %edi" "\n"
    131     "popl %esi" "\n"
    132     "popl %ebp" "\n"
    133     "ret" "\n"
    134 );
    135    
    136 #elif (COMPILER(GCC) || COMPILER(RVCT)) && CPU(ARM_THUMB2)
    137 
    138 #define THUNK_RETURN_ADDRESS_OFFSET      0x38
    139 #define PRESERVED_RETURN_ADDRESS_OFFSET  0x3C
    140 #define PRESERVED_R4_OFFSET              0x40
    141 #define PRESERVED_R5_OFFSET              0x44
    142 #define PRESERVED_R6_OFFSET              0x48
    143 #define PRESERVED_R7_OFFSET              0x4C
    144 #define PRESERVED_R8_OFFSET              0x50
    145 #define PRESERVED_R9_OFFSET              0x54
    146 #define PRESERVED_R10_OFFSET             0x58
    147 #define PRESERVED_R11_OFFSET             0x5C
    148 #define REGISTER_FILE_OFFSET             0x60
    149 #define FIRST_STACK_ARGUMENT             0x68
    150 
    151 #elif (COMPILER(GCC) || COMPILER(MSVC) || COMPILER(RVCT)) && CPU(ARM_TRADITIONAL)
    152 
    153 // Also update the MSVC section (defined at DEFINE_STUB_FUNCTION)
    154 // when changing one of the following values.
    155 #define THUNK_RETURN_ADDRESS_OFFSET 64
    156 #define PRESERVEDR4_OFFSET          68
    157 
    158 #elif COMPILER(MSVC) && CPU(X86)
    159 
    160 // These ASSERTs remind you that, if you change the layout of JITStackFrame, you
    161 // need to change the assembly trampolines below to match.
    162 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) % 16 == 0x0, JITStackFrame_maintains_16byte_stack_alignment);
    163 COMPILE_ASSERT(offsetof(struct JITStackFrame, savedEBX) == 0x3c, JITStackFrame_stub_argument_space_matches_ctiTrampoline);
    164 COMPILE_ASSERT(offsetof(struct JITStackFrame, callFrame) == 0x58, JITStackFrame_callFrame_offset_matches_ctiTrampoline);
    165 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) == 0x50, JITStackFrame_code_offset_matches_ctiTrampoline);
    166 
    167 extern "C" {
    168 
    169     __declspec(naked) EncodedJSValue ctiTrampoline(void* code, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, VM*)
    170     {
    171         __asm {
    172             push ebp;
    173             mov ebp, esp;
    174             push esi;
    175             push edi;
    176             push ebx;
    177             sub esp, 0x3c;
    178             mov ecx, esp;
    179             mov edi, [esp + 0x58];
    180             call [esp + 0x50];
    181             add esp, 0x3c;
    182             pop ebx;
    183             pop edi;
    184             pop esi;
    185             pop ebp;
    186             ret;
    187         }
    188     }
    189 
    190     __declspec(naked) void ctiVMThrowTrampoline()
    191     {
    192         __asm {
    193             mov ecx, esp;
    194             call cti_vm_throw;
    195             add esp, 0x3c;
    196             pop ebx;
    197             pop edi;
    198             pop esi;
    199             pop ebp;
    200             ret;
    201         }
    202     }
    203 
    204     __declspec(naked) void ctiOpThrowNotCaught()
    205     {
    206         __asm {
    207             add esp, 0x3c;
    208             pop ebx;
    209             pop edi;
    210             pop esi;
    211             pop ebp;
    212             ret;
    213         }
    214     }
    215 }
    216 
    217 #elif CPU(MIPS)
    218 
    219 #define PRESERVED_GP_OFFSET         60
    220 #define PRESERVED_S0_OFFSET         64
    221 #define PRESERVED_S1_OFFSET         68
    222 #define PRESERVED_S2_OFFSET         72
    223 #define PRESERVED_S3_OFFSET         76
    224 #define PRESERVED_S4_OFFSET         80
    225 #define PRESERVED_RETURN_ADDRESS_OFFSET 84
    226 #define THUNK_RETURN_ADDRESS_OFFSET 88
    227 #define REGISTER_FILE_OFFSET        92
    228 #define GLOBAL_DATA_OFFSET         108
    229 #define STACK_LENGTH               112
    230 
    231 #elif CPU(SH4)
    232 
    233 #define SYMBOL_STRING(name) #name
    234 /* code (r4), JSStack* (r5), CallFrame* (r6), void* unused1 (r7), void* unused2(sp), VM (sp)*/
    235 
    236 asm volatile (
    237 ".text\n"
    238 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
    239 HIDE_SYMBOL(ctiTrampoline) "\n"
    240 SYMBOL_STRING(ctiTrampoline) ":" "\n"
    241     "mov.l r7, @-r15" "\n"
    242     "mov.l r6, @-r15" "\n"
    243     "mov.l r5, @-r15" "\n"
    244     "mov.l r8, @-r15" "\n"
    245     "mov #127, r8" "\n"
    246     "mov.l r14, @-r15" "\n"
    247     "sts.l pr, @-r15" "\n"
    248     "mov.l r13, @-r15" "\n"
    249     "mov.l r11, @-r15" "\n"
    250     "mov.l r10, @-r15" "\n"
    251     "add #-60, r15" "\n"
    252     "mov r6, r14" "\n"
    253     "jsr @r4" "\n"
    254     "nop" "\n"
    255     "add #60, r15" "\n"
    256     "mov.l @r15+,r10" "\n"
    257     "mov.l @r15+,r11" "\n"
    258     "mov.l @r15+,r13" "\n"
    259     "lds.l @r15+,pr" "\n"
    260     "mov.l @r15+,r14" "\n"
    261     "mov.l @r15+,r8" "\n"
    262     "add #12, r15" "\n"
    263     "rts" "\n"
    264     "nop" "\n"
    265 );
    266 
    267 asm volatile (
    268 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
    269 HIDE_SYMBOL(ctiVMThrowTrampoline) "\n"
    270 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
    271     "mov.l .L2"SYMBOL_STRING(cti_vm_throw)",r0" "\n"
    272     "mov r15, r4" "\n"
    273     "mov.l @(r0,r12),r11" "\n"
    274     "jsr @r11" "\n"
    275     "nop" "\n"
    276     "add #60, r15" "\n"
    277     "mov.l @r15+,r10" "\n"
    278     "mov.l @r15+,r11" "\n"
    279     "mov.l @r15+,r13" "\n"
    280     "lds.l @r15+,pr" "\n"
    281     "mov.l @r15+,r14" "\n"
    282     "mov.l @r15+,r8" "\n"
    283     "add #12, r15" "\n"
    284     "rts" "\n"
    285     "nop" "\n"
    286     ".align 2" "\n"
    287     ".L2"SYMBOL_STRING(cti_vm_throw)":.long " SYMBOL_STRING(cti_vm_throw)"@GOT \n"
    288 );
    289 
    290 asm volatile (
    291 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
    292 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
    293 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
    294     "add #60, r15" "\n"
    295     "mov.l @r15+,r10" "\n"
    296     "mov.l @r15+,r11" "\n"
    297     "mov.l @r15+,r13" "\n"
    298     "lds.l @r15+,pr" "\n"
    299     "mov.l @r15+,r14" "\n"
    300     "mov.l @r15+,r8" "\n"
    301     "add #12, r15" "\n"
    302     "rts" "\n"
    303     "nop" "\n"
    304 );
    305 #else
    306     #error "JIT not supported on this platform."
    307 #endif
    308 
    309 #else // USE(JSVALUE32_64)
    310 
    311 #if COMPILER(GCC) && CPU(X86_64)
    312 
    313 // These ASSERTs remind you that, if you change the layout of JITStackFrame, you
    314 // need to change the assembly trampolines below to match.
    315 COMPILE_ASSERT(offsetof(struct JITStackFrame, callFrame) == 0x58, JITStackFrame_callFrame_offset_matches_ctiTrampoline);
    316 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) == 0x48, JITStackFrame_code_offset_matches_ctiTrampoline);
    317 COMPILE_ASSERT(offsetof(struct JITStackFrame, savedRBX) == 0x78, JITStackFrame_stub_argument_space_matches_ctiTrampoline);
    318 
    319 asm (
    320 ".text\n"
    321 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
    322 HIDE_SYMBOL(ctiTrampoline) "\n"
    323 SYMBOL_STRING(ctiTrampoline) ":" "\n"
    324     "pushq %rbp" "\n"
    325     "movq %rsp, %rbp" "\n"
    326     "pushq %r12" "\n"
    327     "pushq %r13" "\n"
    328     "pushq %r14" "\n"
    329     "pushq %r15" "\n"
    330     "pushq %rbx" "\n"
    331     // Form the JIT stubs area
    332     "pushq %r9" "\n"
    333     "pushq %r8" "\n"
    334     "pushq %rcx" "\n"
    335     "pushq %rdx" "\n"
    336     "pushq %rsi" "\n"
    337     "pushq %rdi" "\n"
    338     "subq $0x48, %rsp" "\n"
    339     "movq $512, %r12" "\n"
    340     "movq $0xFFFF000000000000, %r14" "\n"
    341     "movq $0xFFFF000000000002, %r15" "\n"
    342     "movq %rdx, %r13" "\n"
    343     "call *%rdi" "\n"
    344     "addq $0x78, %rsp" "\n"
    345     "popq %rbx" "\n"
    346     "popq %r15" "\n"
    347     "popq %r14" "\n"
    348     "popq %r13" "\n"
    349     "popq %r12" "\n"
    350     "popq %rbp" "\n"
    351     "ret" "\n"
    352 ".globl " SYMBOL_STRING(ctiTrampolineEnd) "\n"
    353 HIDE_SYMBOL(ctiTrampolineEnd) "\n"
    354 SYMBOL_STRING(ctiTrampolineEnd) ":" "\n"
    355 );
    356 
    357 asm (
    358 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
    359 HIDE_SYMBOL(ctiVMThrowTrampoline) "\n"
    360 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
    361     "movq %rsp, %rdi" "\n"
    362     "call " LOCAL_REFERENCE(cti_vm_throw) "\n"
    363     "int3" "\n"
    364 );
    365 
    366 asm (
    367 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
    368 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
    369 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
    370     "addq $0x78, %rsp" "\n"
    371     "popq %rbx" "\n"
    372     "popq %r15" "\n"
    373     "popq %r14" "\n"
    374     "popq %r13" "\n"
    375     "popq %r12" "\n"
    376     "popq %rbp" "\n"
    377     "ret" "\n"
    378 );
    379 
    380 #elif COMPILER(MSVC) && CPU(X86_64)
    381 
    382 // These ASSERTs remind you that, if you change the layout of JITStackFrame, you
    383 // need to change the assembly trampolines in JITStubsMSVC64.asm to match.
    384 COMPILE_ASSERT(offsetof(struct JITStackFrame, code) % 16 == 0x0, JITStackFrame_maintains_16byte_stack_alignment);
    385 COMPILE_ASSERT(offsetof(struct JITStackFrame, savedRBX) == 0x58, JITStackFrame_stub_argument_space_matches_ctiTrampoline);
    386 
    387 #else
    388     #error "JIT not supported on this platform."
    389 #endif
    390 
    391 #endif // USE(JSVALUE32_64)
    392 
    393 #if CPU(MIPS)
    394 asm (
    395 ".text" "\n"
    396 ".align 2" "\n"
    397 ".set noreorder" "\n"
    398 ".set nomacro" "\n"
    399 ".set nomips16" "\n"
    400 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
    401 ".ent " SYMBOL_STRING(ctiTrampoline) "\n"
    402 SYMBOL_STRING(ctiTrampoline) ":" "\n"
    403     "addiu $29,$29,-" STRINGIZE_VALUE_OF(STACK_LENGTH) "\n"
    404     "sw    $31," STRINGIZE_VALUE_OF(PRESERVED_RETURN_ADDRESS_OFFSET) "($29)" "\n"
    405     "sw    $20," STRINGIZE_VALUE_OF(PRESERVED_S4_OFFSET) "($29)" "\n"
    406     "sw    $19," STRINGIZE_VALUE_OF(PRESERVED_S3_OFFSET) "($29)" "\n"
    407     "sw    $18," STRINGIZE_VALUE_OF(PRESERVED_S2_OFFSET) "($29)" "\n"
    408     "sw    $17," STRINGIZE_VALUE_OF(PRESERVED_S1_OFFSET) "($29)" "\n"
    409     "sw    $16," STRINGIZE_VALUE_OF(PRESERVED_S0_OFFSET) "($29)" "\n"
    410 #if WTF_MIPS_PIC
    411     "sw    $28," STRINGIZE_VALUE_OF(PRESERVED_GP_OFFSET) "($29)" "\n"
    412 #endif
    413     "move  $16,$6       # set callFrameRegister" "\n"
    414     "li    $17,512      # set timeoutCheckRegister" "\n"
    415     "move  $25,$4       # move executableAddress to t9" "\n"
    416     "sw    $5," STRINGIZE_VALUE_OF(REGISTER_FILE_OFFSET) "($29) # store JSStack to current stack" "\n"
    417     "lw    $9," STRINGIZE_VALUE_OF(STACK_LENGTH + 20) "($29)    # load vm from previous stack" "\n"
    418     "jalr  $25" "\n"
    419     "sw    $9," STRINGIZE_VALUE_OF(GLOBAL_DATA_OFFSET) "($29)   # store vm to current stack" "\n"
    420     "lw    $16," STRINGIZE_VALUE_OF(PRESERVED_S0_OFFSET) "($29)" "\n"
    421     "lw    $17," STRINGIZE_VALUE_OF(PRESERVED_S1_OFFSET) "($29)" "\n"
    422     "lw    $18," STRINGIZE_VALUE_OF(PRESERVED_S2_OFFSET) "($29)" "\n"
    423     "lw    $19," STRINGIZE_VALUE_OF(PRESERVED_S3_OFFSET) "($29)" "\n"
    424     "lw    $20," STRINGIZE_VALUE_OF(PRESERVED_S4_OFFSET) "($29)" "\n"
    425     "lw    $31," STRINGIZE_VALUE_OF(PRESERVED_RETURN_ADDRESS_OFFSET) "($29)" "\n"
    426     "jr    $31" "\n"
    427     "addiu $29,$29," STRINGIZE_VALUE_OF(STACK_LENGTH) "\n"
    428 ".set reorder" "\n"
    429 ".set macro" "\n"
    430 ".end " SYMBOL_STRING(ctiTrampoline) "\n"
    431 ".globl " SYMBOL_STRING(ctiTrampolineEnd) "\n"
    432 HIDE_SYMBOL(ctiTrampolineEnd) "\n"
    433 SYMBOL_STRING(ctiTrampolineEnd) ":" "\n"
    434 );
    435 
    436 asm (
    437 ".text" "\n"
    438 ".align 2" "\n"
    439 ".set noreorder" "\n"
    440 ".set nomacro" "\n"
    441 ".set nomips16" "\n"
    442 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
    443 ".ent " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
    444 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
    445 #if WTF_MIPS_PIC
    446 ".set macro" "\n"
    447 ".cpload $31" "\n"
    448     "la    $25," SYMBOL_STRING(cti_vm_throw) "\n"
    449 ".set nomacro" "\n"
    450     "bal " SYMBOL_STRING(cti_vm_throw) "\n"
    451     "move  $4,$29" "\n"
    452 #else
    453     "jal " SYMBOL_STRING(cti_vm_throw) "\n"
    454     "move  $4,$29" "\n"
    455 #endif
    456     "lw    $16," STRINGIZE_VALUE_OF(PRESERVED_S0_OFFSET) "($29)" "\n"
    457     "lw    $17," STRINGIZE_VALUE_OF(PRESERVED_S1_OFFSET) "($29)" "\n"
    458     "lw    $18," STRINGIZE_VALUE_OF(PRESERVED_S2_OFFSET) "($29)" "\n"
    459     "lw    $19," STRINGIZE_VALUE_OF(PRESERVED_S3_OFFSET) "($29)" "\n"
    460     "lw    $20," STRINGIZE_VALUE_OF(PRESERVED_S4_OFFSET) "($29)" "\n"
    461     "lw    $31," STRINGIZE_VALUE_OF(PRESERVED_RETURN_ADDRESS_OFFSET) "($29)" "\n"
    462     "jr    $31" "\n"
    463     "addiu $29,$29," STRINGIZE_VALUE_OF(STACK_LENGTH) "\n"
    464 ".set reorder" "\n"
    465 ".set macro" "\n"
    466 ".end " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
    467 );
    468 
    469 asm (
    470 ".text" "\n"
    471 ".align 2" "\n"
    472 ".set noreorder" "\n"
    473 ".set nomacro" "\n"
    474 ".set nomips16" "\n"
    475 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
    476 ".ent " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
    477 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
    478     "lw    $16," STRINGIZE_VALUE_OF(PRESERVED_S0_OFFSET) "($29)" "\n"
    479     "lw    $17," STRINGIZE_VALUE_OF(PRESERVED_S1_OFFSET) "($29)" "\n"
    480     "lw    $18," STRINGIZE_VALUE_OF(PRESERVED_S2_OFFSET) "($29)" "\n"
    481     "lw    $19," STRINGIZE_VALUE_OF(PRESERVED_S3_OFFSET) "($29)" "\n"
    482     "lw    $20," STRINGIZE_VALUE_OF(PRESERVED_S4_OFFSET) "($29)" "\n"
    483     "lw    $31," STRINGIZE_VALUE_OF(PRESERVED_RETURN_ADDRESS_OFFSET) "($29)" "\n"
    484     "jr    $31" "\n"
    485     "addiu $29,$29," STRINGIZE_VALUE_OF(STACK_LENGTH) "\n"
    486 ".set reorder" "\n"
    487 ".set macro" "\n"
    488 ".end " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
    489 );
    490 #endif
    491 
    492 #if COMPILER(GCC) && CPU(ARM_THUMB2)
    493 
    494 asm (
    495 ".text" "\n"
    496 ".align 2" "\n"
    497 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
    498 HIDE_SYMBOL(ctiTrampoline) "\n"
    499 ".thumb" "\n"
    500 ".thumb_func " THUMB_FUNC_PARAM(ctiTrampoline) "\n"
    501 SYMBOL_STRING(ctiTrampoline) ":" "\n"
    502     "sub sp, sp, #" STRINGIZE_VALUE_OF(FIRST_STACK_ARGUMENT) "\n"
    503     "str lr, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_RETURN_ADDRESS_OFFSET) "]" "\n"
    504     "str r4, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R4_OFFSET) "]" "\n"
    505     "str r5, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R5_OFFSET) "]" "\n"
    506     "str r6, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R6_OFFSET) "]" "\n"
    507     "str r7, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R7_OFFSET) "]" "\n"
    508     "str r8, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R8_OFFSET) "]" "\n"
    509     "str r9, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R9_OFFSET) "]" "\n"
    510     "str r10, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R10_OFFSET) "]" "\n"
    511     "str r11, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R11_OFFSET) "]" "\n"
    512     "str r1, [sp, #" STRINGIZE_VALUE_OF(REGISTER_FILE_OFFSET) "]" "\n"
    513     "mov r5, r2" "\n"
    514     "mov r6, #512" "\n"
    515     "blx r0" "\n"
    516     "ldr r11, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R11_OFFSET) "]" "\n"
    517     "ldr r10, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R10_OFFSET) "]" "\n"
    518     "ldr r9, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R9_OFFSET) "]" "\n"
    519     "ldr r8, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R8_OFFSET) "]" "\n"
    520     "ldr r7, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R7_OFFSET) "]" "\n"
    521     "ldr r6, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R6_OFFSET) "]" "\n"
    522     "ldr r5, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R5_OFFSET) "]" "\n"
    523     "ldr r4, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R4_OFFSET) "]" "\n"
    524     "ldr lr, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_RETURN_ADDRESS_OFFSET) "]" "\n"
    525     "add sp, sp, #" STRINGIZE_VALUE_OF(FIRST_STACK_ARGUMENT) "\n"
    526     "bx lr" "\n"
    527 ".align 2" "\n"
    528 ".globl " SYMBOL_STRING(ctiTrampolineEnd) "\n"
    529 HIDE_SYMBOL(ctiTrampolineEnd) "\n"
    530 ".thumb" "\n"
    531 ".thumb_func " THUMB_FUNC_PARAM(ctiTrampolineEnd) "\n"
    532 SYMBOL_STRING(ctiTrampolineEnd) ":" "\n"
    533 );
    534 
    535 asm (
    536 ".text" "\n"
    537 ".align 2" "\n"
    538 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
    539 HIDE_SYMBOL(ctiVMThrowTrampoline) "\n"
    540 ".thumb" "\n"
    541 ".thumb_func " THUMB_FUNC_PARAM(ctiVMThrowTrampoline) "\n"
    542 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
    543     "mov r0, sp" "\n"
    544     "bl " LOCAL_REFERENCE(cti_vm_throw) "\n"
    545     "ldr r11, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R11_OFFSET) "]" "\n"
    546     "ldr r10, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R10_OFFSET) "]" "\n"
    547     "ldr r9, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R9_OFFSET) "]" "\n"
    548     "ldr r8, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R8_OFFSET) "]" "\n"
    549     "ldr r7, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R7_OFFSET) "]" "\n"
    550     "ldr r6, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R6_OFFSET) "]" "\n"
    551     "ldr r5, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R5_OFFSET) "]" "\n"
    552     "ldr r4, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R4_OFFSET) "]" "\n"
    553     "ldr lr, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_RETURN_ADDRESS_OFFSET) "]" "\n"
    554     "add sp, sp, #" STRINGIZE_VALUE_OF(FIRST_STACK_ARGUMENT) "\n"
    555     "bx lr" "\n"
    556 );
    557 
    558 asm (
    559 ".text" "\n"
    560 ".align 2" "\n"
    561 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
    562 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
    563 ".thumb" "\n"
    564 ".thumb_func " THUMB_FUNC_PARAM(ctiOpThrowNotCaught) "\n"
    565 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
    566     "ldr r11, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R11_OFFSET) "]" "\n"
    567     "ldr r10, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R10_OFFSET) "]" "\n"
    568     "ldr r9, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R9_OFFSET) "]" "\n"
    569     "ldr r8, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R8_OFFSET) "]" "\n"
    570     "ldr r7, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R7_OFFSET) "]" "\n"
    571     "ldr r6, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R6_OFFSET) "]" "\n"
    572     "ldr r5, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R5_OFFSET) "]" "\n"
    573     "ldr r4, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R4_OFFSET) "]" "\n"
    574     "ldr lr, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_RETURN_ADDRESS_OFFSET) "]" "\n"
    575     "add sp, sp, #" STRINGIZE_VALUE_OF(FIRST_STACK_ARGUMENT) "\n"
    576     "bx lr" "\n"
    577 );
    578 
    579 #elif COMPILER(GCC) && CPU(ARM_TRADITIONAL)
    580 
    581 asm (
    582 ".text" "\n"
    583 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
    584 HIDE_SYMBOL(ctiTrampoline) "\n"
    585 INLINE_ARM_FUNCTION(ctiTrampoline)
    586 SYMBOL_STRING(ctiTrampoline) ":" "\n"
    587     "stmdb sp!, {r1-r3}" "\n"
    588     "stmdb sp!, {r4-r6, r8-r11, lr}" "\n"
    589     "sub sp, sp, #" STRINGIZE_VALUE_OF(PRESERVEDR4_OFFSET) "\n"
    590     "mov r5, r2" "\n"
    591     "mov r6, #512" "\n"
    592     // r0 contains the code
    593     "blx r0" "\n"
    594     "add sp, sp, #" STRINGIZE_VALUE_OF(PRESERVEDR4_OFFSET) "\n"
    595     "ldmia sp!, {r4-r6, r8-r11, lr}" "\n"
    596     "add sp, sp, #12" "\n"
    597     "bx lr" "\n"
    598 ".globl " SYMBOL_STRING(ctiTrampolineEnd) "\n"
    599 HIDE_SYMBOL(ctiTrampolineEnd) "\n"
    600 SYMBOL_STRING(ctiTrampolineEnd) ":" "\n"
    601 );
    602 
    603 asm (
    604 ".text" "\n"
    605 ".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
    606 HIDE_SYMBOL(ctiVMThrowTrampoline) "\n"
    607 INLINE_ARM_FUNCTION(ctiVMThrowTrampoline)
    608 SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
    609     "mov r0, sp" "\n"
    610     "bl " SYMBOL_STRING(cti_vm_throw) "\n"
    611 
    612 // Both has the same return sequence
    613 ".text" "\n"
    614 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
    615 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
    616 INLINE_ARM_FUNCTION(ctiOpThrowNotCaught)
    617 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
    618     "add sp, sp, #" STRINGIZE_VALUE_OF(PRESERVEDR4_OFFSET) "\n"
    619     "ldmia sp!, {r4-r6, r8-r11, lr}" "\n"
    620     "add sp, sp, #12" "\n"
    621     "bx lr" "\n"
    622 );
    623 
    624 #elif COMPILER(RVCT) && CPU(ARM_THUMB2)
    625 
    626 __asm EncodedJSValue ctiTrampoline(void*, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, VM*)
    627 {
    628     PRESERVE8
    629     sub sp, sp, # FIRST_STACK_ARGUMENT
    630     str lr, [sp, # PRESERVED_RETURN_ADDRESS_OFFSET ]
    631     str r4, [sp, # PRESERVED_R4_OFFSET ]
    632     str r5, [sp, # PRESERVED_R5_OFFSET ]
    633     str r6, [sp, # PRESERVED_R6_OFFSET ]
    634     str r7, [sp, # PRESERVED_R7_OFFSET ]
    635     str r8, [sp, # PRESERVED_R8_OFFSET ]
    636     str r9, [sp, # PRESERVED_R9_OFFSET ]
    637     str r10, [sp, # PRESERVED_R10_OFFSET ]
    638     str r11, [sp, # PRESERVED_R11_OFFSET ]
    639     str r1, [sp, # REGISTER_FILE_OFFSET ]
    640     mov r5, r2
    641     mov r6, #512
    642     blx r0
    643     ldr r11, [sp, # PRESERVED_R11_OFFSET ]
    644     ldr r10, [sp, # PRESERVED_R10_OFFSET ]
    645     ldr r9, [sp, # PRESERVED_R9_OFFSET ]
    646     ldr r8, [sp, # PRESERVED_R8_OFFSET ]
    647     ldr r7, [sp, # PRESERVED_R7_OFFSET ]
    648     ldr r6, [sp, # PRESERVED_R6_OFFSET ]
    649     ldr r5, [sp, # PRESERVED_R5_OFFSET ]
    650     ldr r4, [sp, # PRESERVED_R4_OFFSET ]
    651     ldr lr, [sp, # PRESERVED_RETURN_ADDRESS_OFFSET ]
    652     add sp, sp, # FIRST_STACK_ARGUMENT
    653     bx lr
    654 }
    655 
    656 __asm void ctiVMThrowTrampoline()
    657 {
    658     PRESERVE8
    659     mov r0, sp
    660     bl cti_vm_throw
    661     ldr r11, [sp, # PRESERVED_R11_OFFSET ]
    662     ldr r10, [sp, # PRESERVED_R10_OFFSET ]
    663     ldr r9, [sp, # PRESERVED_R9_OFFSET ]
    664     ldr r8, [sp, # PRESERVED_R8_OFFSET ]
    665     ldr r7, [sp, # PRESERVED_R7_OFFSET ]
    666     ldr r6, [sp, # PRESERVED_R6_OFFSET ]
    667     ldr r6, [sp, # PRESERVED_R6_OFFSET ]
    668     ldr r5, [sp, # PRESERVED_R5_OFFSET ]
    669     ldr r4, [sp, # PRESERVED_R4_OFFSET ]
    670     ldr lr, [sp, # PRESERVED_RETURN_ADDRESS_OFFSET ]
    671     add sp, sp, # FIRST_STACK_ARGUMENT
    672     bx lr
    673 }
    674 
    675 __asm void ctiOpThrowNotCaught()
    676 {
    677     PRESERVE8
    678     ldr r11, [sp, # PRESERVED_R11_OFFSET ]
    679     ldr r10, [sp, # PRESERVED_R10_OFFSET ]
    680     ldr r9, [sp, # PRESERVED_R9_OFFSET ]
    681     ldr r8, [sp, # PRESERVED_R8_OFFSET ]
    682     ldr r7, [sp, # PRESERVED_R7_OFFSET ]
    683     ldr r6, [sp, # PRESERVED_R6_OFFSET ]
    684     ldr r6, [sp, # PRESERVED_R6_OFFSET ]
    685     ldr r5, [sp, # PRESERVED_R5_OFFSET ]
    686     ldr r4, [sp, # PRESERVED_R4_OFFSET ]
    687     ldr lr, [sp, # PRESERVED_RETURN_ADDRESS_OFFSET ]
    688     add sp, sp, # FIRST_STACK_ARGUMENT
    689     bx lr
    690 }
    691 
    692 #elif COMPILER(RVCT) && CPU(ARM_TRADITIONAL)
    693 
    694 __asm EncodedJSValue ctiTrampoline(void*, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, VM*)
    695 {
    696     ARM
    697     stmdb sp!, {r1-r3}
    698     stmdb sp!, {r4-r6, r8-r11, lr}
    699     sub sp, sp, # PRESERVEDR4_OFFSET
    700     mov r5, r2
    701     mov r6, #512
    702     mov lr, pc
    703     bx r0
    704     add sp, sp, # PRESERVEDR4_OFFSET
    705     ldmia sp!, {r4-r6, r8-r11, lr}
    706     add sp, sp, #12
    707     bx lr
    708 }
    709 __asm void ctiTrampolineEnd()
    710 {
    711 }
    712 
    713 __asm void ctiVMThrowTrampoline()
    714 {
    715     ARM
    716     PRESERVE8
    717     mov r0, sp
    718     bl cti_vm_throw
    719     add sp, sp, # PRESERVEDR4_OFFSET
    720     ldmia sp!, {r4-r6, r8-r11, lr}
    721     add sp, sp, #12
    722     bx lr
    723 }
    724 
    725 __asm void ctiOpThrowNotCaught()
    726 {
    727     ARM
    728     add sp, sp, # PRESERVEDR4_OFFSET
    729     ldmia sp!, {r4-r8, lr}
    730     add sp, sp, #12
    731     bx lr
    732 }
    733 #endif
    73495
    73596#if ENABLE(OPCODE_SAMPLING)
     
    745106
    746107#if CPU(ARM_THUMB2)
    747     // Unfortunate the arm compiler does not like the use of offsetof on JITStackFrame (since it contains non POD types),
    748     // and the OBJECT_OFFSETOF macro does not appear constantish enough for it to be happy with its use in COMPILE_ASSERT
    749     // macros.
    750     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedReturnAddress) == PRESERVED_RETURN_ADDRESS_OFFSET);
    751     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedR4) == PRESERVED_R4_OFFSET);
    752     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedR5) == PRESERVED_R5_OFFSET);
    753     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedR6) == PRESERVED_R6_OFFSET);
    754     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedR7) == PRESERVED_R7_OFFSET);
    755     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedR8) == PRESERVED_R8_OFFSET);
    756     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedR9) == PRESERVED_R9_OFFSET);
    757     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedR10) == PRESERVED_R10_OFFSET);
    758     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedR11) == PRESERVED_R11_OFFSET);
    759 
    760     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, stack) == REGISTER_FILE_OFFSET);
    761     // The fifth argument is the first item already on the stack.
    762     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, unused1) == FIRST_STACK_ARGUMENT);
    763 
    764     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, thunkReturnAddress) == THUNK_RETURN_ADDRESS_OFFSET);
    765 
     108    performARMv7JITAssertions();
    766109#elif CPU(ARM_TRADITIONAL)
    767 
    768     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, thunkReturnAddress) == THUNK_RETURN_ADDRESS_OFFSET);
    769     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedR4) == PRESERVEDR4_OFFSET);
    770 
    771 
     110    performARMJITAssertions();
    772111#elif CPU(MIPS)
    773     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedGP) == PRESERVED_GP_OFFSET);
    774     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedS0) == PRESERVED_S0_OFFSET);
    775     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedS1) == PRESERVED_S1_OFFSET);
    776     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedS2) == PRESERVED_S2_OFFSET);
    777     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedReturnAddress) == PRESERVED_RETURN_ADDRESS_OFFSET);
    778     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, thunkReturnAddress) == THUNK_RETURN_ADDRESS_OFFSET);
    779     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, stack) == REGISTER_FILE_OFFSET);
    780     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, vm) == GLOBAL_DATA_OFFSET);
    781 
     112    performMIPSJITAssertions();
    782113#endif
    783114}
     
    1041372}
    1042373
    1043 #if CPU(ARM_THUMB2) && COMPILER(GCC)
    1044 
    1045 #define DEFINE_STUB_FUNCTION(rtype, op) \
    1046     extern "C" { \
    1047         rtype JITStubThunked_##op(STUB_ARGS_DECLARATION); \
    1048     }; \
    1049     asm ( \
    1050         ".text" "\n" \
    1051         ".align 2" "\n" \
    1052         ".globl " SYMBOL_STRING(cti_##op) "\n" \
    1053         HIDE_SYMBOL(cti_##op) "\n"             \
    1054         ".thumb" "\n" \
    1055         ".thumb_func " THUMB_FUNC_PARAM(cti_##op) "\n" \
    1056         SYMBOL_STRING(cti_##op) ":" "\n" \
    1057         "str lr, [sp, #" STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "]" "\n" \
    1058         "bl " SYMBOL_STRING(JITStubThunked_##op) "\n" \
    1059         "ldr lr, [sp, #" STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "]" "\n" \
    1060         "bx lr" "\n" \
    1061         ); \
    1062     rtype JITStubThunked_##op(STUB_ARGS_DECLARATION) \
    1063 
    1064 #elif CPU(MIPS)
    1065 #if WTF_MIPS_PIC
    1066 #define DEFINE_STUB_FUNCTION(rtype, op) \
    1067     extern "C" { \
    1068         rtype JITStubThunked_##op(STUB_ARGS_DECLARATION); \
    1069     }; \
    1070     asm ( \
    1071         ".text" "\n" \
    1072         ".align 2" "\n" \
    1073         ".set noreorder" "\n" \
    1074         ".set nomacro" "\n" \
    1075         ".set nomips16" "\n" \
    1076         ".globl " SYMBOL_STRING(cti_##op) "\n" \
    1077         ".ent " SYMBOL_STRING(cti_##op) "\n" \
    1078         SYMBOL_STRING(cti_##op) ":" "\n" \
    1079         ".set macro" "\n" \
    1080         ".cpload $25" "\n" \
    1081         "sw    $31," STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "($29)" "\n" \
    1082         "la    $25," SYMBOL_STRING(JITStubThunked_##op) "\n" \
    1083         ".set nomacro" "\n" \
    1084         ".reloc 1f,R_MIPS_JALR," SYMBOL_STRING(JITStubThunked_##op) "\n" \
    1085         "1: jalr $25" "\n" \
    1086         "nop" "\n" \
    1087         "lw    $31," STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "($29)" "\n" \
    1088         "jr    $31" "\n" \
    1089         "nop" "\n" \
    1090         ".set reorder" "\n" \
    1091         ".set macro" "\n" \
    1092         ".end " SYMBOL_STRING(cti_##op) "\n" \
    1093         ); \
    1094     rtype JITStubThunked_##op(STUB_ARGS_DECLARATION)
    1095 
    1096 #else // WTF_MIPS_PIC
    1097 #define DEFINE_STUB_FUNCTION(rtype, op) \
    1098     extern "C" { \
    1099         rtype JITStubThunked_##op(STUB_ARGS_DECLARATION); \
    1100     }; \
    1101     asm ( \
    1102         ".text" "\n" \
    1103         ".align 2" "\n" \
    1104         ".set noreorder" "\n" \
    1105         ".set nomacro" "\n" \
    1106         ".set nomips16" "\n" \
    1107         ".globl " SYMBOL_STRING(cti_##op) "\n" \
    1108         ".ent " SYMBOL_STRING(cti_##op) "\n" \
    1109         SYMBOL_STRING(cti_##op) ":" "\n" \
    1110         "sw    $31," STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "($29)" "\n" \
    1111         "jal " SYMBOL_STRING(JITStubThunked_##op) "\n" \
    1112         "nop" "\n" \
    1113         "lw    $31," STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "($29)" "\n" \
    1114         "jr    $31" "\n" \
    1115         "nop" "\n" \
    1116         ".set reorder" "\n" \
    1117         ".set macro" "\n" \
    1118         ".end " SYMBOL_STRING(cti_##op) "\n" \
    1119         ); \
    1120     rtype JITStubThunked_##op(STUB_ARGS_DECLARATION)
    1121 
    1122 #endif
    1123 
    1124 #elif CPU(ARM_TRADITIONAL) && COMPILER(GCC)
    1125 
    1126 #define DEFINE_STUB_FUNCTION(rtype, op) \
    1127     extern "C" { \
    1128         rtype JITStubThunked_##op(STUB_ARGS_DECLARATION); \
    1129     }; \
    1130     asm ( \
    1131         ".globl " SYMBOL_STRING(cti_##op) "\n" \
    1132         INLINE_ARM_FUNCTION(cti_##op) \
    1133         SYMBOL_STRING(cti_##op) ":" "\n" \
    1134         "str lr, [sp, #" STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "]" "\n" \
    1135         "bl " SYMBOL_STRING(JITStubThunked_##op) "\n" \
    1136         "ldr lr, [sp, #" STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "]" "\n" \
    1137         "bx lr" "\n" \
    1138         ); \
    1139     rtype JITStubThunked_##op(STUB_ARGS_DECLARATION)
    1140 
    1141 #elif (CPU(ARM_THUMB2) || CPU(ARM_TRADITIONAL)) && COMPILER(RVCT)
    1142 
    1143 #define DEFINE_STUB_FUNCTION(rtype, op) rtype JITStubThunked_##op(STUB_ARGS_DECLARATION)
    1144 
    1145 /* The following is a workaround for RVCT toolchain; precompiler macros are not expanded before the code is passed to the assembler */
    1146 
    1147 /* The following section is a template to generate code for GeneratedJITStubs_RVCT.h */
    1148 /* The pattern "#xxx#" will be replaced with "xxx" */
    1149 
    1150 /*
    1151 RVCT(extern "C" #rtype# JITStubThunked_#op#(STUB_ARGS_DECLARATION);)
    1152 RVCT(__asm #rtype# cti_#op#(STUB_ARGS_DECLARATION))
    1153 RVCT({)
    1154 RVCT(    PRESERVE8)
    1155 RVCT(    IMPORT JITStubThunked_#op#)
    1156 RVCT(    str lr, [sp, # THUNK_RETURN_ADDRESS_OFFSET])
    1157 RVCT(    bl JITStubThunked_#op#)
    1158 RVCT(    ldr lr, [sp, # THUNK_RETURN_ADDRESS_OFFSET])
    1159 RVCT(    bx lr)
    1160 RVCT(})
    1161 RVCT()
    1162 */
    1163 
    1164 /* Include the generated file */
    1165 #include "GeneratedJITStubs_RVCT.h"
    1166 
    1167 #elif CPU(ARM_TRADITIONAL) && COMPILER(MSVC)
    1168 
    1169 #define DEFINE_STUB_FUNCTION(rtype, op) extern "C" rtype JITStubThunked_##op(STUB_ARGS_DECLARATION)
    1170 
    1171 /* The following is a workaround for MSVC toolchain; inline assembler is not supported */
    1172 
    1173 /* The following section is a template to generate code for GeneratedJITStubs_MSVC.asm */
    1174 /* The pattern "#xxx#" will be replaced with "xxx" */
    1175 
    1176 /*
    1177 MSVC_BEGIN(    AREA Trampoline, CODE)
    1178 MSVC_BEGIN()
    1179 MSVC_BEGIN(    EXPORT ctiTrampoline)
    1180 MSVC_BEGIN(    EXPORT ctiTrampolineEnd)
    1181 MSVC_BEGIN(    EXPORT ctiVMThrowTrampoline)
    1182 MSVC_BEGIN(    EXPORT ctiOpThrowNotCaught)
    1183 MSVC_BEGIN()
    1184 MSVC_BEGIN(ctiTrampoline PROC)
    1185 MSVC_BEGIN(    stmdb sp!, {r1-r3})
    1186 MSVC_BEGIN(    stmdb sp!, {r4-r6, r8-r11, lr})
    1187 MSVC_BEGIN(    sub sp, sp, #68 ; sync with PRESERVEDR4_OFFSET)
    1188 MSVC_BEGIN(    mov r5, r2)
    1189 MSVC_BEGIN(    mov r6, #512)
    1190 MSVC_BEGIN(    ; r0 contains the code)
    1191 MSVC_BEGIN(    mov lr, pc)
    1192 MSVC_BEGIN(    bx r0)
    1193 MSVC_BEGIN(    add sp, sp, #68 ; sync with PRESERVEDR4_OFFSET)
    1194 MSVC_BEGIN(    ldmia sp!, {r4-r6, r8-r11, lr})
    1195 MSVC_BEGIN(    add sp, sp, #12)
    1196 MSVC_BEGIN(    bx lr)
    1197 MSVC_BEGIN(ctiTrampolineEnd)
    1198 MSVC_BEGIN(ctiTrampoline ENDP)
    1199 MSVC_BEGIN()
    1200 MSVC_BEGIN(ctiVMThrowTrampoline PROC)
    1201 MSVC_BEGIN(    mov r0, sp)
    1202 MSVC_BEGIN(    bl cti_vm_throw)
    1203 MSVC_BEGIN(ctiOpThrowNotCaught)
    1204 MSVC_BEGIN(    add sp, sp, #68 ; sync with PRESERVEDR4_OFFSET)
    1205 MSVC_BEGIN(    ldmia sp!, {r4-r6, r8-r11, lr})
    1206 MSVC_BEGIN(    add sp, sp, #12)
    1207 MSVC_BEGIN(    bx lr)
    1208 MSVC_BEGIN(ctiVMThrowTrampoline ENDP)
    1209 MSVC_BEGIN()
    1210 
    1211 MSVC(    EXPORT cti_#op#)
    1212 MSVC(    IMPORT JITStubThunked_#op#)
    1213 MSVC(cti_#op# PROC)
    1214 MSVC(    str lr, [sp, #64] ; sync with THUNK_RETURN_ADDRESS_OFFSET)
    1215 MSVC(    bl JITStubThunked_#op#)
    1216 MSVC(    ldr lr, [sp, #64] ; sync with THUNK_RETURN_ADDRESS_OFFSET)
    1217 MSVC(    bx lr)
    1218 MSVC(cti_#op# ENDP)
    1219 MSVC()
    1220 
    1221 MSVC_END(    END)
    1222 */
    1223 
    1224 #elif CPU(SH4)
    1225 #define DEFINE_STUB_FUNCTION(rtype, op) \
    1226     extern "C" { \
    1227         rtype JITStubThunked_##op(STUB_ARGS_DECLARATION); \
    1228     }; \
    1229     asm volatile( \
    1230     ".align 2" "\n" \
    1231     ".globl " SYMBOL_STRING(cti_##op) "\n" \
    1232     SYMBOL_STRING(cti_##op) ":" "\n" \
    1233     "sts pr, r11" "\n" \
    1234     "mov.l r11, @(0x38, r15)" "\n" \
    1235     "mov.l .L2"SYMBOL_STRING(JITStubThunked_##op)",r0" "\n" \
    1236     "mov.l @(r0,r12),r11" "\n" \
    1237     "jsr @r11" "\n" \
    1238     "nop" "\n" \
    1239     "mov.l @(0x38, r15), r11 " "\n" \
    1240     "lds r11, pr " "\n" \
    1241     "rts" "\n" \
    1242     "nop" "\n" \
    1243     ".align 2" "\n" \
    1244     ".L2"SYMBOL_STRING(JITStubThunked_##op)":.long " SYMBOL_STRING(JITStubThunked_##op)"@GOT \n" \
    1245     ); \
    1246     rtype JITStubThunked_##op(STUB_ARGS_DECLARATION)
    1247 #else
     374// If the CPU specific header does not provide an implementation, use the default one here.
     375#ifndef DEFINE_STUB_FUNCTION
    1248376#define DEFINE_STUB_FUNCTION(rtype, op) rtype JIT_STUB cti_##op(STUB_ARGS_DECLARATION)
    1249377#endif
Note: See TracChangeset for help on using the changeset viewer.