⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 157612 in webkit


Ignore:
Timestamp:
Oct 17, 2013, 4:29:16 PM (13 years ago)
Author:
ggaren@apple.com
Message:

Removed the JITStackFrame struct
​https://bugs.webkit.org/show_bug.cgi?id=123001

Reviewed by Anders Carlsson.

  • jit/JITStubs.h: JITStackFrame and JITStubArg are unused now, since all

our helper functions obey the C function call ABI.

Location:
trunk/Source/JavaScriptCore
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r157610 r157612  
     12013-10-17  Geoffrey Garen  <ggaren@apple.com>
     2
     3        Removed the JITStackFrame struct
     4        https://bugs.webkit.org/show_bug.cgi?id=123001
     5
     6        Reviewed by Anders Carlsson.
     7
     8        * jit/JITStubs.h: JITStackFrame and JITStubArg are unused now, since all
     9        our helper functions obey the C function call ABI.
     10
    1112013-10-17  Geoffrey Garen  <ggaren@apple.com>
    212

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

    r157610 r157612  
    6363class Structure;
    6464
    65 template <typename T> class Weak;
    66 
    67 union JITStubArg {
    68     void* asPointer;
    69     EncodedJSValue asEncodedJSValue;
    70     int32_t asInt32;
    71 
    72     JSValue jsValue() { return JSValue::decode(asEncodedJSValue); }
    73     JSObject* jsObject() { return static_cast<JSObject*>(asPointer); }
    74     Register* reg() { return static_cast<Register*>(asPointer); }
    75     Identifier& identifier() { return *static_cast<Identifier*>(asPointer); }
    76     int32_t int32() { return asInt32; }
    77     CodeBlock* codeBlock() { return static_cast<CodeBlock*>(asPointer); }
    78     FunctionExecutable* function() { return static_cast<FunctionExecutable*>(asPointer); }
    79     RegExp* regExp() { return static_cast<RegExp*>(asPointer); }
    80     JSPropertyNameIterator* propertyNameIterator() { return static_cast<JSPropertyNameIterator*>(asPointer); }
    81     JSGlobalObject* globalObject() { return static_cast<JSGlobalObject*>(asPointer); }
    82     JSString* jsString() { return static_cast<JSString*>(asPointer); }
    83     Structure* structure() { return static_cast<Structure*>(asPointer); }
    84     ReturnAddressPtr returnAddress() { return ReturnAddressPtr(asPointer); }
    85     ArrayAllocationProfile* arrayAllocationProfile() { return static_cast<ArrayAllocationProfile*>(asPointer); }
    86     Instruction* pc() { return static_cast<Instruction*>(asPointer); }
    87 };
    88    
    89 #if !OS(WINDOWS) && CPU(X86_64)
    90 struct JITStackFrame {
    91     void* reserved; // Unused
    92     JITStubArg args[6];
    93     void* padding[2]; // Maintain 32-byte stack alignment (possibly overkill).
    94 
    95     void* code;
    96     JSStack* stack;
    97     CallFrame* callFrame;
    98     void* unused1;
    99     void* unused2;
    100     VM* vm;
    101 
    102     void* savedRBX;
    103     void* savedR15;
    104     void* savedR14;
    105     void* savedR13;
    106     void* savedR12;
    107     void* savedRBP;
    108     void* savedRIP;
    109 
    110     // When JIT code makes a call, it pushes its return address just below the rest of the stack.
    111     ReturnAddressPtr* returnAddressSlot() { return reinterpret_cast<ReturnAddressPtr*>(this) - 1; }
    112 };
    113 #elif CPU(ARM64)
    114 struct JITStackFrame {
    115     JITStubArg args[6];
    116 
    117     ReturnAddressPtr thunkReturnAddress;
    118 
    119     void* preservedReturnAddress;
    120     void* preservedX19;
    121     void* preservedX20;
    122     void* preservedX21;
    123     void* preservedX22;
    124     void* preservedX23;
    125     void* preservedX24;
    126     void* preservedX25;
    127     void* preservedX26;
    128     void* preservedX27;
    129     void* preservedX28;
    130 
    131     JSStack* stack;
    132     CallFrame* callFrame;
    133     LegacyProfiler** enabledProfilerReference;
    134     VM* vm;
    135    
    136     ReturnAddressPtr* returnAddressSlot() { return &thunkReturnAddress; }
    137 };
    138 #elif OS(WINDOWS) && CPU(X86_64)
    139 struct JITStackFrame {
    140     void* shadow[4]; // Shadow space reserved for a callee's parameters home addresses
    141     void* reserved; // Unused, also maintains the 16-bytes stack alignment
    142     JITStubArg args[6];
    143 
    144     void* savedRBX;
    145     void* savedR15;
    146     void* savedR14;
    147     void* savedR13;
    148     void* savedR12;
    149     void* savedRBP;
    150     void* savedRIP;
    151 
    152     // Home addresses for our register passed parameters
    153     // http://msdn.microsoft.com/en-us/library/ew5tede7.aspx
    154     void* code;
    155     JSStack* stack;
    156     CallFrame* callFrame;
    157     void* unused1;
    158 
    159     // Passed on the stack
    160     void* unused2;
    161     VM* vm;
    162 
    163     // When JIT code makes a call, it pushes its return address just below the rest of the stack.
    164     ReturnAddressPtr* returnAddressSlot() { return reinterpret_cast<ReturnAddressPtr*>(this) - 1; }
    165 };
    166 #elif CPU(X86)
    167 #if COMPILER(MSVC) || (OS(WINDOWS) && COMPILER(GCC))
    168 #pragma pack(push)
    169 #pragma pack(4)
    170 #endif // COMPILER(MSVC) || (OS(WINDOWS) && COMPILER(GCC))
    171 struct JITStackFrame {
    172     void* reserved; // Unused
    173     JITStubArg args[6];
    174 #if USE(JSVALUE32_64)
    175     void* padding[2]; // Maintain 16-byte stack alignment.
    176 #endif
    177 
    178     void* savedEBX;
    179     void* savedEDI;
    180     void* savedESI;
    181     void* savedEBP;
    182     void* savedEIP;
    183 
    184     void* code;
    185     JSStack* stack;
    186     CallFrame* callFrame;
    187     void* unused1;
    188     void* unused2;
    189     VM* vm;
    190        
    191     // When JIT code makes a call, it pushes its return address just below the rest of the stack.
    192     ReturnAddressPtr* returnAddressSlot() { return reinterpret_cast<ReturnAddressPtr*>(this) - 1; }
    193 };
    194 #if COMPILER(MSVC) || (OS(WINDOWS) && COMPILER(GCC))
    195 #pragma pack(pop)
    196 #endif // COMPILER(MSVC) || (OS(WINDOWS) && COMPILER(GCC))
    197 #elif CPU(ARM_THUMB2)
    198 struct JITStackFrame {
    199     JITStubArg reserved; // Unused
    200     JITStubArg args[6];
    201 
    202     ReturnAddressPtr thunkReturnAddress;
    203 
    204     void* preservedReturnAddress;
    205     void* preservedR4;
    206     void* preservedR5;
    207     void* preservedR6;
    208     void* preservedR7;
    209     void* preservedR8;
    210     void* preservedR9;
    211     void* preservedR10;
    212     void* preservedR11;
    213 
    214     // These arguments passed in r1..r3 (r0 contained the entry code pointed, which is not preserved)
    215     JSStack* stack;
    216     CallFrame* callFrame;
    217 
    218     // These arguments passed on the stack.
    219     void* unused1;
    220     VM* vm;
    221        
    222     ReturnAddressPtr* returnAddressSlot() { return &thunkReturnAddress; }
    223 };
    224 #elif CPU(ARM_TRADITIONAL)
    225 #if COMPILER(MSVC)
    226 #pragma pack(push)
    227 #pragma pack(4)
    228 #endif // COMPILER(MSVC)
    229 struct JITStackFrame {
    230     JITStubArg padding; // Unused
    231     JITStubArg args[7];
    232 
    233     ReturnAddressPtr thunkReturnAddress;
    234 
    235     void* preservedR4;
    236     void* preservedR5;
    237     void* preservedR6;
    238     void* preservedR8;
    239     void* preservedR9;
    240     void* preservedR10;
    241     void* preservedR11;
    242     void* preservedLink;
    243 
    244     JSStack* stack;
    245     CallFrame* callFrame;
    246     void* unused1;
    247 
    248     // These arguments passed on the stack.
    249     void* unused2;
    250     VM* vm;
    251 
    252     // When JIT code makes a call, it pushes its return address just below the rest of the stack.
    253     ReturnAddressPtr* returnAddressSlot() { return &thunkReturnAddress; }
    254 };
    255 #if COMPILER(MSVC)
    256 #pragma pack(pop)
    257 #endif // COMPILER(MSVC)
    258 #elif CPU(MIPS)
    259 struct JITStackFrame {
    260     JITStubArg reserved; // Unused
    261     JITStubArg args[6];
    262 
    263 #if USE(JSVALUE32_64)
    264     void* padding; // Make the overall stack length 8-byte aligned.
    265 #endif
    266 
    267     void* preservedGP; // store GP when using PIC code
    268     void* preservedS0;
    269     void* preservedS1;
    270     void* preservedS2;
    271     void* preservedS3;
    272     void* preservedS4;
    273     void* preservedReturnAddress;
    274 
    275     ReturnAddressPtr thunkReturnAddress;
    276 
    277     // These arguments passed in a1..a3 (a0 contained the entry code pointed, which is not preserved)
    278     JSStack* stack;
    279     CallFrame* callFrame;
    280     void* unused1;
    281 
    282     // These arguments passed on the stack.
    283     void* unused2;
    284     VM* vm;
    285 
    286     ReturnAddressPtr* returnAddressSlot() { return &thunkReturnAddress; }
    287 };
    288 #elif CPU(SH4)
    289 struct JITStackFrame {
    290     JITStubArg padding; // Unused
    291     JITStubArg args[6];
    292 
    293     ReturnAddressPtr thunkReturnAddress;
    294 
    295     void* savedR8;
    296     void* savedR9;
    297     void* savedR10;
    298     void* savedR11;
    299     void* savedR13;
    300     void* savedRPR;
    301     void* savedR14;
    302 
    303     // These arguments are passed in r5, r6 and r7.
    304     JSStack* stack;
    305     CallFrame* callFrame;
    306     void* unused1;
    307 
    308     // These arguments are passed on the stack.
    309     void* unused2;
    310     VM* vm;
    311 
    312     ReturnAddressPtr* returnAddressSlot() { return &thunkReturnAddress; }
    313 };
    314 #else
    315 #error "JITStackFrame not defined for this platform."
    316 #endif
    317 
    31865#define STUB_ARGS_DECLARATION void** args
    31966#define STUB_ARGS (args)
Note: See TracChangeset for help on using the changeset viewer.