Ignore:
Timestamp:
Dec 21, 2008, 5:00:07 PM (16 years ago)
Author:
[email protected]
Message:

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

Reviewed by Oliver Hunt & Cameron Zwarich.

Add support for call and property access repatching on x86-64.

No change in performance on current configurations (2x impovement on v8-tests with JIT enabled on x86-64).

  • assembler/MacroAssembler.h: (JSC::MacroAssembler::DataLabelPtr::repatch): (JSC::MacroAssembler::DataLabelPtr::operator X86Assembler::JmpDst): (JSC::MacroAssembler::DataLabel32::repatch): (JSC::MacroAssembler::RepatchBuffer::addressOf): (JSC::MacroAssembler::add32): (JSC::MacroAssembler::sub32): (JSC::MacroAssembler::loadPtrWithAddressOffsetRepatch): (JSC::MacroAssembler::storePtrWithAddressOffsetRepatch): (JSC::MacroAssembler::jePtr): (JSC::MacroAssembler::jnePtr): (JSC::MacroAssembler::jnePtrWithRepatch): (JSC::MacroAssembler::differenceBetween):
  • assembler/X86Assembler.h: (JSC::X86Assembler::addl_im): (JSC::X86Assembler::subl_im): (JSC::X86Assembler::cmpl_rm): (JSC::X86Assembler::movq_rm_disp32): (JSC::X86Assembler::movq_mr_disp32): (JSC::X86Assembler::repatchPointer): (JSC::X86Assembler::X86InstructionFormatter::oneByteOp64_disp32):
  • jit/JIT.cpp: (JSC::JIT::privateCompile): (JSC::JIT::privateCompileCTIMachineTrampolines):
  • jit/JIT.h:
  • jit/JITCall.cpp: (JSC::JIT::unlinkCall): (JSC::JIT::linkCall): (JSC::JIT::compileOpCall): (JSC::JIT::compileOpCallSlowCase):
  • jit/JITInlineMethods.h: (JSC::JIT::restoreArgumentReferenceForTrampoline):
  • jit/JITPropertyAccess.cpp: (JSC::JIT::compileGetByIdHotPath): (JSC::JIT::compileGetByIdSlowCase): (JSC::JIT::compilePutByIdHotPath): (JSC::JIT::compilePutByIdSlowCase): (JSC::resizePropertyStorage): (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdProtoList): (JSC::JIT::privateCompileGetByIdChainList): (JSC::JIT::privateCompileGetByIdChain):
  • wtf/Platform.h:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/assembler/MacroAssembler.h

    r39422 r39428  
    169169        }
    170170
    171 #if !PLATFORM(X86_64)
    172171        static void repatch(void* address, void* value)
    173172        {
    174             X86Assembler::repatchImmediate(reinterpret_cast<intptr_t>(address), reinterpret_cast<uint32_t>(value));
    175         }
    176 #endif
    177 
     173            X86Assembler::repatchPointer(reinterpret_cast<intptr_t>(address), reinterpret_cast<intptr_t>(value));
     174        }
     175       
    178176    private:
    179177        X86Assembler::JmpDst m_label;
    … …  
    198196        }
    199197
    200 #if !PLATFORM(X86_64)
    201198        static void repatch(void* address, int32_t value)
    202199        {
    203200            X86Assembler::repatchImmediate(reinterpret_cast<intptr_t>(address), value);
    204201        }
    205 #endif
    206202
    207203    private:
    … …  
    383379        }
    384380
     381        void* addressOf(DataLabelPtr label)
     382        {
     383            return X86Assembler::getRelocatedAddress(m_code, label.m_label);
     384        }
     385
     386        void* addressOf(DataLabel32 label)
     387        {
     388            return X86Assembler::getRelocatedAddress(m_code, label.m_label);
     389        }
     390
    385391        void setPtr(DataLabelPtr label, void* value)
    386392        {
    … …  
    449455    }
    450456
     457    void add32(Imm32 imm, Address address)
     458    {
     459        m_assembler.addl_im(imm.m_value, address.offset, address.base);
     460    }
     461
    451462    void add32(Imm32 imm, RegisterID dest)
    452463    {
    … …  
    454465    }
    455466   
    456 #if !PLATFORM(X86_64)
    457467    void add32(Imm32 imm, AbsoluteAddress address)
    458468    {
     469#if PLATFORM(X86_64)
     470        move(ImmPtr(address.m_ptr), scratchRegister);
     471        add32(imm, Address(scratchRegister));
     472#else
    459473        m_assembler.addl_im(imm.m_value, address.m_ptr);
    460     }
    461 #endif
     474#endif
     475    }
    462476   
    463477    void add32(Address src, RegisterID dest)
    … …  
    596610    }
    597611   
    598 #if !PLATFORM(X86_64)
     612    void sub32(Imm32 imm, Address address)
     613    {
     614        m_assembler.subl_im(imm.m_value, address.offset, address.base);
     615    }
     616
    599617    void sub32(Imm32 imm, AbsoluteAddress address)
    600618    {
     619#if PLATFORM(X86_64)
     620        move(ImmPtr(address.m_ptr), scratchRegister);
     621        sub32(imm, Address(scratchRegister));
     622#else
    601623        m_assembler.subl_im(imm.m_value, address.m_ptr);
    602     }
    603 #endif
    604    
     624#endif
     625    }
     626
    605627    void sub32(Address src, RegisterID dest)
    606628    {
    … …  
    644666    }
    645667
    646 #if !PLATFORM(X86_64)
    647     DataLabel32 loadPtrWithAddressRepatch(Address address, RegisterID dest)
    648     {
     668    DataLabel32 loadPtrWithAddressOffsetRepatch(Address address, RegisterID dest)
     669    {
     670#if PLATFORM(X86_64)
     671        m_assembler.movq_mr_disp32(address.offset, address.base, dest);
     672        return DataLabel32(this);
     673#else
    649674        m_assembler.movl_mr_disp32(address.offset, address.base, dest);
    650675        return DataLabel32(this);
    651     }
    652 #endif
     676#endif
     677    }
    653678
    654679    void loadPtr(BaseIndex address, RegisterID dest)
    … …  
    715740    }
    716741
    717 #if !PLATFORM(X86_64)
    718     DataLabel32 storePtrWithAddressRepatch(RegisterID src, Address address)
    719     {
     742    DataLabel32 storePtrWithAddressOffsetRepatch(RegisterID src, Address address)
     743    {
     744#if PLATFORM(X86_64)
     745        m_assembler.movq_rm_disp32(src, address.offset, address.base);
     746        return DataLabel32(this);
     747#else
    720748        m_assembler.movl_rm_disp32(src, address.offset, address.base);
    721749        return DataLabel32(this);
    722     }
    723 #endif
     750#endif
     751    }
    724752
    725753    void storePtr(RegisterID src, BaseIndex address)
    … …  
    10251053    }
    10261054
     1055    Jump jePtr(RegisterID reg, Address address)
     1056    {
     1057#if PLATFORM(X86_64)
     1058        m_assembler.cmpq_rm(reg, address.offset, address.base);
     1059#else
     1060        m_assembler.cmpl_rm(reg, address.offset, address.base);
     1061#endif
     1062        return Jump(m_assembler.je());
     1063    }
     1064
    10271065    Jump jePtr(RegisterID reg, ImmPtr imm)
    10281066    {
    … …  
    10351073    }
    10361074
     1075    Jump jePtr(Address address, ImmPtr imm)
     1076    {
     1077#if PLATFORM(X86_64)
     1078        move(imm, scratchRegister);
     1079        return jePtr(scratchRegister, address);
     1080#else
     1081        return je32(address, Imm32(reinterpret_cast<int32_t>(imm.m_value)));
     1082#endif
     1083    }
     1084
    10371085    Jump je32(RegisterID op1, RegisterID op2)
    10381086    {
    … …  
    11331181    }
    11341182
     1183    Jump jnePtr(RegisterID reg, AbsoluteAddress address)
     1184    {
     1185#if PLATFORM(X86_64)
     1186        move(ImmPtr(address.m_ptr), scratchRegister);
     1187        return jnePtr(reg, Address(scratchRegister));
     1188#else
     1189        m_assembler.cmpl_rm(reg, address.m_ptr);
     1190        return Jump(m_assembler.jne());
     1191#endif
     1192    }
     1193
    11351194    Jump jnePtr(RegisterID reg, ImmPtr imm)
    11361195    {
    … …  
    11611220#endif
    11621221
    1163 #if !PLATFORM(X86_64)
     1222    Jump jnePtrWithRepatch(RegisterID reg, DataLabelPtr& dataLabel, ImmPtr initialValue = ImmPtr(0))
     1223    {
     1224#if PLATFORM(X86_64)
     1225        m_assembler.movq_i64r(reinterpret_cast<int64_t>(initialValue.m_value), scratchRegister);
     1226        dataLabel = DataLabelPtr(this);
     1227        return jnePtr(scratchRegister, reg);
     1228#else
     1229        m_assembler.cmpl_ir_force32(reinterpret_cast<int32_t>(initialValue.m_value), reg);
     1230        dataLabel = DataLabelPtr(this);
     1231        return Jump(m_assembler.jne());
     1232#endif
     1233    }
     1234
    11641235    Jump jnePtrWithRepatch(Address address, DataLabelPtr& dataLabel, ImmPtr initialValue = ImmPtr(0))
    11651236    {
     1237#if PLATFORM(X86_64)
     1238        m_assembler.movq_i64r(reinterpret_cast<int64_t>(initialValue.m_value), scratchRegister);
     1239        dataLabel = DataLabelPtr(this);
     1240        return jnePtr(scratchRegister, address);
     1241#else
    11661242        m_assembler.cmpl_im_force32(reinterpret_cast<int32_t>(initialValue.m_value), address.offset, address.base);
    11671243        dataLabel = DataLabelPtr(this);
    11681244        return Jump(m_assembler.jne());
    1169     }
    1170 #endif
     1245#endif
     1246    }
    11711247
    11721248    Jump jne32(RegisterID op1, RegisterID op2)
    … …  
    14621538    }
    14631539
     1540    ptrdiff_t differenceBetween(DataLabelPtr from, Jump to)
     1541    {
     1542        return X86Assembler::getDifferenceBetweenLabels(from.m_label, to.m_jmp);
     1543    }
     1544
    14641545    void ret()
    14651546    {
Note: See TracChangeset for help on using the changeset viewer.