Changeset 228932 in webkit


Ignore:
Timestamp:
Feb 22, 2018 1:53:12 PM (6 years ago)
Author:
mark.lam@apple.com
Message:

Refactor MacroAssembler code to improve reuse and extensibility.
https://bugs.webkit.org/show_bug.cgi?id=183054
<rdar://problem/37797337>

Reviewed by Saam Barati.

  • assembler/ARM64Assembler.h:
  • assembler/MacroAssembler.cpp:
  • assembler/MacroAssembler.h:
  • assembler/MacroAssemblerARM.h:
  • assembler/MacroAssemblerARM64.h:

(JSC::MacroAssemblerARM64::canCompact):
(JSC::MacroAssemblerARM64::computeJumpType):
(JSC::MacroAssemblerARM64::jumpSizeDelta):
(JSC::MacroAssemblerARM64::link):
(JSC::MacroAssemblerARM64::load64):
(JSC::MacroAssemblerARM64::load64WithAddressOffsetPatch):
(JSC::MacroAssemblerARM64::load32):
(JSC::MacroAssemblerARM64::load32WithAddressOffsetPatch):
(JSC::MacroAssemblerARM64::load16):
(JSC::MacroAssemblerARM64::load16SignedExtendTo32):
(JSC::MacroAssemblerARM64::load8):
(JSC::MacroAssemblerARM64::load8SignedExtendTo32):
(JSC::MacroAssemblerARM64::store64):
(JSC::MacroAssemblerARM64::store64WithAddressOffsetPatch):
(JSC::MacroAssemblerARM64::store32):
(JSC::MacroAssemblerARM64::store32WithAddressOffsetPatch):
(JSC::MacroAssemblerARM64::store16):
(JSC::MacroAssemblerARM64::store8):
(JSC::MacroAssemblerARM64::getEffectiveAddress):
(JSC::MacroAssemblerARM64::branchDoubleNonZero):
(JSC::MacroAssemblerARM64::branchDoubleZeroOrNaN):
(JSC::MacroAssemblerARM64::branchTruncateDoubleToInt32):
(JSC::MacroAssemblerARM64::loadDouble):
(JSC::MacroAssemblerARM64::loadFloat):
(JSC::MacroAssemblerARM64::moveConditionallyAfterFloatingPointCompare):
(JSC::MacroAssemblerARM64::moveDoubleConditionallyAfterFloatingPointCompare):
(JSC::MacroAssemblerARM64::storeDouble):
(JSC::MacroAssemblerARM64::storeFloat):
(JSC::MacroAssemblerARM64::call):
(JSC::MacroAssemblerARM64::jump):
(JSC::MacroAssemblerARM64::tailRecursiveCall):
(JSC::MacroAssemblerARM64::setCarry):
(JSC::MacroAssemblerARM64::reemitInitialMoveWithPatch):
(JSC::MacroAssemblerARM64::isBreakpoint):
(JSC::MacroAssemblerARM64::invert):
(JSC::MacroAssemblerARM64::readCallTarget):
(JSC::MacroAssemblerARM64::replaceWithVMHalt):
(JSC::MacroAssemblerARM64::replaceWithJump):
(JSC::MacroAssemblerARM64::maxJumpReplacementSize):
(JSC::MacroAssemblerARM64::patchableJumpSize):
(JSC::MacroAssemblerARM64::repatchCall):
(JSC::MacroAssemblerARM64::makeBranch):
(JSC::MacroAssemblerARM64::makeCompareAndBranch):
(JSC::MacroAssemblerARM64::makeTestBitAndBranch):
(JSC::MacroAssemblerARM64::ARM64Condition):
(JSC::MacroAssemblerARM64::moveWithFixedWidth):
(JSC::MacroAssemblerARM64::load):
(JSC::MacroAssemblerARM64::store):
(JSC::MacroAssemblerARM64::tryLoadWithOffset):
(JSC::MacroAssemblerARM64::tryLoadSignedWithOffset):
(JSC::MacroAssemblerARM64::tryStoreWithOffset):
(JSC::MacroAssemblerARM64::jumpAfterFloatingPointCompare):
(JSC::MacroAssemblerARM64::linkCall):

  • assembler/MacroAssemblerARMv7.h:
  • assembler/MacroAssemblerMIPS.h:
  • assembler/MacroAssemblerX86Common.h:
  • assembler/ProbeStack.h:
  • Removed a forward declaration of an obsolete class.
Location:
trunk/Source/JavaScriptCore
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/ChangeLog

    r228926 r228932  
     12018-02-22  Mark Lam  <mark.lam@apple.com>
     2
     3        Refactor MacroAssembler code to improve reuse and extensibility.
     4        https://bugs.webkit.org/show_bug.cgi?id=183054
     5        <rdar://problem/37797337>
     6
     7        Reviewed by Saam Barati.
     8
     9        * assembler/ARM64Assembler.h:
     10        * assembler/MacroAssembler.cpp:
     11        * assembler/MacroAssembler.h:
     12        * assembler/MacroAssemblerARM.h:
     13        * assembler/MacroAssemblerARM64.h:
     14        (JSC::MacroAssemblerARM64::canCompact):
     15        (JSC::MacroAssemblerARM64::computeJumpType):
     16        (JSC::MacroAssemblerARM64::jumpSizeDelta):
     17        (JSC::MacroAssemblerARM64::link):
     18        (JSC::MacroAssemblerARM64::load64):
     19        (JSC::MacroAssemblerARM64::load64WithAddressOffsetPatch):
     20        (JSC::MacroAssemblerARM64::load32):
     21        (JSC::MacroAssemblerARM64::load32WithAddressOffsetPatch):
     22        (JSC::MacroAssemblerARM64::load16):
     23        (JSC::MacroAssemblerARM64::load16SignedExtendTo32):
     24        (JSC::MacroAssemblerARM64::load8):
     25        (JSC::MacroAssemblerARM64::load8SignedExtendTo32):
     26        (JSC::MacroAssemblerARM64::store64):
     27        (JSC::MacroAssemblerARM64::store64WithAddressOffsetPatch):
     28        (JSC::MacroAssemblerARM64::store32):
     29        (JSC::MacroAssemblerARM64::store32WithAddressOffsetPatch):
     30        (JSC::MacroAssemblerARM64::store16):
     31        (JSC::MacroAssemblerARM64::store8):
     32        (JSC::MacroAssemblerARM64::getEffectiveAddress):
     33        (JSC::MacroAssemblerARM64::branchDoubleNonZero):
     34        (JSC::MacroAssemblerARM64::branchDoubleZeroOrNaN):
     35        (JSC::MacroAssemblerARM64::branchTruncateDoubleToInt32):
     36        (JSC::MacroAssemblerARM64::loadDouble):
     37        (JSC::MacroAssemblerARM64::loadFloat):
     38        (JSC::MacroAssemblerARM64::moveConditionallyAfterFloatingPointCompare):
     39        (JSC::MacroAssemblerARM64::moveDoubleConditionallyAfterFloatingPointCompare):
     40        (JSC::MacroAssemblerARM64::storeDouble):
     41        (JSC::MacroAssemblerARM64::storeFloat):
     42        (JSC::MacroAssemblerARM64::call):
     43        (JSC::MacroAssemblerARM64::jump):
     44        (JSC::MacroAssemblerARM64::tailRecursiveCall):
     45        (JSC::MacroAssemblerARM64::setCarry):
     46        (JSC::MacroAssemblerARM64::reemitInitialMoveWithPatch):
     47        (JSC::MacroAssemblerARM64::isBreakpoint):
     48        (JSC::MacroAssemblerARM64::invert):
     49        (JSC::MacroAssemblerARM64::readCallTarget):
     50        (JSC::MacroAssemblerARM64::replaceWithVMHalt):
     51        (JSC::MacroAssemblerARM64::replaceWithJump):
     52        (JSC::MacroAssemblerARM64::maxJumpReplacementSize):
     53        (JSC::MacroAssemblerARM64::patchableJumpSize):
     54        (JSC::MacroAssemblerARM64::repatchCall):
     55        (JSC::MacroAssemblerARM64::makeBranch):
     56        (JSC::MacroAssemblerARM64::makeCompareAndBranch):
     57        (JSC::MacroAssemblerARM64::makeTestBitAndBranch):
     58        (JSC::MacroAssemblerARM64::ARM64Condition):
     59        (JSC::MacroAssemblerARM64::moveWithFixedWidth):
     60        (JSC::MacroAssemblerARM64::load):
     61        (JSC::MacroAssemblerARM64::store):
     62        (JSC::MacroAssemblerARM64::tryLoadWithOffset):
     63        (JSC::MacroAssemblerARM64::tryLoadSignedWithOffset):
     64        (JSC::MacroAssemblerARM64::tryStoreWithOffset):
     65        (JSC::MacroAssemblerARM64::jumpAfterFloatingPointCompare):
     66        (JSC::MacroAssemblerARM64::linkCall):
     67        * assembler/MacroAssemblerARMv7.h:
     68        * assembler/MacroAssemblerMIPS.h:
     69        * assembler/MacroAssemblerX86Common.h:
     70        * assembler/ProbeStack.h:
     71        - Removed a forward declaration of an obsolete class.
     72
    1732018-02-22  Yusuke Suzuki  <utatane.tea@gmail.com>
    274
  • trunk/Source/JavaScriptCore/assembler/ARM64Assembler.h

    r224258 r228932  
    11/*
    2  * Copyright (C) 2012-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    309309    }
    310310
    311 private:
     311protected:
    312312    static constexpr bool isSp(RegisterID reg) { return ARM64Registers::isSp(reg); }
    313313    static constexpr bool isZr(RegisterID reg) { return ARM64Registers::isZr(reg); }
     
    516516    }
    517517
    518 private:
     518protected:
    519519    int encodeFPImm(double d)
    520520    {
     
    29902990    }
    29912991
    2992 private:
     2992protected:
    29932993    template<Datasize size>
    29942994    static bool checkMovk(int insn, int _hw, RegisterID _rd)
     
    37553755    int m_indexOfLastWatchpoint;
    37563756    int m_indexOfTailOfLastWatchpoint;
     3757
     3758public:
     3759    static constexpr ptrdiff_t MAX_POINTER_BITS = 48;
    37573760};
    37583761
  • trunk/Source/JavaScriptCore/assembler/MacroAssembler.cpp

    r228193 r228932  
    11/*
    2  * Copyright (C) 2012-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    3333#include <wtf/PrintStream.h>
    3434#include <wtf/ScopedLambda.h>
     35
     36#if USE(APPLE_INTERNAL_SDK) && __has_include(<WebKitAdditions/MacroAssemblerSupport.h>)
     37#include <WebKitAdditions/MacroAssemblerSupport.h>
     38#endif
    3539
    3640namespace JSC {
  • trunk/Source/JavaScriptCore/assembler/MacroAssembler.h

    r228193 r228932  
    3131
    3232#if CPU(ARM_THUMB2)
     33#define TARGET_ASSEMBLER ARMv7Assembler
     34#define TARGET_MACROASSEMBLER MacroAssemblerARMv7
    3335#include "MacroAssemblerARMv7.h"
    3436namespace JSC { typedef MacroAssemblerARMv7 MacroAssemblerBase; };
    3537
    3638#elif CPU(ARM64)
     39#define TARGET_ASSEMBLER ARM64Assembler
     40#define TARGET_MACROASSEMBLER MacroAssemblerARM64
    3741#include "MacroAssemblerARM64.h"
    38 namespace JSC { typedef MacroAssemblerARM64 MacroAssemblerBase; };
    3942
    4043#elif CPU(ARM_TRADITIONAL)
     44#define TARGET_ASSEMBLER ARMAssembler
     45#define TARGET_MACROASSEMBLER MacroAssemblerARM
    4146#include "MacroAssemblerARM.h"
    42 namespace JSC { typedef MacroAssemblerARM MacroAssemblerBase; };
    4347
    4448#elif CPU(MIPS)
     49#define TARGET_ASSEMBLER MIPSAssembler
     50#define TARGET_MACROASSEMBLER MacroAssemblerMIPS
    4551#include "MacroAssemblerMIPS.h"
    46 namespace JSC {
    47 typedef MacroAssemblerMIPS MacroAssemblerBase;
    48 };
    4952
    5053#elif CPU(X86)
     54#define TARGET_ASSEMBLER X86Assembler
     55#define TARGET_MACROASSEMBLER MacroAssemblerX86
    5156#include "MacroAssemblerX86.h"
    52 namespace JSC { typedef MacroAssemblerX86 MacroAssemblerBase; };
    5357
    5458#elif CPU(X86_64)
     59#define TARGET_ASSEMBLER X86Assembler
     60#define TARGET_MACROASSEMBLER MacroAssemblerX86_64
    5561#include "MacroAssemblerX86_64.h"
    56 namespace JSC { typedef MacroAssemblerX86_64 MacroAssemblerBase; };
    5762
    5863#else
     
    8691
    8792} // namespace Printer
     93
     94using MacroAssemblerBase = TARGET_MACROASSEMBLER;
    8895
    8996class MacroAssembler : public MacroAssemblerBase {
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h

    r225360 r228932  
    11/*
    2  * Copyright (C) 2008-2017 Apple Inc.
     2 * Copyright (C) 2008-2018 Apple Inc.
    33 * Copyright (C) 2009, 2010 University of Szeged
    44 * All rights reserved.
     
    3535namespace JSC {
    3636
    37 class MacroAssemblerARM : public AbstractMacroAssembler<ARMAssembler> {
     37using Assembler = TARGET_ASSEMBLER;
     38
     39class MacroAssemblerARM : public AbstractMacroAssembler<Assembler> {
    3840    static const int DoubleConditionMask = 0x0f;
    3941    static const int DoubleConditionBitSpecial = 0x10;
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h

    r227897 r228932  
    3535namespace JSC {
    3636
    37 class MacroAssemblerARM64 : public AbstractMacroAssembler<ARM64Assembler> {
     37using Assembler = TARGET_ASSEMBLER;
     38
     39class MacroAssemblerARM64 : public AbstractMacroAssembler<Assembler> {
    3840public:
    3941    static const unsigned numGPRs = 32;
     
    4951    }
    5052
    51 private:
     53protected:
    5254    static const ARM64Registers::FPRegisterID fpTempRegister = ARM64Registers::q31;
    53     static const ARM64Assembler::SetFlags S = ARM64Assembler::S;
     55    static const Assembler::SetFlags S = Assembler::S;
    5456    static const intptr_t maskHalfWord0 = 0xffffl;
    5557    static const intptr_t maskHalfWord1 = 0xffff0000l;
    5658    static const intptr_t maskUpperWord = 0xffffffff00000000l;
    5759
    58     // 4 instructions - 3 to load the function pointer, + blr.
    59     static const ptrdiff_t REPATCH_OFFSET_CALL_TO_POINTER = -16;
    60    
     60    static constexpr size_t INSTRUCTION_SIZE = 4;
     61
     62    // N instructions to load the pointer + 1 call instruction.
     63    static constexpr ptrdiff_t REPATCH_OFFSET_CALL_TO_POINTER = -((Assembler::MAX_POINTER_BITS / 16 + 1) * INSTRUCTION_SIZE);
     64
    6165public:
    6266    MacroAssemblerARM64()
     
    6771    }
    6872
    69     typedef ARM64Assembler::LinkRecord LinkRecord;
    70     typedef ARM64Assembler::JumpType JumpType;
    71     typedef ARM64Assembler::JumpLinkType JumpLinkType;
    72     typedef ARM64Assembler::Condition Condition;
    73 
    74     static const ARM64Assembler::Condition DefaultCondition = ARM64Assembler::ConditionInvalid;
    75     static const ARM64Assembler::JumpType DefaultJump = ARM64Assembler::JumpNoConditionFixedSize;
     73    typedef Assembler::LinkRecord LinkRecord;
     74    typedef Assembler::JumpType JumpType;
     75    typedef Assembler::JumpLinkType JumpLinkType;
     76    typedef Assembler::Condition Condition;
     77
     78    static const Assembler::Condition DefaultCondition = Assembler::ConditionInvalid;
     79    static const Assembler::JumpType DefaultJump = Assembler::JumpNoConditionFixedSize;
    7680
    7781    Vector<LinkRecord, 0, UnsafeVectorOverflow>& jumpsToLink() { return m_assembler.jumpsToLink(); }
    7882    void* unlinkedCode() { return m_assembler.unlinkedCode(); }
    79     static bool canCompact(JumpType jumpType) { return ARM64Assembler::canCompact(jumpType); }
    80     static JumpLinkType computeJumpType(JumpType jumpType, const uint8_t* from, const uint8_t* to) { return ARM64Assembler::computeJumpType(jumpType, from, to); }
    81     static JumpLinkType computeJumpType(LinkRecord& record, const uint8_t* from, const uint8_t* to) { return ARM64Assembler::computeJumpType(record, from, to); }
    82     static int jumpSizeDelta(JumpType jumpType, JumpLinkType jumpLinkType) { return ARM64Assembler::jumpSizeDelta(jumpType, jumpLinkType); }
    83     static void link(LinkRecord& record, uint8_t* from, const uint8_t* fromInstruction, uint8_t* to) { return ARM64Assembler::link(record, from, fromInstruction, to); }
     83    static bool canCompact(JumpType jumpType) { return Assembler::canCompact(jumpType); }
     84    static JumpLinkType computeJumpType(JumpType jumpType, const uint8_t* from, const uint8_t* to) { return Assembler::computeJumpType(jumpType, from, to); }
     85    static JumpLinkType computeJumpType(LinkRecord& record, const uint8_t* from, const uint8_t* to) { return Assembler::computeJumpType(record, from, to); }
     86    static int jumpSizeDelta(JumpType jumpType, JumpLinkType jumpLinkType) { return Assembler::jumpSizeDelta(jumpType, jumpLinkType); }
     87    static void link(LinkRecord& record, uint8_t* from, const uint8_t* fromInstruction, uint8_t* to) { return Assembler::link(record, from, fromInstruction, to); }
    8488
    8589    static const Scale ScalePtr = TimesEight;
     
    9296
    9397    enum RelationalCondition {
    94         Equal = ARM64Assembler::ConditionEQ,
    95         NotEqual = ARM64Assembler::ConditionNE,
    96         Above = ARM64Assembler::ConditionHI,
    97         AboveOrEqual = ARM64Assembler::ConditionHS,
    98         Below = ARM64Assembler::ConditionLO,
    99         BelowOrEqual = ARM64Assembler::ConditionLS,
    100         GreaterThan = ARM64Assembler::ConditionGT,
    101         GreaterThanOrEqual = ARM64Assembler::ConditionGE,
    102         LessThan = ARM64Assembler::ConditionLT,
    103         LessThanOrEqual = ARM64Assembler::ConditionLE
     98        Equal = Assembler::ConditionEQ,
     99        NotEqual = Assembler::ConditionNE,
     100        Above = Assembler::ConditionHI,
     101        AboveOrEqual = Assembler::ConditionHS,
     102        Below = Assembler::ConditionLO,
     103        BelowOrEqual = Assembler::ConditionLS,
     104        GreaterThan = Assembler::ConditionGT,
     105        GreaterThanOrEqual = Assembler::ConditionGE,
     106        LessThan = Assembler::ConditionLT,
     107        LessThanOrEqual = Assembler::ConditionLE
    104108    };
    105109
    106110    enum ResultCondition {
    107         Overflow = ARM64Assembler::ConditionVS,
    108         Signed = ARM64Assembler::ConditionMI,
    109         PositiveOrZero = ARM64Assembler::ConditionPL,
    110         Zero = ARM64Assembler::ConditionEQ,
    111         NonZero = ARM64Assembler::ConditionNE
     111        Overflow = Assembler::ConditionVS,
     112        Signed = Assembler::ConditionMI,
     113        PositiveOrZero = Assembler::ConditionPL,
     114        Zero = Assembler::ConditionEQ,
     115        NonZero = Assembler::ConditionNE
    112116    };
    113117
    114118    enum ZeroCondition {
    115         IsZero = ARM64Assembler::ConditionEQ,
    116         IsNonZero = ARM64Assembler::ConditionNE
     119        IsZero = Assembler::ConditionEQ,
     120        IsNonZero = Assembler::ConditionNE
    117121    };
    118122
    119123    enum DoubleCondition {
    120124        // These conditions will only evaluate to true if the comparison is ordered - i.e. neither operand is NaN.
    121         DoubleEqual = ARM64Assembler::ConditionEQ,
    122         DoubleNotEqual = ARM64Assembler::ConditionVC, // Not the right flag! check for this & handle differently.
    123         DoubleGreaterThan = ARM64Assembler::ConditionGT,
    124         DoubleGreaterThanOrEqual = ARM64Assembler::ConditionGE,
    125         DoubleLessThan = ARM64Assembler::ConditionLO,
    126         DoubleLessThanOrEqual = ARM64Assembler::ConditionLS,
     125        DoubleEqual = Assembler::ConditionEQ,
     126        DoubleNotEqual = Assembler::ConditionVC, // Not the right flag! check for this & handle differently.
     127        DoubleGreaterThan = Assembler::ConditionGT,
     128        DoubleGreaterThanOrEqual = Assembler::ConditionGE,
     129        DoubleLessThan = Assembler::ConditionLO,
     130        DoubleLessThanOrEqual = Assembler::ConditionLS,
    127131        // If either operand is NaN, these conditions always evaluate to true.
    128         DoubleEqualOrUnordered = ARM64Assembler::ConditionVS, // Not the right flag! check for this & handle differently.
    129         DoubleNotEqualOrUnordered = ARM64Assembler::ConditionNE,
    130         DoubleGreaterThanOrUnordered = ARM64Assembler::ConditionHI,
    131         DoubleGreaterThanOrEqualOrUnordered = ARM64Assembler::ConditionHS,
    132         DoubleLessThanOrUnordered = ARM64Assembler::ConditionLT,
    133         DoubleLessThanOrEqualOrUnordered = ARM64Assembler::ConditionLE,
     132        DoubleEqualOrUnordered = Assembler::ConditionVS, // Not the right flag! check for this & handle differently.
     133        DoubleNotEqualOrUnordered = Assembler::ConditionNE,
     134        DoubleGreaterThanOrUnordered = Assembler::ConditionHI,
     135        DoubleGreaterThanOrEqualOrUnordered = Assembler::ConditionHS,
     136        DoubleLessThanOrUnordered = Assembler::ConditionLT,
     137        DoubleLessThanOrEqualOrUnordered = Assembler::ConditionLE,
    134138    };
    135139
     
    10491053    {
    10501054        if (!address.offset && (!address.scale || address.scale == 3)) {
    1051             m_assembler.ldr<64>(dest, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     1055            m_assembler.ldr<64>(dest, address.base, address.index, Assembler::UXTX, address.scale);
    10521056            return;
    10531057        }
    10541058
    10551059        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    1056         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     1060        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    10571061        m_assembler.ldr<64>(dest, address.base, memoryTempRegister);
    10581062    }
     
    10721076        DataLabel32 label(this);
    10731077        signExtend32ToPtrWithFixedWidth(address.offset, getCachedMemoryTempRegisterIDAndInvalidate());
    1074         m_assembler.ldr<64>(dest, address.base, memoryTempRegister, ARM64Assembler::SXTW, 0);
     1078        m_assembler.ldr<64>(dest, address.base, memoryTempRegister, Assembler::SXTW, 0);
    10751079        return label;
    10761080    }
     
    11381142    {
    11391143        if (!address.offset && (!address.scale || address.scale == 2)) {
    1140             m_assembler.ldr<32>(dest, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     1144            m_assembler.ldr<32>(dest, address.base, address.index, Assembler::UXTX, address.scale);
    11411145            return;
    11421146        }
    11431147
    11441148        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    1145         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     1149        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    11461150        m_assembler.ldr<32>(dest, address.base, memoryTempRegister);
    11471151    }
     
    11561160        DataLabel32 label(this);
    11571161        signExtend32ToPtrWithFixedWidth(address.offset, getCachedMemoryTempRegisterIDAndInvalidate());
    1158         m_assembler.ldr<32>(dest, address.base, memoryTempRegister, ARM64Assembler::SXTW, 0);
     1162        m_assembler.ldr<32>(dest, address.base, memoryTempRegister, Assembler::SXTW, 0);
    11591163        return label;
    11601164    }
     
    11851189    {
    11861190        if (!address.offset && (!address.scale || address.scale == 1)) {
    1187             m_assembler.ldrh(dest, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     1191            m_assembler.ldrh(dest, address.base, address.index, Assembler::UXTX, address.scale);
    11881192            return;
    11891193        }
    11901194
    11911195        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    1192         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     1196        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    11931197        m_assembler.ldrh(dest, address.base, memoryTempRegister);
    11941198    }
     
    12161220    {
    12171221        if (!address.offset && (!address.scale || address.scale == 1)) {
    1218             m_assembler.ldrsh<32>(dest, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     1222            m_assembler.ldrsh<32>(dest, address.base, address.index, Assembler::UXTX, address.scale);
    12191223            return;
    12201224        }
    12211225
    12221226        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    1223         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     1227        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    12241228        m_assembler.ldrsh<32>(dest, address.base, memoryTempRegister);
    12251229    }
     
    12471251    {
    12481252        if (!address.offset && !address.scale) {
    1249             m_assembler.ldrb(dest, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     1253            m_assembler.ldrb(dest, address.base, address.index, Assembler::UXTX, address.scale);
    12501254            return;
    12511255        }
    12521256
    12531257        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    1254         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     1258        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    12551259        m_assembler.ldrb(dest, address.base, memoryTempRegister);
    12561260    }
     
    12811285    {
    12821286        if (!address.offset && !address.scale) {
    1283             m_assembler.ldrsb<32>(dest, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     1287            m_assembler.ldrsb<32>(dest, address.base, address.index, Assembler::UXTX, address.scale);
    12841288            return;
    12851289        }
    12861290
    12871291        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    1288         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     1292        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    12891293        m_assembler.ldrsb<32>(dest, address.base, memoryTempRegister);
    12901294    }
     
    13201324    {
    13211325        if (!address.offset && (!address.scale || address.scale == 3)) {
    1322             m_assembler.str<64>(src, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     1326            m_assembler.str<64>(src, address.base, address.index, Assembler::UXTX, address.scale);
    13231327            return;
    13241328        }
    13251329
    13261330        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    1327         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     1331        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    13281332        m_assembler.str<64>(src, address.base, memoryTempRegister);
    13291333    }
     
    13801384        DataLabel32 label(this);
    13811385        signExtend32ToPtrWithFixedWidth(address.offset, getCachedMemoryTempRegisterIDAndInvalidate());
    1382         m_assembler.str<64>(src, address.base, memoryTempRegister, ARM64Assembler::SXTW, 0);
     1386        m_assembler.str<64>(src, address.base, memoryTempRegister, Assembler::SXTW, 0);
    13831387        return label;
    13841388    }
     
    14161420    {
    14171421        if (!address.offset && (!address.scale || address.scale == 2)) {
    1418             m_assembler.str<32>(src, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     1422            m_assembler.str<32>(src, address.base, address.index, Assembler::UXTX, address.scale);
    14191423            return;
    14201424        }
    14211425
    14221426        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    1423         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     1427        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    14241428        m_assembler.str<32>(src, address.base, memoryTempRegister);
    14251429    }
     
    14771481        DataLabel32 label(this);
    14781482        signExtend32ToPtrWithFixedWidth(address.offset, getCachedMemoryTempRegisterIDAndInvalidate());
    1479         m_assembler.str<32>(src, address.base, memoryTempRegister, ARM64Assembler::SXTW, 0);
     1483        m_assembler.str<32>(src, address.base, memoryTempRegister, Assembler::SXTW, 0);
    14801484        return label;
    14811485    }
     
    14931497    {
    14941498        if (!address.offset && (!address.scale || address.scale == 1)) {
    1495             m_assembler.strh(src, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     1499            m_assembler.strh(src, address.base, address.index, Assembler::UXTX, address.scale);
    14961500            return;
    14971501        }
    14981502
    14991503        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    1500         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     1504        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    15011505        m_assembler.strh(src, address.base, memoryTempRegister);
    15021506    }
     
    15051509    {
    15061510        if (!address.offset && !address.scale) {
    1507             m_assembler.strb(src, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     1511            m_assembler.strb(src, address.base, address.index, Assembler::UXTX, address.scale);
    15081512            return;
    15091513        }
    15101514
    15111515        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    1512         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     1516        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    15131517        m_assembler.strb(src, address.base, memoryTempRegister);
    15141518    }
     
    15601564    void getEffectiveAddress(BaseIndex address, RegisterID dest)
    15611565    {
    1562         m_assembler.add<64>(dest, address.base, address.index, ARM64Assembler::LSL, address.scale);
     1566        m_assembler.add<64>(dest, address.base, address.index, Assembler::LSL, address.scale);
    15631567        if (address.offset)
    15641568            add64(TrustedImm32(address.offset), dest);
     
    16901694    {
    16911695        m_assembler.fcmp_0<64>(reg);
    1692         Jump unordered = makeBranch(ARM64Assembler::ConditionVS);
    1693         Jump result = makeBranch(ARM64Assembler::ConditionNE);
     1696        Jump unordered = makeBranch(Assembler::ConditionVS);
     1697        Jump result = makeBranch(Assembler::ConditionNE);
    16941698        unordered.link(this);
    16951699        return result;
     
    16991703    {
    17001704        m_assembler.fcmp_0<64>(reg);
    1701         Jump unordered = makeBranch(ARM64Assembler::ConditionVS);
    1702         Jump notEqual = makeBranch(ARM64Assembler::ConditionNE);
     1705        Jump unordered = makeBranch(Assembler::ConditionVS);
     1706        Jump notEqual = makeBranch(Assembler::ConditionNE);
    17031707        unordered.link(this);
    17041708        // We get here if either unordered or equal.
     
    17141718        zeroExtend32ToPtr(dataTempRegister, dest);
    17151719        // Check the low 32-bits sign extend to be equal to the full value.
    1716         m_assembler.cmp<64>(dataTempRegister, dataTempRegister, ARM64Assembler::SXTW, 0);
     1720        m_assembler.cmp<64>(dataTempRegister, dataTempRegister, Assembler::SXTW, 0);
    17171721        return Jump(makeBranch(branchType == BranchIfTruncateSuccessful ? Equal : NotEqual));
    17181722    }
     
    18031807    {
    18041808        if (!address.offset && (!address.scale || address.scale == 3)) {
    1805             m_assembler.ldr<64>(dest, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     1809            m_assembler.ldr<64>(dest, address.base, address.index, Assembler::UXTX, address.scale);
    18061810            return;
    18071811        }
    18081812
    18091813        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    1810         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     1814        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    18111815        m_assembler.ldr<64>(dest, address.base, memoryTempRegister);
    18121816    }
     
    18301834    {
    18311835        if (!address.offset && (!address.scale || address.scale == 2)) {
    1832             m_assembler.ldr<32>(dest, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     1836            m_assembler.ldr<32>(dest, address.base, address.index, Assembler::UXTX, address.scale);
    18331837            return;
    18341838        }
    18351839
    18361840        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    1837         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     1841        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    18381842        m_assembler.ldr<32>(dest, address.base, memoryTempRegister);
    18391843    }
     
    18971901    {
    18981902        if (cond == DoubleNotEqual) {
    1899             Jump unordered = makeBranch(ARM64Assembler::ConditionVS);
    1900             m_assembler.csel<datasize>(dest, src, dest, ARM64Assembler::ConditionNE);
     1903            Jump unordered = makeBranch(Assembler::ConditionVS);
     1904            m_assembler.csel<datasize>(dest, src, dest, Assembler::ConditionNE);
    19011905            unordered.link(this);
    19021906            return;
     
    19071911            // If the compare is ordered, dest is unchanged and EQ decides
    19081912            // what value to set.
    1909             m_assembler.csel<datasize>(dest, src, dest, ARM64Assembler::ConditionVS);
    1910             m_assembler.csel<datasize>(dest, src, dest, ARM64Assembler::ConditionEQ);
     1913            m_assembler.csel<datasize>(dest, src, dest, Assembler::ConditionVS);
     1914            m_assembler.csel<datasize>(dest, src, dest, Assembler::ConditionEQ);
    19111915            return;
    19121916        }
     
    19181922    {
    19191923        if (cond == DoubleNotEqual) {
    1920             Jump unordered = makeBranch(ARM64Assembler::ConditionVS);
    1921             m_assembler.csel<datasize>(dest, thenCase, elseCase, ARM64Assembler::ConditionNE);
     1924            Jump unordered = makeBranch(Assembler::ConditionVS);
     1925            m_assembler.csel<datasize>(dest, thenCase, elseCase, Assembler::ConditionNE);
    19221926            unordered.link(this);
    19231927            return;
     
    19281932            // If the compare is ordered, dest is unchanged and EQ decides
    19291933            // what value to set.
    1930             m_assembler.csel<datasize>(elseCase, thenCase, elseCase, ARM64Assembler::ConditionVS);
    1931             m_assembler.csel<datasize>(dest, thenCase, elseCase, ARM64Assembler::ConditionEQ);
     1934            m_assembler.csel<datasize>(elseCase, thenCase, elseCase, Assembler::ConditionVS);
     1935            m_assembler.csel<datasize>(dest, thenCase, elseCase, Assembler::ConditionEQ);
    19321936            return;
    19331937        }
     
    19391943    {
    19401944        if (cond == DoubleNotEqual) {
    1941             Jump unordered = makeBranch(ARM64Assembler::ConditionVS);
    1942             m_assembler.fcsel<datasize>(dest, thenCase, elseCase, ARM64Assembler::ConditionNE);
     1945            Jump unordered = makeBranch(Assembler::ConditionVS);
     1946            m_assembler.fcsel<datasize>(dest, thenCase, elseCase, Assembler::ConditionNE);
    19431947            unordered.link(this);
    19441948            return;
     
    19491953            // If the compare is ordered, dest is unchanged and EQ decides
    19501954            // what value to set.
    1951             m_assembler.fcsel<datasize>(elseCase, thenCase, elseCase, ARM64Assembler::ConditionVS);
    1952             m_assembler.fcsel<datasize>(dest, thenCase, elseCase, ARM64Assembler::ConditionEQ);
     1955            m_assembler.fcsel<datasize>(elseCase, thenCase, elseCase, Assembler::ConditionVS);
     1956            m_assembler.fcsel<datasize>(dest, thenCase, elseCase, Assembler::ConditionEQ);
    19531957            return;
    19541958        }
     
    20472051    {
    20482052        if (!address.offset && (!address.scale || address.scale == 3)) {
    2049             m_assembler.str<64>(src, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     2053            m_assembler.str<64>(src, address.base, address.index, Assembler::UXTX, address.scale);
    20502054            return;
    20512055        }
    20522056
    20532057        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    2054         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     2058        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    20552059        m_assembler.str<64>(src, address.base, memoryTempRegister);
    20562060    }
     
    20682072    {
    20692073        if (!address.offset && (!address.scale || address.scale == 2)) {
    2070             m_assembler.str<32>(src, address.base, address.index, ARM64Assembler::UXTX, address.scale);
     2074            m_assembler.str<32>(src, address.base, address.index, Assembler::UXTX, address.scale);
    20712075            return;
    20722076        }
    20732077
    20742078        signExtend32ToPtr(TrustedImm32(address.offset), getCachedMemoryTempRegisterIDAndInvalidate());
    2075         m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
     2079        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, Assembler::UXTX, address.scale);
    20762080        m_assembler.str<32>(src, address.base, memoryTempRegister);
    20772081    }
     
    30813085        m_assembler.blr(dataTempRegister);
    30823086        AssemblerLabel callLabel = m_assembler.label();
    3083         ASSERT_UNUSED(pointerLabel, ARM64Assembler::getDifferenceBetweenLabels(callLabel, pointerLabel) == REPATCH_OFFSET_CALL_TO_POINTER);
     3087        ASSERT_UNUSED(pointerLabel, Assembler::getDifferenceBetweenLabels(callLabel, pointerLabel) == REPATCH_OFFSET_CALL_TO_POINTER);
    30843088        return Call(callLabel, Call::Linkable);
    30853089    }
     
    31023106        AssemblerLabel label = m_assembler.label();
    31033107        m_assembler.b();
    3104         return Jump(label, m_makeJumpPatchable ? ARM64Assembler::JumpNoConditionFixedSize : ARM64Assembler::JumpNoCondition);
     3108        return Jump(label, m_makeJumpPatchable ? Assembler::JumpNoConditionFixedSize : Assembler::JumpNoCondition);
    31053109    }
    31063110
     
    31663170        m_assembler.br(dataTempRegister);
    31673171        AssemblerLabel callLabel = m_assembler.label();
    3168         ASSERT_UNUSED(pointerLabel, ARM64Assembler::getDifferenceBetweenLabels(callLabel, pointerLabel) == REPATCH_OFFSET_CALL_TO_POINTER);
     3172        ASSERT_UNUSED(pointerLabel, Assembler::getDifferenceBetweenLabels(callLabel, pointerLabel) == REPATCH_OFFSET_CALL_TO_POINTER);
    31693173        return Call(callLabel, Call::Linkable);
    31703174    }
     
    32783282    void setCarry(RegisterID dest)
    32793283    {
    3280         m_assembler.cset<32>(dest, ARM64Assembler::ConditionCS);
     3284        m_assembler.cset<32>(dest, Assembler::ConditionCS);
    32813285    }
    32823286
     
    34053409    static void reemitInitialMoveWithPatch(void* address, void* value)
    34063410    {
    3407         ARM64Assembler::setPointer(static_cast<int*>(address), value, dataTempRegister, true);
     3411        Assembler::setPointer(static_cast<int*>(address), value, dataTempRegister, true);
    34083412    }
    34093413
     
    34153419    }
    34163420
    3417     static bool isBreakpoint(void* address) { return ARM64Assembler::isBrk(address); }
     3421    static bool isBreakpoint(void* address) { return Assembler::isBrk(address); }
    34183422
    34193423    void nop()
     
    37323736    static RelationalCondition invert(RelationalCondition cond)
    37333737    {
    3734         return static_cast<RelationalCondition>(ARM64Assembler::invert(static_cast<ARM64Assembler::Condition>(cond)));
     3738        return static_cast<RelationalCondition>(Assembler::invert(static_cast<Assembler::Condition>(cond)));
    37353739    }
    37363740
     
    37543758    static FunctionPtr readCallTarget(CodeLocationCall call)
    37553759    {
    3756         return FunctionPtr(reinterpret_cast<void(*)()>(ARM64Assembler::readCallTarget(call.dataLocation())));
     3760        return FunctionPtr(reinterpret_cast<void(*)()>(Assembler::readCallTarget(call.dataLocation())));
    37573761    }
    37583762
    37593763    static void replaceWithVMHalt(CodeLocationLabel instructionStart)
    37603764    {
    3761         ARM64Assembler::replaceWithVMHalt(instructionStart.executableAddress());
     3765        Assembler::replaceWithVMHalt(instructionStart.executableAddress());
    37623766    }
    37633767
    37643768    static void replaceWithJump(CodeLocationLabel instructionStart, CodeLocationLabel destination)
    37653769    {
    3766         ARM64Assembler::replaceWithJump(instructionStart.dataLocation(), destination.dataLocation());
     3770        Assembler::replaceWithJump(instructionStart.dataLocation(), destination.dataLocation());
    37673771    }
    37683772   
    37693773    static ptrdiff_t maxJumpReplacementSize()
    37703774    {
    3771         return ARM64Assembler::maxJumpReplacementSize();
     3775        return Assembler::maxJumpReplacementSize();
    37723776    }
    37733777
    37743778    static ptrdiff_t patchableJumpSize()
    37753779    {
    3776         return ARM64Assembler::patchableJumpSize();
     3780        return Assembler::patchableJumpSize();
    37773781    }
    37783782
     
    38213825    static void repatchCall(CodeLocationCall call, CodeLocationLabel destination)
    38223826    {
    3823         ARM64Assembler::repatchPointer(call.dataLabelPtrAtOffset(REPATCH_OFFSET_CALL_TO_POINTER).dataLocation(), destination.executableAddress());
     3827        Assembler::repatchPointer(call.dataLabelPtrAtOffset(REPATCH_OFFSET_CALL_TO_POINTER).dataLocation(), destination.executableAddress());
    38243828    }
    38253829
    38263830    static void repatchCall(CodeLocationCall call, FunctionPtr destination)
    38273831    {
    3828         ARM64Assembler::repatchPointer(call.dataLabelPtrAtOffset(REPATCH_OFFSET_CALL_TO_POINTER).dataLocation(), destination.executableAddress());
     3832        Assembler::repatchPointer(call.dataLabelPtrAtOffset(REPATCH_OFFSET_CALL_TO_POINTER).dataLocation(), destination.executableAddress());
    38293833    }
    38303834
    38313835protected:
    3832     ALWAYS_INLINE Jump makeBranch(ARM64Assembler::Condition cond)
     3836    ALWAYS_INLINE Jump makeBranch(Assembler::Condition cond)
    38333837    {
    38343838        m_assembler.b_cond(cond);
    38353839        AssemblerLabel label = m_assembler.label();
    38363840        m_assembler.nop();
    3837         return Jump(label, m_makeJumpPatchable ? ARM64Assembler::JumpConditionFixedSize : ARM64Assembler::JumpCondition, cond);
     3841        return Jump(label, m_makeJumpPatchable ? Assembler::JumpConditionFixedSize : Assembler::JumpCondition, cond);
    38383842    }
    38393843    ALWAYS_INLINE Jump makeBranch(RelationalCondition cond) { return makeBranch(ARM64Condition(cond)); }
     
    38503854        AssemblerLabel label = m_assembler.label();
    38513855        m_assembler.nop();
    3852         return Jump(label, m_makeJumpPatchable ? ARM64Assembler::JumpCompareAndBranchFixedSize : ARM64Assembler::JumpCompareAndBranch, static_cast<ARM64Assembler::Condition>(cond), dataSize == 64, reg);
     3856        return Jump(label, m_makeJumpPatchable ? Assembler::JumpCompareAndBranchFixedSize : Assembler::JumpCompareAndBranch, static_cast<Assembler::Condition>(cond), dataSize == 64, reg);
    38533857    }
    38543858
     
    38633867        AssemblerLabel label = m_assembler.label();
    38643868        m_assembler.nop();
    3865         return Jump(label, m_makeJumpPatchable ? ARM64Assembler::JumpTestBitFixedSize : ARM64Assembler::JumpTestBit, static_cast<ARM64Assembler::Condition>(cond), bit, reg);
    3866     }
    3867 
    3868     ARM64Assembler::Condition ARM64Condition(RelationalCondition cond)
    3869     {
    3870         return static_cast<ARM64Assembler::Condition>(cond);
    3871     }
    3872 
    3873     ARM64Assembler::Condition ARM64Condition(ResultCondition cond)
    3874     {
    3875         return static_cast<ARM64Assembler::Condition>(cond);
    3876     }
    3877 
    3878     ARM64Assembler::Condition ARM64Condition(DoubleCondition cond)
    3879     {
    3880         return static_cast<ARM64Assembler::Condition>(cond);
    3881     }
    3882    
    3883 private:
     3869        return Jump(label, m_makeJumpPatchable ? Assembler::JumpTestBitFixedSize : Assembler::JumpTestBit, static_cast<Assembler::Condition>(cond), bit, reg);
     3870    }
     3871
     3872    Assembler::Condition ARM64Condition(RelationalCondition cond)
     3873    {
     3874        return static_cast<Assembler::Condition>(cond);
     3875    }
     3876
     3877    Assembler::Condition ARM64Condition(ResultCondition cond)
     3878    {
     3879        return static_cast<Assembler::Condition>(cond);
     3880    }
     3881
     3882    Assembler::Condition ARM64Condition(DoubleCondition cond)
     3883    {
     3884        return static_cast<Assembler::Condition>(cond);
     3885    }
     3886   
     3887protected:
    38843888    ALWAYS_INLINE RegisterID getCachedDataTempRegisterIDAndInvalidate()
    38853889    {
     
    40164020        m_assembler.movk<64>(dest, getHalfword(value, 1), 16);
    40174021        m_assembler.movk<64>(dest, getHalfword(value, 2), 32);
     4022        if (Assembler::MAX_POINTER_BITS > 48)
     4023            m_assembler.movk<64>(dest, getHalfword(value, 3), 48);
    40184024    }
    40194025
     
    40414047
    40424048            if (isInIntRange(addressDelta)) {
    4043                 if (ARM64Assembler::canEncodeSImmOffset(addressDelta)) {
     4049                if (Assembler::canEncodeSImmOffset(addressDelta)) {
    40444050                    m_assembler.ldur<datasize>(dest,  memoryTempRegister, addressDelta);
    40454051                    return;
    40464052                }
    40474053
    4048                 if (ARM64Assembler::canEncodePImmOffset<datasize>(addressDelta)) {
     4054                if (Assembler::canEncodePImmOffset<datasize>(addressDelta)) {
    40494055                    m_assembler.ldr<datasize>(dest,  memoryTempRegister, addressDelta);
    40504056                    return;
     
    40784084
    40794085            if (isInIntRange(addressDelta)) {
    4080                 if (ARM64Assembler::canEncodeSImmOffset(addressDelta)) {
     4086                if (Assembler::canEncodeSImmOffset(addressDelta)) {
    40814087                    m_assembler.stur<datasize>(src, memoryTempRegister, addressDelta);
    40824088                    return;
    40834089                }
    40844090
    4085                 if (ARM64Assembler::canEncodePImmOffset<datasize>(addressDelta)) {
     4091                if (Assembler::canEncodePImmOffset<datasize>(addressDelta)) {
    40864092                    m_assembler.str<datasize>(src, memoryTempRegister, addressDelta);
    40874093                    return;
     
    41634169    ALWAYS_INLINE bool tryLoadWithOffset(RegisterID rt, RegisterID rn, int32_t offset)
    41644170    {
    4165         if (ARM64Assembler::canEncodeSImmOffset(offset)) {
     4171        if (Assembler::canEncodeSImmOffset(offset)) {
    41664172            loadUnscaledImmediate<datasize>(rt, rn, offset);
    41674173            return true;
    41684174        }
    4169         if (ARM64Assembler::canEncodePImmOffset<datasize>(offset)) {
     4175        if (Assembler::canEncodePImmOffset<datasize>(offset)) {
    41704176            loadUnsignedImmediate<datasize>(rt, rn, static_cast<unsigned>(offset));
    41714177            return true;
     
    41774183    ALWAYS_INLINE bool tryLoadSignedWithOffset(RegisterID rt, RegisterID rn, int32_t offset)
    41784184    {
    4179         if (ARM64Assembler::canEncodeSImmOffset(offset)) {
     4185        if (Assembler::canEncodeSImmOffset(offset)) {
    41804186            loadSignedAddressedByUnscaledImmediate<datasize>(rt, rn, offset);
    41814187            return true;
    41824188        }
    4183         if (ARM64Assembler::canEncodePImmOffset<datasize>(offset)) {
     4189        if (Assembler::canEncodePImmOffset<datasize>(offset)) {
    41844190            loadSignedAddressedByUnsignedImmediate<datasize>(rt, rn, static_cast<unsigned>(offset));
    41854191            return true;
     
    41914197    ALWAYS_INLINE bool tryLoadWithOffset(FPRegisterID rt, RegisterID rn, int32_t offset)
    41924198    {
    4193         if (ARM64Assembler::canEncodeSImmOffset(offset)) {
     4199        if (Assembler::canEncodeSImmOffset(offset)) {
    41944200            m_assembler.ldur<datasize>(rt, rn, offset);
    41954201            return true;
    41964202        }
    4197         if (ARM64Assembler::canEncodePImmOffset<datasize>(offset)) {
     4203        if (Assembler::canEncodePImmOffset<datasize>(offset)) {
    41984204            m_assembler.ldr<datasize>(rt, rn, static_cast<unsigned>(offset));
    41994205            return true;
     
    42054211    ALWAYS_INLINE bool tryStoreWithOffset(RegisterID rt, RegisterID rn, int32_t offset)
    42064212    {
    4207         if (ARM64Assembler::canEncodeSImmOffset(offset)) {
     4213        if (Assembler::canEncodeSImmOffset(offset)) {
    42084214            storeUnscaledImmediate<datasize>(rt, rn, offset);
    42094215            return true;
    42104216        }
    4211         if (ARM64Assembler::canEncodePImmOffset<datasize>(offset)) {
     4217        if (Assembler::canEncodePImmOffset<datasize>(offset)) {
    42124218            storeUnsignedImmediate<datasize>(rt, rn, static_cast<unsigned>(offset));
    42134219            return true;
     
    42194225    ALWAYS_INLINE bool tryStoreWithOffset(FPRegisterID rt, RegisterID rn, int32_t offset)
    42204226    {
    4221         if (ARM64Assembler::canEncodeSImmOffset(offset)) {
     4227        if (Assembler::canEncodeSImmOffset(offset)) {
    42224228            m_assembler.stur<datasize>(rt, rn, offset);
    42234229            return true;
    42244230        }
    4225         if (ARM64Assembler::canEncodePImmOffset<datasize>(offset)) {
     4231        if (Assembler::canEncodePImmOffset<datasize>(offset)) {
    42264232            m_assembler.str<datasize>(rt, rn, static_cast<unsigned>(offset));
    42274233            return true;
     
    43974403        if (cond == DoubleNotEqual) {
    43984404            // ConditionNE jumps if NotEqual *or* unordered - force the unordered cases not to jump.
    4399             Jump unordered = makeBranch(ARM64Assembler::ConditionVS);
    4400             Jump result = makeBranch(ARM64Assembler::ConditionNE);
     4405            Jump unordered = makeBranch(Assembler::ConditionVS);
     4406            Jump result = makeBranch(Assembler::ConditionNE);
    44014407            unordered.link(this);
    44024408            return result;
    44034409        }
    44044410        if (cond == DoubleEqualOrUnordered) {
    4405             Jump unordered = makeBranch(ARM64Assembler::ConditionVS);
    4406             Jump notEqual = makeBranch(ARM64Assembler::ConditionNE);
     4411            Jump unordered = makeBranch(Assembler::ConditionVS);
     4412            Jump notEqual = makeBranch(Assembler::ConditionNE);
    44074413            unordered.link(this);
    44084414            // We get here if either unordered or equal.
     
    44194425    {
    44204426        if (!call.isFlagSet(Call::Near))
    4421             ARM64Assembler::linkPointer(code, call.m_label.labelAtOffset(REPATCH_OFFSET_CALL_TO_POINTER), function.value());
     4427            Assembler::linkPointer(code, call.m_label.labelAtOffset(REPATCH_OFFSET_CALL_TO_POINTER), function.value());
    44224428        else if (call.isFlagSet(Call::Tail))
    4423             ARM64Assembler::linkJump(code, call.m_label, function.value());
     4429            Assembler::linkJump(code, call.m_label, function.value());
    44244430        else
    4425             ARM64Assembler::linkCall(code, call.m_label, function.value());
     4431            Assembler::linkCall(code, call.m_label, function.value());
    44264432    }
    44274433
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h

    r225360 r228932  
    11/*
    2  * Copyright (C) 2009-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2009-2018 Apple Inc. All rights reserved.
    33 * Copyright (C) 2010 University of Szeged
    44 *
     
    3434namespace JSC {
    3535
    36 class MacroAssemblerARMv7 : public AbstractMacroAssembler<ARMv7Assembler> {
     36using Assembler = TARGET_ASSEMBLER;
     37
     38class MacroAssemblerARMv7 : public AbstractMacroAssembler<Assembler> {
    3739    static const RegisterID dataTempRegister = ARMRegisters::ip;
    3840    static const RegisterID addressTempRegister = ARMRegisters::r6;
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h

    r225360 r228932  
    11/*
    2  * Copyright (C) 2008-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
    33 * Copyright (C) 2010 MIPS Technologies, Inc. All rights reserved.
    44 *
     
    3434namespace JSC {
    3535
    36 class MacroAssemblerMIPS : public AbstractMacroAssembler<MIPSAssembler> {
     36using Assembler = TARGET_ASSEMBLER;
     37
     38class MacroAssemblerMIPS : public AbstractMacroAssembler<Assembler> {
    3739public:
    3840    typedef MIPSRegisters::FPRegisterID FPRegisterID;
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h

    r226428 r228932  
    11/*
    2  * Copyright (C) 2008-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    3838namespace JSC {
    3939
    40 class MacroAssemblerX86Common : public AbstractMacroAssembler<X86Assembler> {
     40using Assembler = TARGET_ASSEMBLER;
     41
     42class MacroAssemblerX86Common : public AbstractMacroAssembler<Assembler> {
    4143public:
    4244#if CPU(X86_64)
  • trunk/Source/JavaScriptCore/assembler/ProbeStack.h

    r222871 r228932  
    11/*
    2  * Copyright (C) 2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2017-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    3434
    3535namespace JSC {
    36 
    37 struct ProbeContext;
    3836
    3937namespace Probe {
Note: See TracChangeset for help on using the changeset viewer.