Changeset 158751 in webkit


Ignore:
Timestamp:
Nov 6, 2013 9:29:12 AM (10 years ago)
Author:
msaboff@apple.com
Message:

Change ctiTrampoline into a thunk
​https://bugs.webkit.org/show_bug.cgi?id=123844

Reviewed by Filip Pizlo.

Converted ctiTrampoline and ctiOpThrowNotCaught into thunks named callToJavaScript
and returnFromJavaScript. Cleaned up and in some cases removed JITStubsXXX.h files
after removing ctiTrampoline and ctiOpThrowNotCaught. Added callJavaScriptJITFunction
to VM that is a function pointer to the callToJavaScript thunk.

  • GNUmakefile.list.am:
  • JavaScriptCore.xcodeproj/project.pbxproj:
  • dfg/DFGDriver.cpp:

(JSC::DFG::compileImpl):

  • jit/JITCode.cpp:

(JSC::JITCode::execute):

  • jit/JITExceptions.cpp:

(JSC::genericUnwind):

  • jit/JITStubs.cpp:
  • jit/JITStubs.h:
  • jit/JITStubsARM.h:
  • jit/JITStubsARM64.h: Removed.
  • jit/JITStubsARMv7.h:
  • jit/JITStubsMIPS.h: Removed.
  • jit/JITStubsMSVC64.asm:
  • jit/JITStubsSH4.h: Removed.
  • jit/JITStubsX86.h:
  • jit/JITStubsX86_64.h:
  • jit/JSInterfaceJIT.h:
  • jit/ThunkGenerators.cpp:

(JSC::returnFromJavaScript):
(JSC::callToJavaScript):

  • jit/ThunkGenerators.h:
  • runtime/VM.cpp:

(JSC::VM::VM):

  • runtime/VM.h:
Location:
trunk/Source/JavaScriptCore
Files:
3 deleted
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r158748 r158751  
     12013-11-06  Michael Saboff  <msaboff@apple.com>
     2
     3        Change ctiTrampoline into a thunk
     4        https://bugs.webkit.org/show_bug.cgi?id=123844
     5
     6        Reviewed by Filip Pizlo.
     7
     8        Converted ctiTrampoline and ctiOpThrowNotCaught into thunks named callToJavaScript
     9        and returnFromJavaScript.  Cleaned up and in some cases removed JITStubsXXX.h files
     10        after removing ctiTrampoline and ctiOpThrowNotCaught.  Added callJavaScriptJITFunction
     11        to VM that is a function pointer to the callToJavaScript thunk.
     12
     13        * GNUmakefile.list.am:
     14        * JavaScriptCore.xcodeproj/project.pbxproj:
     15        * dfg/DFGDriver.cpp:
     16        (JSC::DFG::compileImpl):
     17        * jit/JITCode.cpp:
     18        (JSC::JITCode::execute):
     19        * jit/JITExceptions.cpp:
     20        (JSC::genericUnwind):
     21        * jit/JITStubs.cpp:
     22        * jit/JITStubs.h:
     23        * jit/JITStubsARM.h:
     24        * jit/JITStubsARM64.h: Removed.
     25        * jit/JITStubsARMv7.h:
     26        * jit/JITStubsMIPS.h: Removed.
     27        * jit/JITStubsMSVC64.asm:
     28        * jit/JITStubsSH4.h: Removed.
     29        * jit/JITStubsX86.h:
     30        * jit/JITStubsX86_64.h:
     31        * jit/JSInterfaceJIT.h:
     32        * jit/ThunkGenerators.cpp:
     33        (JSC::returnFromJavaScript):
     34        (JSC::callToJavaScript):
     35        * jit/ThunkGenerators.h:
     36        * runtime/VM.cpp:
     37        (JSC::VM::VM):
     38        * runtime/VM.h:
     39
    1402013-11-05  Filip Pizlo  <fpizlo@apple.com>
    241

  • trunk/Source/JavaScriptCore/GNUmakefile.list.am

    r158385 r158751  
    663663        Source/JavaScriptCore/jit/JITStubs.h \
    664664        Source/JavaScriptCore/jit/JITStubsARM.h \
    665         Source/JavaScriptCore/jit/JITStubsARM64.h \
    666665        Source/JavaScriptCore/jit/JITStubsARMv7.h \
    667         Source/JavaScriptCore/jit/JITStubsMIPS.h \
    668         Source/JavaScriptCore/jit/JITStubsSH4.h \
    669666        Source/JavaScriptCore/jit/JITStubsX86.h \
    670667        Source/JavaScriptCore/jit/JITStubsX86_64.h \

  • trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

    r158384 r158751  
    715715                41359CF30FDD89AD00206180 /* DateConversion.h in Headers */ = {isa = PBXBuildFile; fileRef = D21202290AD4310C00ED79B6 /* DateConversion.h */; };
    716716                4443AE3316E188D90076F110 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 51F0EB6105C86C6B00E6DF1B /* Foundation.framework */; };
    717                 44DF93E617A1D9200097B97B /* JITStubsARM64.h in Headers */ = {isa = PBXBuildFile; fileRef = 44DF93E517A1D9200097B97B /* JITStubsARM64.h */; };
    718717                451539B912DC994500EF7AC4 /* Yarr.h in Headers */ = {isa = PBXBuildFile; fileRef = 451539B812DC994500EF7AC4 /* Yarr.h */; settings = {ATTRIBUTES = (Private, ); }; };
    719718                5D53726F0E1C54880021E549 /* Tracing.h in Headers */ = {isa = PBXBuildFile; fileRef = 5D53726E0E1C54880021E549 /* Tracing.h */; };
    … …  
    970969                A7986D5717A0BB1E00A95DD0 /* DFGEdgeUsesStructure.h in Headers */ = {isa = PBXBuildFile; fileRef = A7986D5617A0BB1E00A95DD0 /* DFGEdgeUsesStructure.h */; settings = {ATTRIBUTES = (Private, ); }; };
    971970                A7A4AE0817973B26005612B1 /* MacroAssemblerX86Common.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A7A4AE0717973B26005612B1 /* MacroAssemblerX86Common.cpp */; };
    972                 A7A4AE0D17973B4D005612B1 /* JITStubsMIPS.h in Headers */ = {isa = PBXBuildFile; fileRef = A7A4AE0917973B4D005612B1 /* JITStubsMIPS.h */; };
    973                 A7A4AE0F17973B4D005612B1 /* JITStubsSH4.h in Headers */ = {isa = PBXBuildFile; fileRef = A7A4AE0B17973B4D005612B1 /* JITStubsSH4.h */; };
    974971                A7A4AE1017973B4D005612B1 /* JITStubsX86Common.h in Headers */ = {isa = PBXBuildFile; fileRef = A7A4AE0C17973B4D005612B1 /* JITStubsX86Common.h */; };
    975972                A7A8AF3417ADB5F3005AB174 /* ArrayBuffer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A7A8AF2517ADB5F2005AB174 /* ArrayBuffer.cpp */; };
    … …  
    19441941                371D842C17C98B6E00ECF994 /* libz.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libz.dylib; path = usr/lib/libz.dylib; sourceTree = SDKROOT; };
    19451942                449097EE0F8F81B50076A327 /* FeatureDefines.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = FeatureDefines.xcconfig; sourceTree = "<group>"; };
    1946                 44DF93E517A1D9200097B97B /* JITStubsARM64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JITStubsARM64.h; sourceTree = "<group>"; };
    19471943                451539B812DC994500EF7AC4 /* Yarr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Yarr.h; path = yarr/Yarr.h; sourceTree = "<group>"; };
    19481944                45E12D8806A49B0F00E9DF84 /* jsc.cpp */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; path = jsc.cpp; sourceTree = "<group>"; tabWidth = 4; };
    … …  
    22542250                A79EDB0811531CD60019E912 /* JSObjectRefPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSObjectRefPrivate.h; sourceTree = "<group>"; };
    22552251                A7A4AE0717973B26005612B1 /* MacroAssemblerX86Common.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MacroAssemblerX86Common.cpp; sourceTree = "<group>"; };
    2256                 A7A4AE0917973B4D005612B1 /* JITStubsMIPS.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JITStubsMIPS.h; sourceTree = "<group>"; };
    2257                 A7A4AE0B17973B4D005612B1 /* JITStubsSH4.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JITStubsSH4.h; sourceTree = "<group>"; };
    22582252                A7A4AE0C17973B4D005612B1 /* JITStubsX86Common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JITStubsX86Common.h; sourceTree = "<group>"; };
    22592253                A7A7EE7411B98B8D0065A14F /* ASTBuilder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ASTBuilder.h; sourceTree = "<group>"; };
    … …  
    29362930                                14A6581A0F4E36F4000150FD /* JITStubs.h */,
    29372931                                FEF6835A174343CC00A32E25 /* JITStubsARM.h */,
    2938                                 44DF93E517A1D9200097B97B /* JITStubsARM64.h */,
    29392932                                FEF6835B174343CC00A32E25 /* JITStubsARMv7.h */,
    2940                                 A7A4AE0917973B4D005612B1 /* JITStubsMIPS.h */,
    2941                                 A7A4AE0B17973B4D005612B1 /* JITStubsSH4.h */,
    29422933                                FEF6835D174343CC00A32E25 /* JITStubsX86.h */,
    29432934                                FEF6835C174343CC00A32E25 /* JITStubsX86_64.h */,
    … …  
    44114402                                14C5242B0F5355E900BA3D04 /* JITStubs.h in Headers */,
    44124403                                FEF6835E174343CC00A32E25 /* JITStubsARM.h in Headers */,
    4413                                 44DF93E617A1D9200097B97B /* JITStubsARM64.h in Headers */,
    44144404                                FEF6835F174343CC00A32E25 /* JITStubsARMv7.h in Headers */,
    4415                                 A7A4AE0D17973B4D005612B1 /* JITStubsMIPS.h in Headers */,
    4416                                 A7A4AE0F17973B4D005612B1 /* JITStubsSH4.h in Headers */,
    44174405                                FEF68361174343CC00A32E25 /* JITStubsX86.h in Headers */,
    44184406                                FEF68360174343CC00A32E25 /* JITStubsX86_64.h in Headers */,

  • trunk/Source/JavaScriptCore/dfg/DFGDriver.cpp

    r158535 r158751  
    7979    // Make sure that any stubs that the DFG is going to use are initialized. We want to
    8080    // make sure that all JIT code generation does finalization on the main thread.
     81    vm.getCTIStub(callToJavaScript);
     82    vm.getCTIStub(throwNotCaught);
    8183    vm.getCTIStub(osrExitGenerationThunkGenerator);
    8284    vm.getCTIStub(throwExceptionFromCallSlowPathGenerator);

  • trunk/Source/JavaScriptCore/jit/JITCode.cpp

    r155023 r158751  
    2828
    2929#include "Operations.h"
     30#include "ThunkGenerators.h"
    3031#include <wtf/PrintStream.h>
    3132
    … …  
    4445JSValue JITCode::execute(JSStack* stack, CallFrame* callFrame, VM* vm)
    4546{
    46     JSValue result = JSValue::decode(ctiTrampoline(executableAddress(), stack, callFrame, 0, 0, vm));
     47    UNUSED_PARAM(stack);
     48
     49    JSValue result = JSValue::decode(vm->callJavaScriptJITFunction(executableAddress(), callFrame));
    4750    return vm->exception() ? jsNull() : result;
    4851}

  • trunk/Source/JavaScriptCore/jit/JITExceptions.cpp

    r157636 r158751  
    5050        catchRoutine = ExecutableBase::catchRoutineFor(handler, catchPCForInterpreter);
    5151    } else
    52         catchRoutine = FunctionPtr(LLInt::getCodePtr(ctiOpThrowNotCaught)).value();
     52        catchRoutine = vm->getCTIStub(throwNotCaught).code().executableAddress();
    5353   
    5454    vm->callFrameForThrow = callFrame;

  • trunk/Source/JavaScriptCore/jit/JITStubs.cpp

    r157636 r158751  
    3434#include "JITStubs.h"
    3535
    36 #include "Arguments.h"
    37 #include "ArrayConstructor.h"
    38 #include "CallFrame.h"
    39 #include "CallFrameInlines.h"
    40 #include "CodeBlock.h"
    41 #include "CodeProfiling.h"
    42 #include "CommonSlowPaths.h"
    43 #include "DFGCompilationMode.h"
    44 #include "DFGDriver.h"
    45 #include "DFGOSREntry.h"
    46 #include "DFGWorklist.h"
    47 #include "Debugger.h"
    48 #include "DeferGC.h"
    49 #include "ErrorInstance.h"
    50 #include "ExceptionHelpers.h"
    51 #include "GetterSetter.h"
    52 #include "Heap.h"
    53 #include <wtf/InlineASM.h>
    54 #include "JIT.h"
    55 #include "JITExceptions.h"
    56 #include "JITToDFGDeferredCompilationCallback.h"
    57 #include "JSActivation.h"
    58 #include "JSArray.h"
    59 #include "JSFunction.h"
    60 #include "JSGlobalObjectFunctions.h"
    61 #include "JSNameScope.h"
    62 #include "JSNotAnObject.h"
    63 #include "JSPropertyNameIterator.h"
    64 #include "JSString.h"
    65 #include "JSWithScope.h"
    66 #include "LegacyProfiler.h"
    67 #include "NameInstance.h"
    68 #include "ObjectConstructor.h"
    69 #include "ObjectPrototype.h"
    70 #include "Operations.h"
    71 #include "Parser.h"
    72 #include "RegExpObject.h"
    73 #include "RegExpPrototype.h"
    74 #include "Register.h"
    75 #include "RepatchBuffer.h"
    76 #include "SamplingTool.h"
    77 #include "SlowPathCall.h"
    78 #include "Strong.h"
    79 #include "StructureRareDataInlines.h"
    80 #include <wtf/StdLibExtras.h>
    81 #include <stdarg.h>
    82 #include <stdio.h>
    83 
    84 using namespace std;
    85 
    8636#if CPU(ARM_TRADITIONAL)
    8737#include "JITStubsARM.h"
    8838#elif CPU(ARM_THUMB2)
    8939#include "JITStubsARMv7.h"
    90 #elif CPU(MIPS)
    91 #include "JITStubsMIPS.h"
    92 #elif CPU(SH4)
    93 #include "JITStubsSH4.h"
    9440#elif CPU(X86)
    9541#include "JITStubsX86.h"
    … …  
    9743#include "JITStubsX86_64.h"
    9844#elif CPU(ARM64)
    99 #include "JITStubsARM64.h"
     45// There isn't an ARM64 specific .h file
     46#elif CPU(MIPS)
     47// There isn't a MIPS specific .h file
     48#elif CPU(SH4)
     49// There isn't an SH4 specific .h file
    10050#else
    10151#error "JIT not supported on this platform."
    10252#endif
    10353
    104 namespace JSC {
    105 
    106 #if ENABLE(OPCODE_SAMPLING)
    107     #define CTI_SAMPLER stackFrame.vm->interpreter->sampler()
    108 #else
    109     #define CTI_SAMPLER 0
    110 #endif
    111 
    112 } // namespace JSC
    113 
    11454#endif // ENABLE(JIT)

  • trunk/Source/JavaScriptCore/jit/JITStubs.h

    r157795 r158751  
    3131#define JITStubs_h
    3232
    33 #include "CallData.h"
    34 #include "Intrinsic.h"
    35 #include "JITExceptions.h"
    36 #include "LowLevelInterpreter.h"
    37 #include "MacroAssemblerCodeRef.h"
    38 #include "Register.h"
    39 
    4033namespace JSC {
    4134
    4235#if ENABLE(JIT)
    43 
    44 struct StructureStubInfo;
    45 
    46 class ArrayAllocationProfile;
    47 class CodeBlock;
    48 class ExecutablePool;
    49 class FunctionExecutable;
    50 class Identifier;
    51 class VM;
    52 class JSGlobalObject;
    53 class JSObject;
    54 class JSPropertyNameIterator;
    55 class JSStack;
    56 class JSValue;
    57 class JSValueEncodedAsPointer;
    58 class LegacyProfiler;
    59 class NativeExecutable;
    60 class PropertySlot;
    61 class PutPropertySlot;
    62 class RegExp;
    63 class Structure;
    64 
    65 #define STUB_ARGS_DECLARATION void** args
    66 #define STUB_ARGS (args)
    67 
    68 #if CPU(X86)
    69 #if COMPILER(MSVC)
    70 #define JIT_STUB __fastcall
    71 #elif COMPILER(GCC)
    72 #define JIT_STUB  __attribute__ ((fastcall))
    73 #elif COMPILER(SUNCC)
    74 #define JIT_STUB
    75 #else
    76 #error "JIT_STUB function calls require fastcall conventions on x86, add appropriate directive/attribute here for your compiler!"
    77 #endif
    78 #else
    79 #define JIT_STUB
    80 #endif
    81 
    82 extern "C" void ctiOpThrowNotCaught();
    83 extern "C" EncodedJSValue ctiTrampoline(void* code, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, VM*);
    8436
    8537#if USE(MASM_PROBE)

  • trunk/Source/JavaScriptCore/jit/JITStubsARM.h

    r158586 r158751  
    4242namespace JSC {
    4343
    44 // Also update the MSVC section (defined at DEFINE_STUB_FUNCTION)
    45 // when changing one of the following values.
    46 #define THUNK_RETURN_ADDRESS_OFFSET 64
    47 #define PRESERVEDR4_OFFSET          68
    48 
    4944#if COMPILER(GCC)
    5045
    … …  
    151146#endif // USE(MASM_PROBE)
    152147
    153 
    154 asm (
    155 ".text" "\n"
    156 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
    157 HIDE_SYMBOL(ctiTrampoline) "\n"
    158 INLINE_ARM_FUNCTION(ctiTrampoline)
    159 SYMBOL_STRING(ctiTrampoline) ":" "\n"
    160     "stmdb sp!, {r1-r3}" "\n"
    161     "stmdb sp!, {r4-r6, r8-r11, lr}" "\n"
    162     "sub sp, sp, #" STRINGIZE_VALUE_OF(PRESERVEDR4_OFFSET) "\n"
    163     "mov r5, r2" "\n"
    164     "ldr r4, [r5]" "\n"
    165     "str r11, [r4]" "\n"
    166     // r0 contains the code
    167     "blx r0" "\n"
    168     "add sp, sp, #" STRINGIZE_VALUE_OF(PRESERVEDR4_OFFSET) "\n"
    169     "ldmia sp!, {r4-r6, r8-r11, lr}" "\n"
    170     "add sp, sp, #12" "\n"
    171     "bx lr" "\n"
    172 );
    173 
    174 asm (
    175 // Both has the same return sequence
    176 ".text" "\n"
    177 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
    178 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
    179 INLINE_ARM_FUNCTION(ctiOpThrowNotCaught)
    180 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
    181     "add sp, sp, #" STRINGIZE_VALUE_OF(PRESERVEDR4_OFFSET) "\n"
    182     "ldmia sp!, {r4-r6, r8-r11, lr}" "\n"
    183     "add sp, sp, #12" "\n"
    184     "bx lr" "\n"
    185 );
    186148
    187149#if USE(MASM_PROBE)
    … …  
    333295
    334296
    335 #define DEFINE_STUB_FUNCTION(rtype, op) \
    336     extern "C" { \
    337         rtype JITStubThunked_##op(STUB_ARGS_DECLARATION); \
    338     }; \
    339     asm ( \
    340         ".globl " SYMBOL_STRING(cti_##op) "\n" \
    341         INLINE_ARM_FUNCTION(cti_##op) \
    342         SYMBOL_STRING(cti_##op) ":" "\n" \
    343         "str lr, [sp, #" STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "]" "\n" \
    344         "bl " SYMBOL_STRING(JITStubThunked_##op) "\n" \
    345         "ldr lr, [sp, #" STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "]" "\n" \
    346         "bx lr" "\n" \
    347         ); \
    348     rtype JITStubThunked_##op(STUB_ARGS_DECLARATION)
    349297
    350298#endif // COMPILER(GCC)
    351299
    352300#if COMPILER(RVCT)
    353 
    354 __asm EncodedJSValue ctiTrampoline(void*, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, VM*)
    355 {
    356     ARM
    357     stmdb sp!, {r1-r3}
    358     stmdb sp!, {r4-r6, r8-r11, lr}
    359     sub sp, sp, # PRESERVEDR4_OFFSET
    360     mov r5, r2
    361     ldr r4, [r5]
    362     str r11, [r4]
    363     mov lr, pc
    364     bx r0
    365     add sp, sp, # PRESERVEDR4_OFFSET
    366     ldmia sp!, {r4-r6, r8-r11, lr}
    367     add sp, sp, #12
    368     bx lr
    369 }
    370 
    371 __asm void ctiOpThrowNotCaught()
    372 {
    373     ARM
    374     add sp, sp, # PRESERVEDR4_OFFSET
    375     ldmia sp!, {r4-r8, lr}
    376     add sp, sp, #12
    377     bx lr
    378 }
    379 
    380 #define DEFINE_STUB_FUNCTION(rtype, op) rtype JITStubThunked_##op(STUB_ARGS_DECLARATION)
    381 
    382 /* The following is a workaround for RVCT toolchain; precompiler macros are not expanded before the code is passed to the assembler */
    383 
    384 /* The following section is a template to generate code for GeneratedJITStubs_RVCT.h */
    385 /* The pattern "#xxx#" will be replaced with "xxx" */
    386 
    387 /*
    388 RVCT(extern "C" #rtype# JITStubThunked_#op#(STUB_ARGS_DECLARATION);)
    389 RVCT(__asm #rtype# cti_#op#(STUB_ARGS_DECLARATION))
    390 RVCT({)
    391 RVCT(    PRESERVE8)
    392 RVCT(    IMPORT JITStubThunked_#op#)
    393 RVCT(    str lr, [sp, # THUNK_RETURN_ADDRESS_OFFSET])
    394 RVCT(    bl JITStubThunked_#op#)
    395 RVCT(    ldr lr, [sp, # THUNK_RETURN_ADDRESS_OFFSET])
    396 RVCT(    bx lr)
    397 RVCT(})
    398 RVCT()
    399 */
    400301
    401302/* Include the generated file */
    … …  
    404305#endif // COMPILER(RVCT)
    405306
    406 #if COMPILER(MSVC)
    407 
    408 #define DEFINE_STUB_FUNCTION(rtype, op) extern "C" rtype JITStubThunked_##op(STUB_ARGS_DECLARATION)
    409 
    410 /* The following is a workaround for MSVC toolchain; inline assembler is not supported */
    411 
    412 /* The following section is a template to generate code for GeneratedJITStubs_MSVC.asm */
    413 /* The pattern "#xxx#" will be replaced with "xxx" */
    414 
    415 /*
    416 MSVC_BEGIN(    AREA Trampoline, CODE)
    417 MSVC_BEGIN()
    418 MSVC_BEGIN(    EXPORT ctiTrampoline)
    419 MSVC_BEGIN(    EXPORT ctiTrampolineEnd)
    420 MSVC_BEGIN(    EXPORT ctiOpThrowNotCaught)
    421 MSVC_BEGIN(    EXPORT getHostCallReturnValue)
    422 MSVC_BEGIN(    IMPORT getHostCallReturnValueWithExecState)
    423 MSVC_BEGIN()
    424 MSVC_BEGIN(ctiTrampoline PROC)
    425 MSVC_BEGIN(    stmdb sp!, {r1-r3})
    426 MSVC_BEGIN(    stmdb sp!, {r4-r6, r8-r11, lr})
    427 MSVC_BEGIN(    sub sp, sp, #68 ; sync with PRESERVEDR4_OFFSET)
    428 MSVC_BEGIN(    mov r5, r2)
    429 MSVC_BEGIN(    ldr r4, [r5])
    430 MSVC_BEGIN(    str r11, [r4])
    431 MSVC_BEGIN(    ; r0 contains the code)
    432 MSVC_BEGIN(    mov lr, pc)
    433 MSVC_BEGIN(    bx r0)
    434 MSVC_BEGIN(    add sp, sp, #68 ; sync with PRESERVEDR4_OFFSET)
    435 MSVC_BEGIN(    ldmia sp!, {r4-r6, r8-r11, lr})
    436 MSVC_BEGIN(    add sp, sp, #12)
    437 MSVC_BEGIN(    bx lr)
    438 MSVC_BEGIN(ctiTrampolineEnd)
    439 MSVC_BEGIN(ctiTrampoline ENDP)
    440 MSVC_BEGIN()
    441 MSVC_BEGIN(ctiOpThrowNotCaught PROC)
    442 MSVC_BEGIN(    add sp, sp, #68 ; sync with PRESERVEDR4_OFFSET)
    443 MSVC_BEGIN(    ldmia sp!, {r4-r6, r8-r11, lr})
    444 MSVC_BEGIN(    add sp, sp, #12)
    445 MSVC_BEGIN(    bx lr)
    446 MSVC_BEGIN(ctiOpThrowNotCaught ENDP)
    447 MSVC_BEGIN()
    448 MSVC_BEGIN(getHostCallReturnValue PROC)
    449 MSVC_BEGIN(    ldr r5, [r5, #40])
    450 MSVC_BEGIN(    mov r0, r5)
    451 MSVC_BEGIN(    b getHostCallReturnValueWithExecState)
    452 MSVC_BEGIN(getHostCallReturnValue ENDP)
    453 MSVC_BEGIN()
    454 
    455 MSVC(    EXPORT cti_#op#)
    456 MSVC(    IMPORT JITStubThunked_#op#)
    457 MSVC(cti_#op# PROC)
    458 MSVC(    str lr, [sp, #64] ; sync with THUNK_RETURN_ADDRESS_OFFSET)
    459 MSVC(    bl JITStubThunked_#op#)
    460 MSVC(    ldr lr, [sp, #64] ; sync with THUNK_RETURN_ADDRESS_OFFSET)
    461 MSVC(    bx lr)
    462 MSVC(cti_#op# ENDP)
    463 MSVC()
    464 
    465 MSVC_END(    END)
    466 */
    467 #endif // COMPILER(MSVC)
    468 
    469307} // namespace JSC
    470308

  • trunk/Source/JavaScriptCore/jit/JITStubsARMv7.h

    r158586 r158751  
    4242namespace JSC {
    4343
    44 #define THUNK_RETURN_ADDRESS_OFFSET      0x38
    45 #define PRESERVED_RETURN_ADDRESS_OFFSET  0x3C
    46 #define PRESERVED_R4_OFFSET              0x40
    47 #define PRESERVED_R5_OFFSET              0x44
    48 #define PRESERVED_R6_OFFSET              0x48
    49 #define PRESERVED_R7_OFFSET              0x4C
    50 #define PRESERVED_R8_OFFSET              0x50
    51 #define PRESERVED_R9_OFFSET              0x54
    52 #define PRESERVED_R10_OFFSET             0x58
    53 #define PRESERVED_R11_OFFSET             0x5C
    54 #define REGISTER_FILE_OFFSET             0x60
    55 #define FIRST_STACK_ARGUMENT             0x68
    56 
    5744#if COMPILER(GCC)
    5845
    … …  
    199186#undef PROBE_OFFSETOF
    200187
    201 #endif // USE(MASM_PROBE)
    202 
    203 
    204 asm (
    205 ".text" "\n"
    206 ".align 2" "\n"
    207 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
    208 HIDE_SYMBOL(ctiTrampoline) "\n"
    209 ".thumb" "\n"
    210 ".thumb_func " THUMB_FUNC_PARAM(ctiTrampoline) "\n"
    211 SYMBOL_STRING(ctiTrampoline) ":" "\n"
    212     "sub sp, sp, #" STRINGIZE_VALUE_OF(FIRST_STACK_ARGUMENT) "\n"
    213     "str lr, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_RETURN_ADDRESS_OFFSET) "]" "\n"
    214     "str r4, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R4_OFFSET) "]" "\n"
    215     "str r5, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R5_OFFSET) "]" "\n"
    216     "str r6, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R6_OFFSET) "]" "\n"
    217     "str r7, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R7_OFFSET) "]" "\n"
    218     "str r8, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R8_OFFSET) "]" "\n"
    219     "str r9, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R9_OFFSET) "]" "\n"
    220     "str r10, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R10_OFFSET) "]" "\n"
    221     "str r11, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R11_OFFSET) "]" "\n"
    222     "str r1, [sp, #" STRINGIZE_VALUE_OF(REGISTER_FILE_OFFSET) "]" "\n"
    223     "mov r5, r2" "\n"
    224     "ldr r4, [r5]" "\n"
    225     "str r7, [r4]" "\n"
    226     "blx r0" "\n"
    227     "ldr r11, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R11_OFFSET) "]" "\n"
    228     "ldr r10, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R10_OFFSET) "]" "\n"
    229     "ldr r9, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R9_OFFSET) "]" "\n"
    230     "ldr r8, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R8_OFFSET) "]" "\n"
    231     "ldr r7, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R7_OFFSET) "]" "\n"
    232     "ldr r6, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R6_OFFSET) "]" "\n"
    233     "ldr r5, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R5_OFFSET) "]" "\n"
    234     "ldr r4, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R4_OFFSET) "]" "\n"
    235     "ldr lr, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_RETURN_ADDRESS_OFFSET) "]" "\n"
    236     "add sp, sp, #" STRINGIZE_VALUE_OF(FIRST_STACK_ARGUMENT) "\n"
    237     "bx lr" "\n"
    238 );
    239 
    240 asm (
    241 ".text" "\n"
    242 ".align 2" "\n"
    243 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
    244 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
    245 ".thumb" "\n"
    246 ".thumb_func " THUMB_FUNC_PARAM(ctiOpThrowNotCaught) "\n"
    247 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
    248     "ldr r11, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R11_OFFSET) "]" "\n"
    249     "ldr r10, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R10_OFFSET) "]" "\n"
    250     "ldr r9, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R9_OFFSET) "]" "\n"
    251     "ldr r8, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R8_OFFSET) "]" "\n"
    252     "ldr r7, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R7_OFFSET) "]" "\n"
    253     "ldr r6, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R6_OFFSET) "]" "\n"
    254     "ldr r5, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R5_OFFSET) "]" "\n"
    255     "ldr r4, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_R4_OFFSET) "]" "\n"
    256     "ldr lr, [sp, #" STRINGIZE_VALUE_OF(PRESERVED_RETURN_ADDRESS_OFFSET) "]" "\n"
    257     "add sp, sp, #" STRINGIZE_VALUE_OF(FIRST_STACK_ARGUMENT) "\n"
    258     "bx lr" "\n"
    259 );
    260 
    261 #if USE(MASM_PROBE)
    262188asm (
    263189".text" "\n"
    … …  
    419345#endif // USE(MASM_PROBE)
    420346
    421 
    422 #define DEFINE_STUB_FUNCTION(rtype, op) \
    423     extern "C" { \
    424         rtype JITStubThunked_##op(STUB_ARGS_DECLARATION); \
    425     }; \
    426     asm ( \
    427         ".text" "\n" \
    428         ".align 2" "\n" \
    429         ".globl " SYMBOL_STRING(cti_##op) "\n" \
    430         HIDE_SYMBOL(cti_##op) "\n"             \
    431         ".thumb" "\n" \
    432         ".thumb_func " THUMB_FUNC_PARAM(cti_##op) "\n" \
    433         SYMBOL_STRING(cti_##op) ":" "\n" \
    434         "str lr, [sp, #" STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "]" "\n" \
    435         "bl " SYMBOL_STRING(JITStubThunked_##op) "\n" \
    436         "ldr lr, [sp, #" STRINGIZE_VALUE_OF(THUNK_RETURN_ADDRESS_OFFSET) "]" "\n" \
    437         "bx lr" "\n" \
    438         ); \
    439     rtype JITStubThunked_##op(STUB_ARGS_DECLARATION) \
    440 
    441347#endif // COMPILER(GCC)
    442348
    443349#if COMPILER(RVCT)
    444 
    445 __asm EncodedJSValue ctiTrampoline(void*, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, VM*)
    446 {
    447     PRESERVE8
    448     sub sp, sp, # FIRST_STACK_ARGUMENT
    449     str lr, [sp, # PRESERVED_RETURN_ADDRESS_OFFSET ]
    450     str r4, [sp, # PRESERVED_R4_OFFSET ]
    451     str r5, [sp, # PRESERVED_R5_OFFSET ]
    452     str r6, [sp, # PRESERVED_R6_OFFSET ]
    453     str r7, [sp, # PRESERVED_R7_OFFSET ]
    454     str r8, [sp, # PRESERVED_R8_OFFSET ]
    455     str r9, [sp, # PRESERVED_R9_OFFSET ]
    456     str r10, [sp, # PRESERVED_R10_OFFSET ]
    457     str r11, [sp, # PRESERVED_R11_OFFSET ]
    458     str r1, [sp, # REGISTER_FILE_OFFSET ]
    459     mov r5, r2
    460     ldr r4, [r5]
    461     str r7, [r4]
    462     blx r0
    463     ldr r11, [sp, # PRESERVED_R11_OFFSET ]
    464     ldr r10, [sp, # PRESERVED_R10_OFFSET ]
    465     ldr r9, [sp, # PRESERVED_R9_OFFSET ]
    466     ldr r8, [sp, # PRESERVED_R8_OFFSET ]
    467     ldr r7, [sp, # PRESERVED_R7_OFFSET ]
    468     ldr r6, [sp, # PRESERVED_R6_OFFSET ]
    469     ldr r5, [sp, # PRESERVED_R5_OFFSET ]
    470     ldr r4, [sp, # PRESERVED_R4_OFFSET ]
    471     ldr lr, [sp, # PRESERVED_RETURN_ADDRESS_OFFSET ]
    472     add sp, sp, # FIRST_STACK_ARGUMENT
    473     bx lr
    474 }
    475 
    476 __asm void ctiOpThrowNotCaught()
    477 {
    478     PRESERVE8
    479     ldr r11, [sp, # PRESERVED_R11_OFFSET ]
    480     ldr r10, [sp, # PRESERVED_R10_OFFSET ]
    481     ldr r9, [sp, # PRESERVED_R9_OFFSET ]
    482     ldr r8, [sp, # PRESERVED_R8_OFFSET ]
    483     ldr r7, [sp, # PRESERVED_R7_OFFSET ]
    484     ldr r6, [sp, # PRESERVED_R6_OFFSET ]
    485     ldr r5, [sp, # PRESERVED_R5_OFFSET ]
    486     ldr r4, [sp, # PRESERVED_R4_OFFSET ]
    487     ldr lr, [sp, # PRESERVED_RETURN_ADDRESS_OFFSET ]
    488     add sp, sp, # FIRST_STACK_ARGUMENT
    489     bx lr
    490 }
    491 
    492 #define DEFINE_STUB_FUNCTION(rtype, op) rtype JITStubThunked_##op(STUB_ARGS_DECLARATION)
    493 
    494 /* The following is a workaround for RVCT toolchain; precompiler macros are not expanded before the code is passed to the assembler */
    495 
    496 /* The following section is a template to generate code for GeneratedJITStubs_RVCT.h */
    497 /* The pattern "#xxx#" will be replaced with "xxx" */
    498 
    499 /*
    500 RVCT(extern "C" #rtype# JITStubThunked_#op#(STUB_ARGS_DECLARATION);)
    501 RVCT(__asm #rtype# cti_#op#(STUB_ARGS_DECLARATION))
    502 RVCT({)
    503 RVCT(    PRESERVE8)
    504 RVCT(    IMPORT JITStubThunked_#op#)
    505 RVCT(    str lr, [sp, # THUNK_RETURN_ADDRESS_OFFSET])
    506 RVCT(    bl JITStubThunked_#op#)
    507 RVCT(    ldr lr, [sp, # THUNK_RETURN_ADDRESS_OFFSET])
    508 RVCT(    bx lr)
    509 RVCT(})
    510 RVCT()
    511 */
    512350
    513351/* Include the generated file */

  • trunk/Source/JavaScriptCore/jit/JITStubsMSVC64.asm

    r158586 r158751  
    2626EXTERN getHostCallReturnValueWithExecState : near
    2727
    28 PUBLIC ctiTrampoline
    29 PUBLIC ctiOpThrowNotCaught
    3028PUBLIC getHostCallReturnValue
    3129
    3230_TEXT   SEGMENT
    33 
    34 ctiTrampoline PROC
    35     ; Dump register parameters to their home address
    36     mov qword ptr[rsp+20h], r9
    37     mov qword ptr[rsp+18h], r8
    38     mov qword ptr[rsp+10h], rdx
    39     mov qword ptr[rsp+8h], rcx
    40 
    41     push rbp
    42     mov rbp, rax ; Save previous frame pointer
    43     mov rbp, rsp
    44     push r12
    45     push r13
    46     push r14
    47     push r15
    48     push rbx
    49 
    50     ; JIT operations can use up to 6 args (4 in registers and 2 on the stack).
    51     ; In addition, X86_64 ABI specifies that the worse case stack alignment
    52     ; requirement is 32 bytes. Based on these factors, we need to pad the stack
    53     ; and additional 28h bytes.
    54     sub rsp, 28h
    55     mov r12, 512
    56     mov r14, 0FFFF000000000000h
    57     mov r15, 0FFFF000000000002h
    58     mov r13, r8
    59     mov r11, qword ptr[r13] ; Put the previous frame pointer in the host call frame above us
    60     mov qword ptr[r11], rax
    61     call rcx
    62     add rsp, 28h
    63     pop rbx
    64     pop r15
    65     pop r14
    66     pop r13
    67     pop r12
    68     pop rbp
    69     ret
    70 ctiTrampoline ENDP
    71 
    72 ctiOpThrowNotCaught PROC
    73     add rsp, 28h
    74     pop rbx
    75     pop r15
    76     pop r14
    77     pop r13
    78     pop r12
    79     pop rbp
    80     ret
    81 ctiOpThrowNotCaught ENDP
    8231
    8332getHostCallReturnValue PROC

  • trunk/Source/JavaScriptCore/jit/JITStubsX86.h

    r158586 r158751  
    4646#if COMPILER(GCC)
    4747
    48 asm (
    49 ".text\n"
    50 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
    51 HIDE_SYMBOL(ctiTrampoline) "\n"
    52 SYMBOL_STRING(ctiTrampoline) ":" "\n"
    53     "pushl %ebp" "\n"
    54     "movl %ebp, %eax" "\n" // Save previous frame pointer
    55     "movl %esp, %ebp" "\n"
    56     "pushl %esi" "\n"
    57     "pushl %edi" "\n"
    58     "pushl %ebx" "\n"
    59 
    60     // JIT Operation can use up to 6 arguments right now. So, we need to
    61     // reserve space in this stack frame for the out-going args. To ensure that
    62     // the stack remains aligned on an 16 byte boundary, we round the padding up
    63     // by 0x1c bytes.
    64     "subl $0x1c, %esp" "\n"
    65     "movl 0x38(%esp), %edi" "\n"
    66     "movl (%edi), %ebx" "\n" // Put the previous frame pointer in the VM entry sentinal frame above us
    67     "movl %eax, (%ebx)" "\n"
    68     "call *0x30(%esp)" "\n"
    69     "addl $0x1c, %esp" "\n"
    70 
    71     "popl %ebx" "\n"
    72     "popl %edi" "\n"
    73     "popl %esi" "\n"
    74     "popl %ebp" "\n"
    75     "ret" "\n"
    76 );
    77 
    78 asm (
    79 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
    80 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
    81 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
    82     "addl $0x1c, %esp" "\n"
    83     "popl %ebx" "\n"
    84     "popl %edi" "\n"
    85     "popl %esi" "\n"
    86     "popl %ebp" "\n"
    87     "ret" "\n"
    88 );
    89 
    9048#if USE(MASM_PROBE)
    9149asm (
    … …  
    243201#endif // COMPILER(GCC)
    244202
    245 #if COMPILER(MSVC)
    246 
    247 extern "C" {
    248 
    249     __declspec(naked) EncodedJSValue ctiTrampoline(void* code, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, VM*)
    250     {
    251         __asm {
    252             push ebp;
    253             mov eax, ebp;
    254             mov ebp, esp;
    255             push esi;
    256             push edi;
    257             push ebx;
    258             sub esp, 0x1c;
    259             mov ecx, esp;
    260             mov edi, [esp + 0x38];
    261             mov ebx, [edi];
    262             mov [ebx], eax;
    263             call [esp + 0x30];
    264             add esp, 0x1c;
    265             pop ebx;
    266             pop edi;
    267             pop esi;
    268             pop ebp;
    269             ret;
    270         }
    271     }
    272 
    273     __declspec(naked) void ctiOpThrowNotCaught()
    274     {
    275         __asm {
    276             add esp, 0x1c;
    277             pop ebx;
    278             pop edi;
    279             pop esi;
    280             pop ebp;
    281             ret;
    282         }
    283     }
    284 }
    285 
    286 #endif // COMPILER(MSVC)
    287 
    288203} // namespace JSC
    289204

  • trunk/Source/JavaScriptCore/jit/JITStubsX86_64.h

    r158586 r158751  
    4646#if COMPILER(GCC)
    4747
    48 asm (
    49 ".text\n"
    50 ".globl " SYMBOL_STRING(ctiTrampoline) "\n"
    51 HIDE_SYMBOL(ctiTrampoline) "\n"
    52 SYMBOL_STRING(ctiTrampoline) ":" "\n"
    53     "pushq %rbp" "\n"
    54     "movq %rbp, %rax" "\n" // Save previous frame pointer
    55     "movq %rsp, %rbp" "\n"
    56     "pushq %r12" "\n"
    57     "pushq %r13" "\n"
    58     "pushq %r14" "\n"
    59     "pushq %r15" "\n"
    60     "pushq %rbx" "\n"
    61 
    62     // The X86_64 ABI specifies that the worse case stack alignment requirement
    63     // is 32 bytes.
    64     "subq $0x8, %rsp" "\n"
    65 
    66     "movq $512, %r12" "\n"
    67     "movq $0xFFFF000000000000, %r14" "\n"
    68     "movq $0xFFFF000000000002, %r15" "\n"
    69     "movq %rdx, %r13" "\n"
    70     "movq (%r13), %r11" "\n" // Put the previous frame pointer in the VM entry sentinal frame above us
    71     "movq %rax, (%r11)" "\n"
    72     "call *%rdi" "\n"
    73     "addq $0x8, %rsp" "\n"
    74     "popq %rbx" "\n"
    75     "popq %r15" "\n"
    76     "popq %r14" "\n"
    77     "popq %r13" "\n"
    78     "popq %r12" "\n"
    79     "popq %rbp" "\n"
    80     "ret" "\n"
    81 );
    82 
    83 asm (
    84 ".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
    85 HIDE_SYMBOL(ctiOpThrowNotCaught) "\n"
    86 SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
    87     "addq $0x8, %rsp" "\n"
    88     "popq %rbx" "\n"
    89     "popq %r15" "\n"
    90     "popq %r14" "\n"
    91     "popq %r13" "\n"
    92     "popq %r12" "\n"
    93     "popq %rbp" "\n"
    94     "ret" "\n"
    95 );
    96 
    9748#if USE(MASM_PROBE)
    9849asm (

  • trunk/Source/JavaScriptCore/jit/JSInterfaceJIT.h

    r158677 r158751  
    125125        static const RegisterID regT5 = ARMRegisters::r8;
    126126
    127         // Update ctiTrampoline in JITStubs.cpp if these values are changed!
    128127        static const RegisterID callFrameRegister = ARMRegisters::r5;
    129128

  • trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp

    r158315 r158751  
    5555    UNUSED_PARAM(pointerGPR);
    5656#endif
     57}
     58
     59static void returnFromJavaScript(CCallHelpers& jit)
     60{
     61#if CPU(X86_64)
     62#if OS(WINDOWS)
     63    // JIT operations can use up to 6 args (4 in registers and 2 on the stack).
     64    // In addition, X86_64 ABI specifies that the worse case stack alignment
     65    // requirement is 32 bytes. Based on these factors, we need to pad the stack
     66    // and additional 40 bytes.
     67#   define EXTRA_STACK_SIZE              40
     68    jit.addPtr(CCallHelpers::TrustedImm32(8), X86Registers::esp);
     69#else
     70    // We don't need extra stack space for out-going args, but we need to align the
     71    // stack to 32 byte alignment, therefore add 8 bytes to the stack.
     72#   define EXTRA_STACK_SIZE              8
     73    jit.addPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), X86Registers::esp);
     74#endif
     75
     76    jit.pop(X86Registers::ebx);
     77    jit.pop(X86Registers::r15);
     78    jit.pop(X86Registers::r14);
     79    jit.pop(X86Registers::r13);
     80    jit.pop(X86Registers::r12);
     81    jit.pop(X86Registers::ebp);
     82#elif CPU(X86)
     83    // JIT Operation can use up to 6 arguments right now. So, we need to
     84    // reserve space in this stack frame for the out-going args. To ensure that
     85    // the stack remains aligned on an 16 byte boundary, we round the padding up
     86    // by 28 bytes.
     87#   define EXTRA_STACK_SIZE 28
     88
     89    jit.addPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), X86Registers::esp);
     90
     91    jit.pop(X86Registers::ebx);
     92    jit.pop(X86Registers::edi);
     93    jit.pop(X86Registers::esi);
     94    jit.pop(X86Registers::ebp);
     95#elif CPU(ARM_TRADITIONAL)
     96    // JIT Operation can use up to 6 arguments right now. So, we need to
     97    // reserve space in this stack frame for the out-going args. We need to
     98    // add space for 16 more bytes.
     99#   define EXTRA_STACK_SIZE              16
     100
     101    jit.addPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), ARMRegisters::sp);
     102
     103    jit.pop(ARMRegisters::lr);
     104    jit.pop(ARMRegisters::r11);
     105    jit.pop(ARMRegisters::r10);
     106    jit.pop(ARMRegisters::r9);
     107    jit.pop(ARMRegisters::r8);
     108    jit.pop(ARMRegisters::r6);
     109    jit.pop(ARMRegisters::r5);
     110    jit.pop(ARMRegisters::r4);
     111#elif CPU(ARM_THUMB2)
     112    // JIT Operation can use up to 6 arguments right now. So, we need to
     113    // reserve space in this stack frame for the out-going args. To ensure that
     114    // the stack remains aligned on an 16 byte boundary, we round the padding up
     115    // by 28 bytes.
     116#   define EXTRA_STACK_SIZE              28
     117
     118    jit.addPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), ARMRegisters::sp);
     119    jit.push(ARMRegisters::r11);
     120    jit.push(ARMRegisters::r10);
     121    jit.push(ARMRegisters::r9);
     122    jit.push(ARMRegisters::r8);
     123    jit.push(ARMRegisters::r7);
     124    jit.push(ARMRegisters::r6);
     125    jit.push(ARMRegisters::r5);
     126    jit.push(ARMRegisters::r4);
     127    jit.push(ARMRegisters::lr);
     128#elif CPU(ARM64)
     129    jit.pop(ARM64Registers::x28);
     130    jit.pop(ARM64Registers::x27);
     131    jit.pop(ARM64Registers::x26);
     132    jit.pop(ARM64Registers::x25);
     133    jit.pop(ARM64Registers::x24);
     134    jit.pop(ARM64Registers::x23);
     135    jit.pop(ARM64Registers::x22);
     136    jit.pop(ARM64Registers::x21);
     137    jit.pop(ARM64Registers::x20);
     138    jit.pop(ARM64Registers::x19);
     139    jit.pop(ARM64Registers::lr);
     140#elif CPU(MIPS)
     141#   define PRESERVED_GP_OFFSET         60
     142#   define PRESERVED_S0_OFFSET         64
     143#   define PRESERVED_S1_OFFSET         68
     144#   define PRESERVED_S2_OFFSET         72
     145#   define PRESERVED_S3_OFFSET         76
     146#   define PRESERVED_S4_OFFSET         80
     147#   define PRESERVED_RETURN_ADDRESS_OFFSET 84
     148#   define STACK_LENGTH               112
     149
     150    jit.loadPtr(CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S0_OFFSET), MIPSRegisters::s0);
     151    jit.loadPtr(CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S1_OFFSET), MIPSRegisters::s1);
     152    jit.loadPtr(CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S2_OFFSET), MIPSRegisters::s2);
     153    jit.loadPtr(CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S3_OFFSET), MIPSRegisters::s3);
     154    jit.loadPtr(CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S4_OFFSET), MIPSRegisters::s4);
     155    jit.loadPtr(CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_RETURN_ADDRESS_OFFSET), MIPSRegisters::ra);
     156    jit.addPtr(CCallHelpers::TrustedImm32(STACK_LENGTH), MIPSRegisters::sp);
     157#elif CPU(SH4)
     158#   define EXTRA_STACK_SIZE 20
     159
     160    jit.addPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), SH4Registers::sp);
     161    jit.pop(SH4Registers::r8);
     162    jit.pop(SH4Registers::r9);
     163    jit.pop(SH4Registers::r10);
     164    jit.pop(SH4Registers::r11);
     165    jit.pop(SH4Registers::r13);
     166    jit.pop(SH4Registers::pr);
     167    jit.pop(SH4Registers::fp);
     168#endif
     169
     170    jit.ret();
     171}
     172
     173MacroAssemblerCodeRef callToJavaScript(VM* vm)
     174{
     175    // The signature of the code generated is EncodedJSValue callToJavaScript(void* code, CallFrame*)
     176
     177    CCallHelpers jit(vm);
     178
     179#if CPU(X86_64)
     180#if OS(WINDOWS)
     181    // Dump register parameters to their home address
     182    jit.storePtr(X86Registers::r9, CCallHelpers::Address(X86Registers::esp, 0x20));
     183    jit.storePtr(X86Registers::r8, CCallHelpers::Address(X86Registers::esp, 0x18));
     184    jit.storePtr(X86Registers::edx, CCallHelpers::Address(X86Registers::esp, 0x10));
     185    jit.storePtr(X86Registers::ecx, CCallHelpers::Address(X86Registers::esp, 0x8));
     186#endif // OS(WINDOWS)
     187    jit.push(X86Registers::ebp);
     188    jit.move(X86Registers::ebp, GPRInfo::nonArgGPR0);
     189    jit.move(X86Registers::esp, X86Registers::ebp);
     190    jit.push(X86Registers::r12);
     191    jit.push(X86Registers::r13);
     192    jit.push(X86Registers::r14);
     193    jit.push(X86Registers::r15);
     194    jit.push(X86Registers::ebx);
     195
     196    jit.subPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), X86Registers::esp);
     197
     198#   define CALLFRAME_SRC_REG GPRInfo::argumentGPR1
     199#   define PREVIOUS_CALLFRAME_REG GPRInfo::nonArgGPR0
     200#elif CPU(X86)
     201    jit.push(X86Registers::ebp);
     202    jit.move(X86Registers::ebp, GPRInfo::nonArgGPR0);
     203    jit.move(X86Registers::esp, X86Registers::ebp);
     204    jit.push(X86Registers::esi);
     205    jit.push(X86Registers::edi);
     206    jit.push(X86Registers::ebx);
     207
     208    jit.subPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), X86Registers::esp);
     209#if COMPILER(MSVC)
     210    jit.move(X86Registers::esp, X86Registers::ecx);
     211#endif
     212
     213    jit.load32(CCallHelpers::Address(X86Registers::esp, EXTRA_STACK_SIZE + 24), GPRInfo::callFrameRegister);
     214
     215#   define CALLFRAME_SRC_REG GPRInfo::callFrameRegister
     216#   define CALL_CODE jit.call(CCallHelpers::Address(X86Registers::esp, EXTRA_STACK_SIZE + 20))
     217#   define PREVIOUS_CALLFRAME_REG GPRInfo::nonArgGPR0
     218#elif CPU(ARM_TRADITIONAL)
     219    jit.push(ARMRegisters::r4);
     220    jit.push(ARMRegisters::r5);
     221    jit.push(ARMRegisters::r6);
     222    jit.push(ARMRegisters::r8);
     223    jit.push(ARMRegisters::r9);
     224    jit.push(ARMRegisters::r10);
     225    jit.push(ARMRegisters::r11);
     226    jit.push(ARMRegisters::lr);
     227
     228    jit.subPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), ARMRegisters::sp);
     229
     230#   define CALLFRAME_SRC_REG GPRInfo::argumentGPR1
     231#   define PREVIOUS_CALLFRAME_REG ARMRegisters::r11
     232#elif CPU(ARM_THUMB2)
     233    jit.push(ARMRegisters::lr);
     234    jit.push(ARMRegisters::r4);
     235    jit.push(ARMRegisters::r5);
     236    jit.push(ARMRegisters::r6);
     237    jit.push(ARMRegisters::r7);
     238    jit.push(ARMRegisters::r8);
     239    jit.push(ARMRegisters::r9);
     240    jit.push(ARMRegisters::r10);
     241    jit.push(ARMRegisters::r11);
     242    jit.subPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), ARMRegisters::sp);
     243
     244#   define CALLFRAME_SRC_REG GPRInfo::argumentGPR1
     245#   define PREVIOUS_CALLFRAME_REG ARMRegisters::r7
     246#elif CPU(ARM64)
     247    jit.push(ARM64Registers::lr);
     248    jit.push(ARM64Registers::x19);
     249    jit.push(ARM64Registers::x20);
     250    jit.push(ARM64Registers::x21);
     251    jit.push(ARM64Registers::x22);
     252    jit.push(ARM64Registers::x23);
     253    jit.push(ARM64Registers::x24);
     254    jit.push(ARM64Registers::x25);
     255    jit.push(ARM64Registers::x26);
     256    jit.push(ARM64Registers::x27);
     257    jit.push(ARM64Registers::x28);
     258    jit.push(ARM64Registers::x29);
     259
     260#   define CALLFRAME_SRC_REG GPRInfo::argumentGPR1
     261#   define PREVIOUS_CALLFRAME_REG ARM64Registers::x29
     262#elif CPU(MIPS)
     263    jit.subPtr(CCallHelpers::TrustedImm32(STACK_LENGTH), MIPSRegisters::sp);
     264    jit.storePtr(MIPSRegisters::ra, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_RETURN_ADDRESS_OFFSET));
     265    jit.storePtr(MIPSRegisters::s4, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S4_OFFSET));
     266    jit.storePtr(MIPSRegisters::s3, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S3_OFFSET));
     267    jit.storePtr(MIPSRegisters::s2, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S2_OFFSET));
     268    jit.storePtr(MIPSRegisters::s1, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S1_OFFSET));
     269    jit.storePtr(MIPSRegisters::s0, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S0_OFFSET));
     270#if WTF_MIPS_PIC
     271    jit.storePtr(MIPSRegisters::gp), CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_GP_OFFSET));
     272#endif
     273
     274#   define CALLFRAME_SRC_REG GPRInfo::argumentGPR1
     275#   define PREVIOUS_CALLFRAME_REG MIPSRegisters::fp
     276#elif CPU(SH4)
     277    jit.push(SH4Registers::fp);
     278    jit.push(SH4Registers::pr);
     279    jit.push(SH4Registers::r13);
     280    jit.push(SH4Registers::r11);
     281    jit.push(SH4Registers::r10);
     282    jit.push(SH4Registers::r9);
     283    jit.push(SH4Registers::r8);
     284    jit.subPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), SH4Registers::sp);
     285    jit.move(SH4Registers::fp, GPRInfo::nonArgGPR0);
     286
     287#   define CALLFRAME_SRC_REG GPRInfo::argumentGPR1
     288#   define PREVIOUS_CALLFRAME_REG GPRInfo::nonArgGPR0
     289#endif
     290
     291    if (CALLFRAME_SRC_REG != GPRInfo::callFrameRegister)
     292        jit.move(CALLFRAME_SRC_REG, GPRInfo::callFrameRegister);
     293    jit.loadPtr(CCallHelpers::Address(GPRInfo::callFrameRegister), GPRInfo::nonArgGPR1);
     294    jit.storePtr(PREVIOUS_CALLFRAME_REG, CCallHelpers::Address(GPRInfo::nonArgGPR1));
     295
     296#if USE(JSVALUE64)
     297    jit.move(CCallHelpers::TrustedImm64(0xffff000000000000L), GPRInfo::tagTypeNumberRegister);
     298    jit.move(CCallHelpers::TrustedImm64(0xffff000000000002L), GPRInfo::tagMaskRegister);
     299#endif
     300
     301#if defined(CALL_CODE)
     302    CALL_CODE;
     303#else
     304    jit.call(GPRInfo::argumentGPR0);
     305#endif
     306
     307#undef CALLFRAME_SRC_REG
     308#undef CALL_CODE
     309#undef PREVIOUS_CALLFRAME_REG
     310
     311    returnFromJavaScript(jit);
     312
     313    LinkBuffer patchBuffer(*vm, &jit, GLOBAL_THUNK_ID);
     314    return FINALIZE_CODE(patchBuffer, ("Call to JavaScript thunk"));
     315}
     316
     317MacroAssemblerCodeRef throwNotCaught(VM* vm)
     318{
     319    CCallHelpers jit(vm);
     320
     321    returnFromJavaScript(jit);
     322
     323    LinkBuffer patchBuffer(*vm, &jit, GLOBAL_THUNK_ID);
     324    return FINALIZE_CODE(patchBuffer, ("Uncaught throw thunk"));
    57325}
    58326

  • trunk/Source/JavaScriptCore/jit/ThunkGenerators.h

    r157480 r158751  
    3131#if ENABLE(JIT)
    3232namespace JSC {
     33
     34MacroAssemblerCodeRef callToJavaScript(VM*);
     35MacroAssemblerCodeRef throwNotCaught(VM*);
    3336
    3437MacroAssemblerCodeRef throwExceptionFromCallSlowPathGenerator(VM*);

  • trunk/Source/JavaScriptCore/runtime/VM.cpp

    r158586 r158751  
    258258#if ENABLE(JIT)
    259259    jitStubs = adoptPtr(new JITThunks());
     260
     261    callJavaScriptJITFunction = reinterpret_cast<CallJavaScriptJITFunction>(getCTIStub(callToJavaScript).code().executableAddress());
    260262#endif
    261263

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

    r158384 r158751  
    330330        }
    331331        NativeExecutable* getHostFunction(NativeFunction, Intrinsic);
     332
     333        typedef EncodedJSValue(*CallJavaScriptJITFunction)(void *, ExecState*);
     334
     335        CallJavaScriptJITFunction callJavaScriptJITFunction;
    332336#endif
    333337#if ENABLE(FTL_JIT)
Note: See TracChangeset for help on using the changeset viewer.