Changeset 80938 in webkit


Ignore:
Timestamp:
Mar 12, 2011 7:54:17 AM (13 years ago)
Author:
loislo@chromium.org
Message:

2011-03-12 Sheriff Bot <​webkit.review.bot@gmail.com>

Unreviewed, rolling out r80919.
​http://trac.webkit.org/changeset/80919
​https://bugs.webkit.org/show_bug.cgi?id=56251

all windows bots failed to compile this change (Requested by
loislo on #webkit).

  • JavaScriptCore.xcodeproj/project.pbxproj:
  • bytecode/StructureStubInfo.cpp:
  • interpreter/Register.h: (JSC::Register::withInt): (JSC::Register::withCallee): (JSC::Register::operator=): (JSC::Register::i): (JSC::Register::activation): (JSC::Register::function): (JSC::Register::propertyNameIterator): (JSC::Register::scopeChain):
  • jit/JIT.h:
  • jit/JITCall.cpp: (JSC::JIT::compileOpCallInitializeCallFrame): (JSC::JIT::compileOpCallVarargs): (JSC::JIT::compileOpCall):
  • jit/JITCall32_64.cpp: (JSC::JIT::compileOpCallInitializeCallFrame): (JSC::JIT::compileOpCallVarargs): (JSC::JIT::compileOpCall): (JSC::JIT::compileOpCallSlowCase):
  • jit/JITInlineMethods.h: (JSC::JIT::emitPutToCallFrameHeader):
  • jit/JITOpcodes.cpp: (JSC::JIT::privateCompileCTINativeCall): (JSC::JIT::emit_op_get_pnames): (JSC::JIT::emit_op_next_pname): (JSC::JIT::emit_op_load_varargs): (JSC::JIT::emitSlow_op_load_varargs):
  • jit/JITOpcodes32_64.cpp: (JSC::JIT::privateCompileCTINativeCall): (JSC::JIT::emit_op_get_pnames): (JSC::JIT::emit_op_next_pname):
  • jit/JSInterfaceJIT.h: (JSC::JSInterfaceJIT::payloadFor):
  • jit/SpecializedThunkJIT.h: (JSC::SpecializedThunkJIT::returnJSValue): (JSC::SpecializedThunkJIT::returnDouble): (JSC::SpecializedThunkJIT::returnInt32): (JSC::SpecializedThunkJIT::returnJSCell):
  • runtime/ArgList.cpp:
  • runtime/DateConversion.cpp:
  • runtime/GCActivityCallbackCF.cpp:
  • runtime/Identifier.cpp:
  • runtime/JSActivation.h: (JSC::asActivation):
  • runtime/JSLock.cpp:
  • runtime/JSNumberCell.cpp:
  • runtime/JSObject.h:
  • runtime/JSPropertyNameIterator.h:
  • runtime/JSValue.h:
  • runtime/JSZombie.cpp:
  • runtime/MarkedBlock.cpp:
  • runtime/MarkedSpace.cpp:
  • runtime/PropertyNameArray.cpp:
  • runtime/ScopeChain.h: (JSC::ExecState::globalThisValue):
  • wtf/DateMath.cpp:

2011-03-12 Sheriff Bot <​webkit.review.bot@gmail.com>

Unreviewed, rolling out r80919.
​http://trac.webkit.org/changeset/80919
​https://bugs.webkit.org/show_bug.cgi?id=56251

all windows bots failed to compile this change (Requested by
loislo on #webkit).

  • bridge/c/c_class.cpp:
  • bridge/c/c_runtime.cpp:
  • bridge/jni/JavaMethod.cpp:
  • plugins/PluginViewNone.cpp:
Location:
trunk/Source
Files:
33 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r80919 r80938  
     12011-03-12  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r80919.
     4        http://trac.webkit.org/changeset/80919
     5        https://bugs.webkit.org/show_bug.cgi?id=56251
     6
     7        all windows bots failed to compile this change (Requested by
     8        loislo on #webkit).
     9
     10        * JavaScriptCore.xcodeproj/project.pbxproj:
     11        * bytecode/StructureStubInfo.cpp:
     12        * interpreter/Register.h:
     13        (JSC::Register::withInt):
     14        (JSC::Register::withCallee):
     15        (JSC::Register::operator=):
     16        (JSC::Register::i):
     17        (JSC::Register::activation):
     18        (JSC::Register::function):
     19        (JSC::Register::propertyNameIterator):
     20        (JSC::Register::scopeChain):
     21        * jit/JIT.h:
     22        * jit/JITCall.cpp:
     23        (JSC::JIT::compileOpCallInitializeCallFrame):
     24        (JSC::JIT::compileOpCallVarargs):
     25        (JSC::JIT::compileOpCall):
     26        * jit/JITCall32_64.cpp:
     27        (JSC::JIT::compileOpCallInitializeCallFrame):
     28        (JSC::JIT::compileOpCallVarargs):
     29        (JSC::JIT::compileOpCall):
     30        (JSC::JIT::compileOpCallSlowCase):
     31        * jit/JITInlineMethods.h:
     32        (JSC::JIT::emitPutToCallFrameHeader):
     33        * jit/JITOpcodes.cpp:
     34        (JSC::JIT::privateCompileCTINativeCall):
     35        (JSC::JIT::emit_op_get_pnames):
     36        (JSC::JIT::emit_op_next_pname):
     37        (JSC::JIT::emit_op_load_varargs):
     38        (JSC::JIT::emitSlow_op_load_varargs):
     39        * jit/JITOpcodes32_64.cpp:
     40        (JSC::JIT::privateCompileCTINativeCall):
     41        (JSC::JIT::emit_op_get_pnames):
     42        (JSC::JIT::emit_op_next_pname):
     43        * jit/JSInterfaceJIT.h:
     44        (JSC::JSInterfaceJIT::payloadFor):
     45        * jit/SpecializedThunkJIT.h:
     46        (JSC::SpecializedThunkJIT::returnJSValue):
     47        (JSC::SpecializedThunkJIT::returnDouble):
     48        (JSC::SpecializedThunkJIT::returnInt32):
     49        (JSC::SpecializedThunkJIT::returnJSCell):
     50        * runtime/ArgList.cpp:
     51        * runtime/DateConversion.cpp:
     52        * runtime/GCActivityCallbackCF.cpp:
     53        * runtime/Identifier.cpp:
     54        * runtime/JSActivation.h:
     55        (JSC::asActivation):
     56        * runtime/JSLock.cpp:
     57        * runtime/JSNumberCell.cpp:
     58        * runtime/JSObject.h:
     59        * runtime/JSPropertyNameIterator.h:
     60        * runtime/JSValue.h:
     61        * runtime/JSZombie.cpp:
     62        * runtime/MarkedBlock.cpp:
     63        * runtime/MarkedSpace.cpp:
     64        * runtime/PropertyNameArray.cpp:
     65        * runtime/ScopeChain.h:
     66        (JSC::ExecState::globalThisValue):
     67        * wtf/DateMath.cpp:
     68
    1692011-03-11  Oliver Hunt  <oliver@apple.com>
    270

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

    r80919 r80938  
    25452545                        buildConfigurationList = 149C277108902AFE008A9EFC /* Build configuration list for PBXProject "JavaScriptCore" */;
    25462546                        compatibilityVersion = "Xcode 3.1";
    2547                         developmentRegion = English;
    25482547                        hasScannedForEncodings = 1;
    25492548                        knownRegions = (

  • trunk/Source/JavaScriptCore/bytecode/StructureStubInfo.cpp

    r80919 r80938  
    2727#include "StructureStubInfo.h"
    2828
    29 #include "JSObject.h"
    3029#include "ScopeChain.h"
    3130

  • trunk/Source/JavaScriptCore/interpreter/Register.h

    r80919 r80938  
    5555        Register& operator=(const JSValue&);
    5656        JSValue jsValue() const;
    57 
     57       
     58        Register& operator=(JSActivation*);
    5859        Register& operator=(CallFrame*);
    5960        Register& operator=(CodeBlock*);
     61        Register& operator=(JSPropertyNameIterator*);
    6062        Register& operator=(ScopeChainNode*);
    6163        Register& operator=(Instruction*);
    … …  
    7274        static Register withInt(int32_t i)
    7375        {
    74             Register r = jsNumber(i);
     76            Register r;
     77            r.u.i = i;
    7578            return r;
    7679        }
    7780
    78         static inline Register withCallee(JSObject* callee);
     81        static Register withCallee(JSObject* callee)
     82        {
     83            Register r;
     84            r.u.function = callee;
     85            return r;
     86        }
    7987
    8088    private:
    8189        union {
     90            int32_t i;
    8291            EncodedJSValue value;
     92
     93            JSActivation* activation;
    8394            CallFrame* callFrame;
    8495            CodeBlock* codeBlock;
     96            JSObject* function;
     97            JSPropertyNameIterator* propertyNameIterator;
     98            ScopeChainNode* scopeChain;
    8599            Instruction* vPC;
    86100        } u;
    … …  
    118132    // Interpreter functions
    119133
     134    ALWAYS_INLINE Register& Register::operator=(JSActivation* activation)
     135    {
     136        u.activation = activation;
     137        return *this;
     138    }
     139
    120140    ALWAYS_INLINE Register& Register::operator=(CallFrame* callFrame)
    121141    {
    … …  
    136156    }
    137157
     158    ALWAYS_INLINE Register& Register::operator=(ScopeChainNode* scopeChain)
     159    {
     160        u.scopeChain = scopeChain;
     161        return *this;
     162    }
     163
     164    ALWAYS_INLINE Register& Register::operator=(JSPropertyNameIterator* propertyNameIterator)
     165    {
     166        u.propertyNameIterator = propertyNameIterator;
     167        return *this;
     168    }
     169
    138170    ALWAYS_INLINE int32_t Register::i() const
    139171    {
    140         return jsValue().asInt32();
    141     }
    142 
     172        return u.i;
     173    }
     174   
     175    ALWAYS_INLINE JSActivation* Register::activation() const
     176    {
     177        return u.activation;
     178    }
     179   
    143180    ALWAYS_INLINE CallFrame* Register::callFrame() const
    144181    {
    … …  
    150187        return u.codeBlock;
    151188    }
    152 
     189   
     190    ALWAYS_INLINE JSObject* Register::function() const
     191    {
     192        return u.function;
     193    }
     194   
     195    ALWAYS_INLINE JSPropertyNameIterator* Register::propertyNameIterator() const
     196    {
     197        return u.propertyNameIterator;
     198    }
     199   
     200    ALWAYS_INLINE ScopeChainNode* Register::scopeChain() const
     201    {
     202        return u.scopeChain;
     203    }
     204   
    153205    ALWAYS_INLINE Instruction* Register::vPC() const
    154206    {

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

    r80919 r80938  
    854854
    855855        void emitPutToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry);
    856         void emitPutCellToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry);
    857         void emitPutIntToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry);
    858856        void emitPutImmediateToCallFrameHeader(void* value, RegisterFile::CallFrameHeaderEntry entry);
    859857        void emitGetFromCallFrameHeaderPtr(RegisterFile::CallFrameHeaderEntry entry, RegisterID to, RegisterID from = callFrameRegister);

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

    r80919 r80938  
    4949void JIT::compileOpCallInitializeCallFrame()
    5050{
    51     // regT0 holds callee, regT1 holds argCount
    52     loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scopeChain)), regT3); // scopeChain
    53     emitPutIntToCallFrameHeader(regT1, RegisterFile::ArgumentCount);
    54     emitPutCellToCallFrameHeader(regT0, RegisterFile::Callee);
    55     emitPutCellToCallFrameHeader(regT3, RegisterFile::ScopeChain);
     51    store32(regT1, Address(callFrameRegister, RegisterFile::ArgumentCount * static_cast<int>(sizeof(Register))));
     52    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scopeChain)), regT3); // newScopeChain
     53    storePtr(regT0, Address(callFrameRegister, RegisterFile::Callee * static_cast<int>(sizeof(Register))));
     54    storePtr(regT3, Address(callFrameRegister, RegisterFile::ScopeChain * static_cast<int>(sizeof(Register))));
    5655}
    5756
    … …  
    6968
    7069    emitGetVirtualRegister(argCountRegister, regT1);
    71     emitFastArithImmToInt(regT1);
    7270    emitGetVirtualRegister(callee, regT0);
    7371    addPtr(Imm32(registerOffset), regT1, regT2);
    … …  
    202200
    203201    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scopeChain)), regT1); // newScopeChain
    204    
    205     store32(Imm32(Int32Tag), intTagFor(registerOffset + RegisterFile::ArgumentCount));
    206     store32(Imm32(argCount), intPayloadFor(registerOffset + RegisterFile::ArgumentCount));
     202
     203    store32(Imm32(argCount), Address(callFrameRegister, (registerOffset + RegisterFile::ArgumentCount) * static_cast<int>(sizeof(Register))));
    207204    storePtr(callFrameRegister, Address(callFrameRegister, (registerOffset + RegisterFile::CallerFrame) * static_cast<int>(sizeof(Register))));
    208205    storePtr(regT0, Address(callFrameRegister, (registerOffset + RegisterFile::Callee) * static_cast<int>(sizeof(Register))));

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

    r80919 r80938  
    5050{
    5151    // regT0 holds callee, regT1 holds argCount
     52    store32(regT1, Address(callFrameRegister, RegisterFile::ArgumentCount * static_cast<int>(sizeof(Register))));
    5253    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scopeChain)), regT3); // scopeChain
    53     emitPutIntToCallFrameHeader(regT1, RegisterFile::ArgumentCount);
    54     emitPutCellToCallFrameHeader(regT0, RegisterFile::Callee);
    55     emitPutCellToCallFrameHeader(regT3, RegisterFile::ScopeChain);
     54    storePtr(regT0, Address(callFrameRegister, RegisterFile::Callee * static_cast<int>(sizeof(Register)))); // callee
     55    storePtr(regT3, Address(callFrameRegister, RegisterFile::ScopeChain * static_cast<int>(sizeof(Register)))); // scopeChain
    5656}
    5757
    … …  
    7878    mul32(Imm32(sizeof(Register)), regT3, regT3);
    7979    addPtr(callFrameRegister, regT3);
    80     store32(Imm32(JSValue::CellTag), tagFor(RegisterFile::CallerFrame, regT3));
    81     storePtr(callFrameRegister, payloadFor(RegisterFile::CallerFrame, regT3));
     80    storePtr(callFrameRegister, Address(regT3, RegisterFile::CallerFrame * static_cast<int>(sizeof(Register))));
    8281    move(regT3, callFrameRegister);
    8382
    … …  
    210209
    211210    // Speculatively roll the callframe, assuming argCount will match the arity.
    212     store32(Imm32(JSValue::CellTag), tagFor(RegisterFile::CallerFrame + registerOffset, callFrameRegister));
    213     storePtr(callFrameRegister, payloadFor(RegisterFile::CallerFrame + registerOffset, callFrameRegister));
     211    storePtr(callFrameRegister, Address(callFrameRegister, (RegisterFile::CallerFrame + registerOffset) * static_cast<int>(sizeof(Register))));
    214212    addPtr(Imm32(registerOffset * static_cast<int>(sizeof(Register))), callFrameRegister);
    215213    move(Imm32(argCount), regT1);
    … …  
    283281    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scopeChain)), regT2);
    284282
    285     store32(Imm32(JSValue::Int32Tag), tagFor(registerOffset + RegisterFile::ArgumentCount));
    286     store32(Imm32(argCount), payloadFor(registerOffset + RegisterFile::ArgumentCount));
    287     storePtr(callFrameRegister, payloadFor(RegisterFile::CallerFrame + registerOffset, callFrameRegister));
     283    store32(Imm32(argCount), Address(callFrameRegister, (registerOffset + RegisterFile::ArgumentCount) * static_cast<int>(sizeof(Register))));
     284    storePtr(callFrameRegister, Address(callFrameRegister, (registerOffset + RegisterFile::CallerFrame) * static_cast<int>(sizeof(Register))));
    288285    emitStore(registerOffset + RegisterFile::Callee, regT1, regT0);
    289     store32(Imm32(JSValue::CellTag), tagFor(registerOffset + RegisterFile::ScopeChain));
    290     store32(regT2, payloadFor(registerOffset + RegisterFile::ScopeChain));
     286    storePtr(regT2, Address(callFrameRegister, (registerOffset + RegisterFile::ScopeChain) * static_cast<int>(sizeof(Register))));
    291287    addPtr(Imm32(registerOffset * sizeof(Register)), callFrameRegister);
    292288
    … …  
    314310
    315311    // Speculatively roll the callframe, assuming argCount will match the arity.
    316     store32(Imm32(JSValue::CellTag), tagFor(RegisterFile::CallerFrame + registerOffset, callFrameRegister));
    317     storePtr(callFrameRegister, payloadFor(RegisterFile::CallerFrame + registerOffset, callFrameRegister));
     312    storePtr(callFrameRegister, Address(callFrameRegister, (RegisterFile::CallerFrame + registerOffset) * static_cast<int>(sizeof(Register))));
    318313    addPtr(Imm32(registerOffset * static_cast<int>(sizeof(Register))), callFrameRegister);
    319314    move(Imm32(argCount), regT1);

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

    r80919 r80938  
    5353ALWAYS_INLINE void JIT::emitPutToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
    5454{
    55     storePtr(from, payloadFor(entry, callFrameRegister));
    56 }
    57 
    58 ALWAYS_INLINE void JIT::emitPutCellToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
    59 {
    60 #if USE(JSVALUE32_64)
    61     store32(Imm32(JSValue::CellTag), tagFor(entry, callFrameRegister));
    62 #endif
    63     storePtr(from, payloadFor(entry, callFrameRegister));
    64 }
    65 
    66 ALWAYS_INLINE void JIT::emitPutIntToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
    67 {
    68     store32(Imm32(Int32Tag), intTagFor(entry, callFrameRegister));
    69     store32(from, intPayloadFor(entry, callFrameRegister));
     55    storePtr(from, Address(callFrameRegister, entry * sizeof(Register)));
    7056}
    7157

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

    r80919 r80938  
    200200    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
    201201    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
    202     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     202    emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);
    203203
    204204    peek(regT1);
    … …  
    223223    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);
    224224    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT2);
    225     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     225    emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);
    226226
    227227    preserveReturnAddressAfterCall(regT3); // Callee preserved
    … …  
    244244    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
    245245    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
    246     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     246    emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);
    247247
    248248    preserveReturnAddressAfterCall(regT3); // Callee preserved
    … …  
    903903    getPnamesStubCall.call(dst);
    904904    load32(Address(regT0, OBJECT_OFFSETOF(JSPropertyNameIterator, m_jsStringsSize)), regT3);
    905     storePtr(tagTypeNumberRegister, payloadFor(i));
    906     store32(Imm32(Int32Tag), intTagFor(size));
    907     store32(regT3, intPayloadFor(size));
     905    store32(Imm32(0), addressFor(i));
     906    store32(regT3, addressFor(size));
    908907    Jump end = jump();
    909908
    … …  
    933932
    934933    Label begin(this);
    935     load32(intPayloadFor(i), regT0);
    936     Jump end = branch32(Equal, regT0, intPayloadFor(size));
     934    load32(addressFor(i), regT0);
     935    Jump end = branch32(Equal, regT0, addressFor(size));
    937936
    938937    // Grab key @ i
    … …  
    946945    // Increment i
    947946    add32(Imm32(1), regT0);
    948     store32(regT0, intPayloadFor(i));
     947    store32(regT0, addressFor(i));
    949948
    950949    // Verify that i is valid:
    … …  
    16911690    // Load arg count into regT0
    16921691    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT0);
    1693     store32(Imm32(Int32Tag), intTagFor(argCountDst));
    1694     store32(regT0, intPayloadFor(argCountDst));
     1692    storePtr(regT0, addressFor(argCountDst));
    16951693    Jump endBranch = branch32(Equal, regT0, Imm32(1));
    16961694
    … …  
    17301728    stubCall.addArgument(Imm32(argsOffset));
    17311729    stubCall.call();
    1732    
    1733     store32(Imm32(Int32Tag), intTagFor(argCountDst));
    1734     store32(returnValueRegister, intPayloadFor(argCountDst));
     1730    // Stores a naked int32 in the register file.
     1731    store32(returnValueRegister, Address(callFrameRegister, argCountDst * sizeof(Register)));
    17351732}
    17361733

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

    r80919 r80938  
    206206    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
    207207    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
    208     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     208    emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);
    209209
    210210    peek(regT1);
    … …  
    230230    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);
    231231    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT2);
    232     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     232    emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);
    233233
    234234    preserveReturnAddressAfterCall(regT3); // Callee preserved
    … …  
    252252    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
    253253    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
    254     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     254    emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);
    255255
    256256    preserveReturnAddressAfterCall(regT3); // Callee preserved
    … …  
    322322    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
    323323    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
    324     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     324    emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);
    325325
    326326    peek(regT1);
    … …  
    345345    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);
    346346    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT2);
    347     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     347    emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);
    348348
    349349    preserveReturnAddressAfterCall(regT3); // Callee preserved
    … …  
    368368    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
    369369    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
    370     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     370    emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);
    371371
    372372    preserveReturnAddressAfterCall(regT3); // Callee preserved
    … …  
    12771277    getPnamesStubCall.call(dst);
    12781278    load32(Address(regT0, OBJECT_OFFSETOF(JSPropertyNameIterator, m_jsStringsSize)), regT3);
    1279     store32(Imm32(Int32Tag), intTagFor(i));
    1280     store32(Imm32(0), intPayloadFor(i));
    1281     store32(Imm32(Int32Tag), intTagFor(size));
    1282     store32(regT3, payloadFor(size));
     1279    store32(Imm32(0), addressFor(i));
     1280    store32(regT3, addressFor(size));
    12831281    Jump end = jump();
    12841282
    … …  
    13061304
    13071305    Label begin(this);
    1308     load32(intPayloadFor(i), regT0);
    1309     Jump end = branch32(Equal, regT0, intPayloadFor(size));
     1306    load32(addressFor(i), regT0);
     1307    Jump end = branch32(Equal, regT0, addressFor(size));
    13101308
    13111309    // Grab key @ i
    1312     loadPtr(payloadFor(it), regT1);
     1310    loadPtr(addressFor(it), regT1);
    13131311    loadPtr(Address(regT1, OBJECT_OFFSETOF(JSPropertyNameIterator, m_jsStrings)), regT2);
    13141312    load32(BaseIndex(regT2, regT0, TimesEight), regT2);
    … …  
    13181316    // Increment i
    13191317    add32(Imm32(1), regT0);
    1320     store32(regT0, intPayloadFor(i));
     1318    store32(regT0, addressFor(i));
    13211319
    13221320    // Verify that i is valid:
    1323     loadPtr(payloadFor(base), regT0);
     1321    loadPtr(addressFor(base), regT0);
    13241322
    13251323    // Test base's structure

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

    r80919 r80938  
    3030#include "JITStubs.h"
    3131#include "JSImmediate.h"
    32 #include "JSValue.h"
    3332#include "MacroAssembler.h"
    3433#include "RegisterFile.h"
    … …  
    159158#endif
    160159
    161 #if USE(JSVALUE32_64)
    162         static const unsigned Int32Tag = JSValue::Int32Tag;
    163 #else
    164         static const unsigned Int32Tag = JSImmediate::TagTypeNumber >> 32;
    165 #endif
    166160        inline Jump emitLoadJSCell(unsigned virtualRegisterIndex, RegisterID payload);
    167161        inline Jump emitLoadInt32(unsigned virtualRegisterIndex, RegisterID dst);
    … …  
    180174
    181175        inline Address payloadFor(unsigned index, RegisterID base = callFrameRegister);
    182         inline Address intPayloadFor(unsigned index, RegisterID base = callFrameRegister);
    183         inline Address intTagFor(unsigned index, RegisterID base = callFrameRegister);
    184176        inline Address addressFor(unsigned index, RegisterID base = callFrameRegister);
    185177    };
    … …  
    221213        ASSERT(static_cast<int>(virtualRegisterIndex) < FirstConstantRegisterIndex);
    222214        return Address(base, (virtualRegisterIndex * sizeof(Register)) + OBJECT_OFFSETOF(JSValue, u.asBits.payload));
    223     }
    224 
    225     inline JSInterfaceJIT::Address JSInterfaceJIT::intPayloadFor(unsigned virtualRegisterIndex, RegisterID base)
    226     {
    227         return payloadFor(virtualRegisterIndex, base);
    228     }
    229 
    230     inline JSInterfaceJIT::Address JSInterfaceJIT::intTagFor(unsigned virtualRegisterIndex, RegisterID base)
    231     {
    232         return tagFor(virtualRegisterIndex, base);
    233215    }
    234216
    … …  
    298280        return addressFor(virtualRegisterIndex, base);
    299281    }
    300 
    301     inline JSInterfaceJIT::Address JSInterfaceJIT::intPayloadFor(unsigned virtualRegisterIndex, RegisterID base)
    302     {
    303         ASSERT(static_cast<int>(virtualRegisterIndex) < FirstConstantRegisterIndex);
    304         return Address(base, (virtualRegisterIndex * sizeof(Register)) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload));
    305     }
    306     inline JSInterfaceJIT::Address JSInterfaceJIT::intTagFor(unsigned virtualRegisterIndex, RegisterID base)
    307     {
    308         ASSERT(static_cast<int>(virtualRegisterIndex) < FirstConstantRegisterIndex);
    309         return Address(base, (virtualRegisterIndex * sizeof(Register)) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag));
    310     }
    311282#endif
    312283

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

    r80919 r80938  
    8888            if (src != regT0)
    8989                move(src, regT0);
    90             loadPtr(payloadFor(RegisterFile::CallerFrame, callFrameRegister), callFrameRegister);
     90            loadPtr(Address(callFrameRegister, RegisterFile::CallerFrame * (int)sizeof(Register)), callFrameRegister);
    9191            ret();
    9292        }
    … …  
    102102            loadPtr(Address(stackPointerRegister, OBJECT_OFFSETOF(JSValue, u.asBits.payload) - sizeof(double)), regT0);
    103103#endif
    104             loadPtr(payloadFor(RegisterFile::CallerFrame, callFrameRegister), callFrameRegister);
     104            loadPtr(Address(callFrameRegister, RegisterFile::CallerFrame * (int)sizeof(Register)), callFrameRegister);
    105105            ret();
    106106        }
    … …  
    111111                move(src, regT0);
    112112            tagReturnAsInt32();
    113             loadPtr(payloadFor(RegisterFile::CallerFrame, callFrameRegister), callFrameRegister);
     113            loadPtr(Address(callFrameRegister, RegisterFile::CallerFrame * (int)sizeof(Register)), callFrameRegister);
    114114            ret();
    115115        }
    … …  
    120120                move(src, regT0);
    121121            tagReturnAsJSCell();
    122             loadPtr(payloadFor(RegisterFile::CallerFrame, callFrameRegister), callFrameRegister);
     122            loadPtr(Address(callFrameRegister, RegisterFile::CallerFrame * (int)sizeof(Register)), callFrameRegister);
    123123            ret();
    124124        }

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

    r80919 r80938  
    2424#include "JSValue.h"
    2525#include "JSCell.h"
    26 #include "JSObject.h"
    2726#include "ScopeChain.h"
    2827

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

    r80919 r80938  
    4545
    4646#include "CallFrame.h"
    47 #include "JSObject.h"
    4847#include "ScopeChain.h"
    4948#include "UString.h"

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

    r80919 r80938  
    3434#include "JSGlobalData.h"
    3535#include "JSLock.h"
    36 #include "JSObject.h"
    3736#include "ScopeChain.h"
    3837#include <wtf/RetainPtr.h>

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

    r80919 r80938  
    2323
    2424#include "CallFrame.h"
    25 #include "JSObject.h"
    2625#include "NumericStrings.h"
    2726#include "ScopeChain.h"

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

    r80919 r80938  
    9292        return static_cast<JSActivation*>(asObject(value));
    9393    }
    94    
    95     ALWAYS_INLINE JSActivation* Register::activation() const
    96     {
    97         return asActivation(jsValue());
    98     }
    9994
    10095} // namespace JSC

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

    r80919 r80938  
    2424#include "Heap.h"
    2525#include "CallFrame.h"
    26 #include "JSObject.h"
    2726#include "ScopeChain.h"
    2827

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

    r80919 r80938  
    2323#include "config.h"
    2424#include "JSNumberCell.h"
    25 #include "JSObject.h"
    2625#include "ScopeChain.h"
    2726

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

    r80919 r80938  
    841841}
    842842
    843 ALWAYS_INLINE JSObject* Register::function() const
    844 {
    845     if (!jsValue())
    846         return 0;
    847     return asObject(jsValue());
    848 }
    849 
    850 ALWAYS_INLINE Register Register::withCallee(JSObject* callee)
    851 {
    852     Register r;
    853     r = JSValue(callee);
    854     return r;
    855 }
    856 
    857843} // namespace JSC
    858844

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

    r80919 r80938  
    107107    }
    108108
    109     ALWAYS_INLINE JSPropertyNameIterator* Register::propertyNameIterator() const
    110     {
    111         return static_cast<JSPropertyNameIterator*>(jsValue().asCell());
    112     }
    113 
    114109} // namespace JSC
    115110

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

    r80919 r80938  
    5353    enum PreferredPrimitiveType { NoPreference, PreferNumber, PreferString };
    5454
    55 
    5655#if USE(JSVALUE32_64)
    5756    typedef int64_t EncodedJSValue;
    … …  
    5958    typedef void* EncodedJSValue;
    6059#endif
    61    
    62     union EncodedValueDescriptor {
    63         EncodedJSValue asEncodedJSValue;
    64 #if USE(JSVALUE32_64)
    65         double asDouble;
    66 #elif USE(JSVALUE64)
    67         JSCell* ptr;
    68 #endif
    69        
    70 #if CPU(BIG_ENDIAN)
    71         struct {
    72             int32_t tag;
    73             int32_t payload;
    74         } asBits;
    75 #else
    76         struct {
    77             int32_t payload;
    78             int32_t tag;
    79         } asBits;
    80 #endif
    81     };
    8260
    8361    double nonInlineNaN();
    … …  
    262240       
    263241        enum { LowestTag =  DeletedValueTag };
    264 
     242       
    265243        uint32_t tag() const;
    266244        int32_t payload() const;
    267245
    268         EncodedValueDescriptor u;
    269 #elif USE(JSVALUE64)
     246        union {
     247            EncodedJSValue asEncodedJSValue;
     248            double asDouble;
     249#if CPU(BIG_ENDIAN)
     250            struct {
     251                int32_t tag;
     252                int32_t payload;
     253            } asBits;
     254#else
     255            struct {
     256                int32_t payload;
     257                int32_t tag;
     258            } asBits;
     259#endif
     260        } u;
     261#else // USE(JSVALUE32_64)
    270262        JSCell* m_ptr;
    271 #endif
     263#endif // USE(JSVALUE32_64)
    272264    };
    273265

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

    r80919 r80938  
    2727#include "JSZombie.h"
    2828#include "ClassInfo.h"
    29 #include "JSObject.h"
    3029#include "ScopeChain.h"
    3130

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

    r80919 r80938  
    2828
    2929#include "JSCell.h"
    30 #include "JSObject.h"
    3130#include "JSZombie.h"
    3231#include "ScopeChain.h"

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

    r80919 r80938  
    2525#include "JSGlobalData.h"
    2626#include "JSLock.h"
    27 #include "JSObject.h"
    2827#include "ScopeChain.h"
    2928

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

    r80919 r80938  
    2222#include "PropertyNameArray.h"
    2323
    24 #include "JSObject.h"
    2524#include "ScopeChain.h"
    2625#include "Structure.h"

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

    r80919 r80938  
    129129        return scopeChain()->globalThis.get();
    130130    }
    131    
    132     ALWAYS_INLINE ScopeChainNode* Register::scopeChain() const
    133     {
    134         return static_cast<ScopeChainNode*>(jsValue().asCell());
    135     }
    136    
    137     ALWAYS_INLINE Register& Register::operator=(ScopeChainNode* scopeChain)
    138     {
    139         *this = JSValue(scopeChain);
    140         return *this;
    141     }
    142131
    143132} // namespace JSC

  • trunk/Source/JavaScriptCore/wtf/DateMath.cpp

    r80919 r80938  
    7676#include "ASCIICType.h"
    7777#include "CurrentTime.h"
    78 #if USE(JSC)
    79 #include "JSObject.h"
    80 #endif
    8178#include "MathExtras.h"
    8279#if USE(JSC)

  • trunk/Source/WebCore/ChangeLog

    r80937 r80938  
     12011-03-12  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r80919.
     4        http://trac.webkit.org/changeset/80919
     5        https://bugs.webkit.org/show_bug.cgi?id=56251
     6
     7        all windows bots failed to compile this change (Requested by
     8        loislo on #webkit).
     9
     10        * bridge/c/c_class.cpp:
     11        * bridge/c/c_runtime.cpp:
     12        * bridge/jni/JavaMethod.cpp:
     13        * plugins/PluginViewNone.cpp:
     14
    1152011-03-12  Patrick Gansterer  <paroga@webkit.org>
    216

  • trunk/Source/WebCore/bridge/c/c_class.cpp

    r80919 r80938  
    3636#include <runtime/Identifier.h>
    3737#include <runtime/JSLock.h>
    38 #include <runtime/JSObject.h>
    3938#include <wtf/text/StringHash.h>
    4039

  • trunk/Source/WebCore/bridge/c/c_runtime.cpp

    r80919 r80938  
    3535#include <runtime/ScopeChain.h>
    3636#include <runtime/JSLock.h>
    37 #include <runtime/JSObject.h>
    3837
    3938namespace JSC {

  • trunk/Source/WebCore/bridge/jni/JavaMethod.cpp

    r80919 r80938  
    3232#include "JavaString.h"
    3333
    34 #include <runtime/JSObject.h>
    3534#include <runtime/ScopeChain.h>
    3635#include <wtf/text/StringBuilder.h>

  • trunk/Source/WebCore/plugins/PluginViewNone.cpp

    r80919 r80938  
    2929#if USE(JSC)
    3030#include "BridgeJSC.h"
    31 #include <runtime/JSObject.h>
    3231#include <runtime/ScopeChain.h>
    3332#endif
Note: See TracChangeset for help on using the changeset viewer.