Ignore:
Timestamp:
Dec 20, 2008, 2:11:31 AM (16 years ago)
Author:
[email protected]
Message:

2008-12-20 Gavin Barraclough <​[email protected]>

Reviewed by Oliver Hunt.

Port optimized property access generation to the MacroAssembler.

  • assembler/MacroAssembler.h: (JSC::MacroAssembler::AbsoluteAddress::AbsoluteAddress): (JSC::MacroAssembler::DataLabelPtr::repatch): (JSC::MacroAssembler::DataLabel32::DataLabel32): (JSC::MacroAssembler::DataLabel32::repatch): (JSC::MacroAssembler::Label::operator X86Assembler::JmpDst): (JSC::MacroAssembler::Jump::repatch): (JSC::MacroAssembler::JumpList::empty): (JSC::MacroAssembler::RepatchBuffer::link): (JSC::MacroAssembler::add32): (JSC::MacroAssembler::and32): (JSC::MacroAssembler::sub32): (JSC::MacroAssembler::loadPtrWithAddressRepatch): (JSC::MacroAssembler::storePtrWithAddressRepatch): (JSC::MacroAssembler::push): (JSC::MacroAssembler::ja32): (JSC::MacroAssembler::jePtr): (JSC::MacroAssembler::jnePtr): (JSC::MacroAssembler::jnePtrWithRepatch): (JSC::MacroAssembler::align): (JSC::MacroAssembler::differenceBetween):
  • assembler/X86Assembler.h: (JSC::X86Assembler::movl_rm_disp32): (JSC::X86Assembler::movl_mr_disp32): (JSC::X86Assembler::X86InstructionFormatter::oneByteOp_disp32): (JSC::X86Assembler::X86InstructionFormatter::memoryModRM):
  • jit/JIT.cpp: (JSC::ctiRepatchCallByReturnAddress): (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompile): (JSC::JIT::privateCompileCTIMachineTrampolines):
  • jit/JIT.h:
  • jit/JITPropertyAccess.cpp: (JSC::JIT::compileGetByIdHotPath): (JSC::JIT::compileGetByIdSlowCase): (JSC::JIT::compilePutByIdHotPath): (JSC::JIT::compilePutByIdSlowCase): (JSC::resizePropertyStorage): (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::patchGetByIdSelf): (JSC::JIT::patchPutByIdReplace): (JSC::JIT::privateCompilePatchGetArrayLength): (JSC::JIT::privateCompileGetByIdSelf): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdSelfList): (JSC::JIT::privateCompileGetByIdProtoList): (JSC::JIT::privateCompileGetByIdChainList): (JSC::JIT::privateCompileGetByIdChain): (JSC::JIT::privateCompilePutByIdReplace):
  • wtf/RefCounted.h: (WTF::RefCountedBase::addressOfCount):
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/assembler/MacroAssembler.h

    r39389 r39422  
    120120    // Describes a complex addressing mode.
    121121    struct BaseIndex {
    122         BaseIndex(RegisterID base, RegisterID index, int32_t offset = 0)
    123             : base(base)
    124             , index(index)
    125             , scale(TimesOne)
    126             , offset(offset)
    127         {
    128         }
    129 
    130122        BaseIndex(RegisterID base, RegisterID index, Scale scale, int32_t offset = 0)
    131123            : base(base)
    … …  
    142134    };
    143135
     136    // AbsoluteAddress:
     137    //
     138    // Describes an memory operand given by a pointer.  For regular load & store
     139    // operations an unwrapped void* will be used, rather than using this.
     140    struct AbsoluteAddress {
     141        explicit AbsoluteAddress(void* ptr)
     142            : m_ptr(ptr)
     143        {
     144        }
     145
     146        void* m_ptr;
     147    };
     148
    144149
    145150    class Jump;
    … …  
    163168        {
    164169        }
     170
     171#if !PLATFORM(X86_64)
     172        static void repatch(void* address, void* value)
     173        {
     174            X86Assembler::repatchImmediate(reinterpret_cast<intptr_t>(address), reinterpret_cast<uint32_t>(value));
     175        }
     176#endif
     177
     178    private:
     179        X86Assembler::JmpDst m_label;
     180    };
     181
     182    // DataLabel32:
     183    //
     184    // A DataLabelPtr is used to refer to a location in the code containing a pointer to be
     185    // repatched after the code has been generated.
     186    class DataLabel32 {
     187        friend class MacroAssembler;
     188        friend class RepatchBuffer;
     189
     190    public:
     191        DataLabel32()
     192        {
     193        }
     194
     195        DataLabel32(MacroAssembler* masm)
     196            : m_label(masm->m_assembler.label())
     197        {
     198        }
     199
     200#if !PLATFORM(X86_64)
     201        static void repatch(void* address, int32_t value)
     202        {
     203            X86Assembler::repatchImmediate(reinterpret_cast<intptr_t>(address), value);
     204        }
     205#endif
    165206
    166207    private:
    … …  
    186227        {
    187228        }
     229       
     230        // FIXME: transitionary method, while we replace JmpSrces with Jumps.
     231        operator X86Assembler::JmpDst()
     232        {
     233            return m_label;
     234        }
    188235
    189236    private:
    … …  
    238285        }
    239286
     287        static void repatch(void* address, void* destination)
     288        {
     289            X86Assembler::repatchBranchOffset(reinterpret_cast<intptr_t>(address), destination);
     290        }
     291
    240292    private:
    241293        X86Assembler::JmpSrc m_jmp;
    … …  
    247299    // All jumps in the set will be linked to the same destination.
    248300    class JumpList {
     301        friend class RepatchBuffer;
     302
    249303    public:
    250304        void link(MacroAssembler* masm)
    … …  
    274328        }
    275329
     330        bool empty()
     331        {
     332            return !m_jumps.size();
     333        }
     334
    276335    private:
    277         Vector<Jump> m_jumps;
     336        Vector<Jump, 16> m_jumps;
    278337    };
    279338
    … …  
    307366            X86Assembler::link(m_code, jump.m_jmp, target);
    308367        }
    309        
     368
     369        void link(JumpList list, void* target)
     370        {
     371            for (unsigned i = 0; i < list.m_jumps.size(); ++i)
     372                X86Assembler::link(m_code, list.m_jumps[i], target);
     373        }
     374
    310375        void* addressOf(Jump jump)
    311376        {
    312377            return X86Assembler::getRelocatedAddress(m_code, jump.m_jmp);
    313378        }
    314        
     379
    315380        void* addressOf(Label label)
    316381        {
    … …  
    389454    }
    390455   
     456#if !PLATFORM(X86_64)
     457    void add32(Imm32 imm, AbsoluteAddress address)
     458    {
     459        m_assembler.addl_im(imm.m_value, address.m_ptr);
     460    }
     461#endif
     462   
    391463    void add32(Address src, RegisterID dest)
    392464    {
    … …  
    394466    }
    395467   
     468    void andPtr(RegisterID src, RegisterID dest)
     469    {
     470#if PLATFORM(X86_64)
     471        m_assembler.andq_rr(src, dest);
     472#else
     473        and32(src, dest);
     474#endif
     475    }
     476
     477    void andPtr(Imm32 imm, RegisterID srcDest)
     478    {
     479#if PLATFORM(X86_64)
     480        m_assembler.andq_ir(imm.m_value, srcDest);
     481#else
     482        and32(imm, srcDest);
     483#endif
     484    }
     485
    396486    void and32(RegisterID src, RegisterID dest)
    397487    {
    … …  
    402492    {
    403493        m_assembler.andl_ir(imm.m_value, dest);
    404     }
    405 
    406     void andPtr(RegisterID src, RegisterID dest)
    407     {
    408 #if PLATFORM(X86_64)
    409         m_assembler.andq_rr(src, dest);
    410 #else
    411         and32(src, dest);
    412 #endif
    413     }
    414 
    415     void andPtr(Imm32 imm, RegisterID srcDest)
    416     {
    417 #if PLATFORM(X86_64)
    418         m_assembler.andq_ir(imm.m_value, srcDest);
    419 #else
    420         and32(imm, srcDest);
    421 #endif
    422494    }
    423495
    … …  
    524596    }
    525597   
     598#if !PLATFORM(X86_64)
     599    void sub32(Imm32 imm, AbsoluteAddress address)
     600    {
     601        m_assembler.subl_im(imm.m_value, address.m_ptr);
     602    }
     603#endif
     604   
    526605    void sub32(Address src, RegisterID dest)
    527606    {
    … …  
    564643#endif
    565644    }
     645
     646#if !PLATFORM(X86_64)
     647    DataLabel32 loadPtrWithAddressRepatch(Address address, RegisterID dest)
     648    {
     649        m_assembler.movl_mr_disp32(address.offset, address.base, dest);
     650        return DataLabel32(this);
     651    }
     652#endif
    566653
    567654    void loadPtr(BaseIndex address, RegisterID dest)
    … …  
    628715    }
    629716
     717#if !PLATFORM(X86_64)
     718    DataLabel32 storePtrWithAddressRepatch(RegisterID src, Address address)
     719    {
     720        m_assembler.movl_rm_disp32(src, address.offset, address.base);
     721        return DataLabel32(this);
     722    }
     723#endif
     724
    630725    void storePtr(RegisterID src, BaseIndex address)
    631726    {
    … …  
    704799    {
    705800        m_assembler.push_r(src);
     801    }
     802
     803    void push(Address address)
     804    {
     805        m_assembler.push_m(address.offset, address.base);
     806    }
     807
     808    void push(Imm32 imm)
     809    {
     810        m_assembler.push_i32(imm.m_value);
    706811    }
    707812
    … …  
    880985
    881986public:
     987    Jump ja32(RegisterID left, Imm32 right)
     988    {
     989        compareImm32ForBranch(left, right.m_value);
     990        return Jump(m_assembler.ja());
     991    }
     992   
    882993    Jump jae32(RegisterID left, Imm32 right)
    883994    {
    … …  
    9141025    }
    9151026
     1027    Jump jePtr(RegisterID reg, ImmPtr imm)
     1028    {
     1029#if PLATFORM(X86_64)
     1030        move(imm, scratchRegister);
     1031        return jePtr(scratchRegister, reg);
     1032#else
     1033        return je32(reg, Imm32(reinterpret_cast<int32_t>(imm.m_value)));
     1034#endif
     1035    }
     1036
    9161037    Jump je32(RegisterID op1, RegisterID op2)
    9171038    {
    … …  
    10311152#endif
    10321153    }
     1154
     1155#if !PLATFORM(X86_64)
     1156    Jump jnePtr(AbsoluteAddress address, ImmPtr imm)
     1157    {
     1158        m_assembler.cmpl_im(reinterpret_cast<uint32_t>(imm.m_value), address.m_ptr);
     1159        return Jump(m_assembler.jne());
     1160    }
     1161#endif
     1162
     1163#if !PLATFORM(X86_64)
     1164    Jump jnePtrWithRepatch(Address address, DataLabelPtr& dataLabel, ImmPtr initialValue = ImmPtr(0))
     1165    {
     1166        m_assembler.cmpl_im_force32(reinterpret_cast<int32_t>(initialValue.m_value), address.offset, address.base);
     1167        dataLabel = DataLabelPtr(this);
     1168        return Jump(m_assembler.jne());
     1169    }
     1170#endif
    10331171
    10341172    Jump jne32(RegisterID op1, RegisterID op2)
    … …  
    12971435        return Label(this);
    12981436    }
     1437   
     1438    Label align()
     1439    {
     1440        m_assembler.align(16);
     1441        return Label(this);
     1442    }
     1443
     1444    ptrdiff_t differenceBetween(Label from, Jump to)
     1445    {
     1446        return X86Assembler::getDifferenceBetweenLabels(from.m_label, to.m_jmp);
     1447    }
     1448
     1449    ptrdiff_t differenceBetween(Label from, Label to)
     1450    {
     1451        return X86Assembler::getDifferenceBetweenLabels(from.m_label, to.m_label);
     1452    }
     1453
     1454    ptrdiff_t differenceBetween(Label from, DataLabelPtr to)
     1455    {
     1456        return X86Assembler::getDifferenceBetweenLabels(from.m_label, to.m_label);
     1457    }
     1458
     1459    ptrdiff_t differenceBetween(Label from, DataLabel32 to)
     1460    {
     1461        return X86Assembler::getDifferenceBetweenLabels(from.m_label, to.m_label);
     1462    }
    12991463
    13001464    void ret()
Note: See TracChangeset for help on using the changeset viewer.