Changeset 58091 in webkit


Ignore:
Timestamp:
Apr 22, 2010 6:24:56 AM (14 years ago)
Author:
eric@webkit.org
Message:

2010-04-22 Gabor Loki <loki@webkit.org>

Reviewed by Gavin Barraclough.

Use BLX and BX to keep happy the return stack predictor above ARMv4
https://bugs.webkit.org/show_bug.cgi?id=37862

Inspired by Jacob Bramley's patch from JaegerMonkey

  • assembler/ARMAssembler.cpp: (JSC::ARMAssembler::executableCopy):
  • assembler/ARMAssembler.h: (JSC::ARMAssembler::): (JSC::ARMAssembler::bx): (JSC::ARMAssembler::blx): (JSC::ARMAssembler::loadBranchTarget): (JSC::ARMAssembler::jmp): (JSC::ARMAssembler::getLdrImmAddress):
  • assembler/MacroAssemblerARM.h: (JSC::MacroAssemblerARM::jump): (JSC::MacroAssemblerARM::nearCall): (JSC::MacroAssemblerARM::call): (JSC::MacroAssemblerARM::ret): (JSC::MacroAssemblerARM::prepareCall): (JSC::MacroAssemblerARM::call32):
Location:
trunk/JavaScriptCore
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/JavaScriptCore/ChangeLog

    r58045 r58091  
     12010-04-22  Gabor Loki  <loki@webkit.org>
     2
     3        Reviewed by Gavin Barraclough.
     4
     5        Use BLX and BX to keep happy the return stack predictor above ARMv4
     6        https://bugs.webkit.org/show_bug.cgi?id=37862
     7
     8        Inspired by Jacob Bramley's patch from JaegerMonkey
     9
     10        * assembler/ARMAssembler.cpp:
     11        (JSC::ARMAssembler::executableCopy):
     12        * assembler/ARMAssembler.h:
     13        (JSC::ARMAssembler::):
     14        (JSC::ARMAssembler::bx):
     15        (JSC::ARMAssembler::blx):
     16        (JSC::ARMAssembler::loadBranchTarget):
     17        (JSC::ARMAssembler::jmp):
     18        (JSC::ARMAssembler::getLdrImmAddress):
     19        * assembler/MacroAssemblerARM.h:
     20        (JSC::MacroAssemblerARM::jump):
     21        (JSC::MacroAssemblerARM::nearCall):
     22        (JSC::MacroAssemblerARM::call):
     23        (JSC::MacroAssemblerARM::ret):
     24        (JSC::MacroAssemblerARM::prepareCall):
     25        (JSC::MacroAssemblerARM::call32):
     26
    1272010-04-21  Andy Estes  <aestes@apple.com>
    228
  • trunk/JavaScriptCore/assembler/ARMAssembler.cpp

    r55718 r58091  
    358358        ARMWord* ldrAddr = reinterpret_cast<ARMWord*>(data + pos);
    359359        ARMWord* addr = getLdrImmAddress(ldrAddr);
    360         if (*addr != 0xffffffff) {
     360        if (*addr != InvalidBranchTarget) {
    361361            if (!(*iter & 1)) {
    362362                int diff = reinterpret_cast<ARMWord*>(data + *addr) - (ldrAddr + DefaultPrefetching);
  • trunk/JavaScriptCore/assembler/ARMAssembler.h

    r55718 r58091  
    11/*
    2  * Copyright (C) 2009 University of Szeged
     2 * Copyright (C) 2009, 2010 University of Szeged
    33 * All rights reserved.
    44 *
     
    132132            B = 0x0a000000,
    133133            BL = 0x0b000000,
     134#if WTF_ARM_ARCH_AT_LEAST(5) || defined(__ARM_ARCH_4T__)
     135            BX = 0x012fff10,
     136#endif
    134137            FMSR = 0x0e000a10,
    135138            FMRS = 0x0e100a10,
     
    140143            CLZ = 0x016f0f10,
    141144            BKPT = 0xe120070,
     145            BLX = 0x012fff30,
    142146#endif
    143147#if WTF_ARM_ARCH_AT_LEAST(7)
     
    183187
    184188        static const ARMWord INVALID_IMM = 0xf0000000;
     189        static const ARMWord InvalidBranchTarget = 0xffffffff;
    185190        static const int DefaultPrefetching = 2;
    186191
     
    548553        }
    549554
     555        void bx(int rm, Condition cc = AL)
     556        {
     557#if WTF_ARM_ARCH_AT_LEAST(5) || defined(__ARM_ARCH_4T__)
     558            emitInst(static_cast<ARMWord>(cc) | BX, 0, 0, RM(rm));
     559#else
     560            mov_r(ARMRegisters::pc, RM(rm), cc);
     561#endif
     562        }
     563
     564        JmpSrc blx(int rm, Condition cc = AL)
     565        {
     566#if WTF_ARM_ARCH_AT_LEAST(5)
     567            int s = m_buffer.uncheckedSize();
     568            emitInst(static_cast<ARMWord>(cc) | BLX, 0, 0, RM(rm));
     569#else
     570            ASSERT(rm != 14);
     571            ensureSpace(2 * sizeof(ARMWord), 0);
     572            mov_r(ARMRegisters::lr, ARMRegisters::pc, cc);
     573            int s = m_buffer.uncheckedSize();
     574            bx(rm, cc);
     575#endif
     576            return JmpSrc(s);
     577        }
     578
    550579        static ARMWord lsl(int reg, ARMWord value)
    551580        {
     
    620649        }
    621650
    622         JmpSrc jmp(Condition cc = AL, int useConstantPool = 0)
     651        JmpSrc loadBranchTarget(int rd, Condition cc = AL, int useConstantPool = 0)
    623652        {
    624653            ensureSpace(sizeof(ARMWord), sizeof(ARMWord));
    625654            int s = m_buffer.uncheckedSize();
    626             ldr_un_imm(ARMRegisters::pc, 0xffffffff, cc);
     655            ldr_un_imm(rd, InvalidBranchTarget, cc);
    627656            m_jumps.append(s | (useConstantPool & 0x1));
    628657            return JmpSrc(s);
    629658        }
    630659
     660        JmpSrc jmp(Condition cc = AL, int useConstantPool = 0)
     661        {
     662            return loadBranchTarget(ARMRegisters::pc, cc, useConstantPool);
     663        }
     664
    631665        void* executableCopy(ExecutablePool* allocator);
    632666
     
    635669        static ARMWord* getLdrImmAddress(ARMWord* insn)
    636670        {
     671#if WTF_ARM_ARCH_AT_LEAST(5)
     672            // Check for call
     673            if ((*insn & 0x0f7f0000) != 0x051f0000) {
     674                // Must be BLX
     675                ASSERT((*insn & 0x012fff30) == 0x012fff30);
     676                insn--;
     677            }
     678#endif
    637679            // Must be an ldr ..., [pc +/- imm]
    638680            ASSERT((*insn & 0x0f7f0000) == 0x051f0000);
  • trunk/JavaScriptCore/assembler/MacroAssemblerARM.h

    r56348 r58091  
    11/*
    22 * Copyright (C) 2008 Apple Inc.
    3  * Copyright (C) 2009 University of Szeged
     3 * Copyright (C) 2009, 2010 University of Szeged
    44 * All rights reserved.
    55 *
     
    475475    void jump(RegisterID target)
    476476    {
    477         move(target, ARMRegisters::pc);
     477        m_assembler.bx(target);
    478478    }
    479479
     
    567567    Call nearCall()
    568568    {
     569#if WTF_ARM_ARCH_AT_LEAST(5)
     570        ensureSpace(2 * sizeof(ARMWord), sizeof(ARMWord));
     571        m_assembler.loadBranchTarget(ARMRegisters::S1, ARMAssembler::AL, true);
     572        return Call(m_assembler.blx(ARMRegisters::S1), Call::LinkableNear);
     573#else
    569574        prepareCall();
    570575        return Call(m_assembler.jmp(ARMAssembler::AL, true), Call::LinkableNear);
     576#endif
    571577    }
    572578
    573579    Call call(RegisterID target)
    574580    {
    575         prepareCall();
    576         move(ARMRegisters::pc, target);
     581        m_assembler.blx(target);
    577582        JmpSrc jmpSrc;
    578583        return Call(jmpSrc, Call::None);
     
    586591    void ret()
    587592    {
    588         m_assembler.mov_r(ARMRegisters::pc, linkRegister);
     593        m_assembler.bx(linkRegister);
    589594    }
    590595
     
    682687    Call call()
    683688    {
     689#if WTF_ARM_ARCH_AT_LEAST(5)
     690        ensureSpace(2 * sizeof(ARMWord), sizeof(ARMWord));
     691        m_assembler.loadBranchTarget(ARMRegisters::S1, ARMAssembler::AL, true);
     692        return Call(m_assembler.blx(ARMRegisters::S1), Call::Linkable);
     693#else
    684694        prepareCall();
    685695        return Call(m_assembler.jmp(ARMAssembler::AL, true), Call::Linkable);
     696#endif
    686697    }
    687698
     
    887898    void prepareCall()
    888899    {
     900#if WTF_ARM_ARCH_VERSION < 5
    889901        ensureSpace(2 * sizeof(ARMWord), sizeof(ARMWord));
    890902
    891903        m_assembler.mov_r(linkRegister, ARMRegisters::pc);
     904#endif
    892905    }
    893906
    894907    void call32(RegisterID base, int32_t offset)
    895908    {
     909#if WTF_ARM_ARCH_AT_LEAST(5)
     910        int targetReg = ARMRegisters::S1;
     911#else
     912        int targetReg = ARMRegisters::pc;
     913#endif
     914        int tmpReg = ARMRegisters::S1;
     915
    896916        if (base == ARMRegisters::sp)
    897917            offset += 4;
     
    900920            if (offset <= 0xfff) {
    901921                prepareCall();
    902                 m_assembler.dtr_u(true, ARMRegisters::pc, base, offset);
     922                m_assembler.dtr_u(true, targetReg, base, offset);
    903923            } else if (offset <= 0xfffff) {
    904                 m_assembler.add_r(ARMRegisters::S0, base, ARMAssembler::OP2_IMM | (offset >> 12) | (10 << 8));
     924                m_assembler.add_r(tmpReg, base, ARMAssembler::OP2_IMM | (offset >> 12) | (10 << 8));
    905925                prepareCall();
    906                 m_assembler.dtr_u(true, ARMRegisters::pc, ARMRegisters::S0, offset & 0xfff);
     926                m_assembler.dtr_u(true, targetReg, tmpReg, offset & 0xfff);
    907927            } else {
    908                 ARMWord reg = m_assembler.getImm(offset, ARMRegisters::S0);
     928                ARMWord reg = m_assembler.getImm(offset, tmpReg);
    909929                prepareCall();
    910                 m_assembler.dtr_ur(true, ARMRegisters::pc, base, reg);
     930                m_assembler.dtr_ur(true, targetReg, base, reg);
    911931            }
    912932        } else  {
     
    914934            if (offset <= 0xfff) {
    915935                prepareCall();
    916                 m_assembler.dtr_d(true, ARMRegisters::pc, base, offset);
     936                m_assembler.dtr_d(true, targetReg, base, offset);
    917937            } else if (offset <= 0xfffff) {
    918                 m_assembler.sub_r(ARMRegisters::S0, base, ARMAssembler::OP2_IMM | (offset >> 12) | (10 << 8));
     938                m_assembler.sub_r(tmpReg, base, ARMAssembler::OP2_IMM | (offset >> 12) | (10 << 8));
    919939                prepareCall();
    920                 m_assembler.dtr_d(true, ARMRegisters::pc, ARMRegisters::S0, offset & 0xfff);
     940                m_assembler.dtr_d(true, targetReg, tmpReg, offset & 0xfff);
    921941            } else {
    922                 ARMWord reg = m_assembler.getImm(offset, ARMRegisters::S0);
     942                ARMWord reg = m_assembler.getImm(offset, tmpReg);
    923943                prepareCall();
    924                 m_assembler.dtr_dr(true, ARMRegisters::pc, base, reg);
     944                m_assembler.dtr_dr(true, targetReg, base, reg);
    925945            }
    926946        }
     947#if WTF_ARM_ARCH_AT_LEAST(5)
     948        m_assembler.blx(targetReg);
     949#endif
    927950    }
    928951
Note: See TracChangeset for help on using the changeset viewer.