Changeset 208450 in webkit


Ignore:
Timestamp:
Nov 9, 2016 11:10:42 AM (7 years ago)
Author:
Yusuke Suzuki
Message:

[JSC] The implementation of 8 bit operation in MacroAssembler should care about uint8_t / int8_t
​https://bugs.webkit.org/show_bug.cgi?id=164432

Reviewed by Michael Saboff.

Source/JavaScriptCore:

Except for X86, our supported MacroAssemblers do not have native 8bit instructions.
It means that all the 8bit instructions are converted to 32bit operations by using
scratch registers. For example, ARM64 branch8 implementation is the following.

Jump branch8(RelationCondition cord, Address left, TrustedImm32 right)
{

TrustedImm32 right8(static_cast<int8_t>(right.m_value));
load8(left, getCachedMemoryTempRegisterIDAndInvalidate());
return branch32(cone, memoryTempRegister, right8);

}

The problem is that we exclusively use zero-extended load instruction (load8). Even
for signed RelationConditions, we do not perform sign extension. It makes signed
operations with negative numbers incorrect! Consider the |left| address holds -1
in int8_t form. However load8 will load it as 255 into 32bit register. On the other hand,
|right| will be sign extended. If you pass 0 as |right| and LessThan condition, this
branch8 should jump based on the answer of -1 < 0. But the current MacroAssembler
performs 255 < 0 in int32_t context and returns the incorrect result.

We should follow the x86 model. So we should select the appropriate load operation and masking
operation based on the RelationCondition. This patch introduces mask8OnCondition and load8OnCondition.
And we use them in 8bit operations including branch8, branchTest8, compare8, and test8.

We intentionally do not change anything on x86 assembler since it has the native signed 8bit operations.

  • JavaScriptCore.xcodeproj/project.pbxproj:
  • assembler/AbstractMacroAssembler.h:
  • assembler/MacroAssembler.h:

(JSC::MacroAssembler::isSigned):
(JSC::MacroAssembler::isUnsigned):
(JSC::MacroAssembler::branchTest8):

  • assembler/MacroAssemblerARM.h:

(JSC::MacroAssemblerARM::branch8):
(JSC::MacroAssemblerARM::branchTest8):
(JSC::MacroAssemblerARM::compare8):
(JSC::MacroAssemblerARM::test8):

  • assembler/MacroAssemblerARM64.h:

(JSC::MacroAssemblerARM64::load8SignedExtendTo32):
(JSC::MacroAssemblerARM64::branch8):
(JSC::MacroAssemblerARM64::branchTest8):
(JSC::MacroAssemblerARM64::compare8):
(JSC::MacroAssemblerARM64::test8):

  • assembler/MacroAssemblerARMv7.h:

(JSC::MacroAssemblerARMv7::branch8):
(JSC::MacroAssemblerARMv7::branchTest8):
(JSC::MacroAssemblerARMv7::compare8):
(JSC::MacroAssemblerARMv7::test8):

  • assembler/MacroAssemblerHelpers.h: Added.

(JSC::MacroAssemblerHelpers::isSigned):
(JSC::MacroAssemblerHelpers::isUnsigned):
(JSC::MacroAssemblerHelpers::mask8OnCondition):
(JSC::MacroAssemblerHelpers::load8OnCondition):

  • assembler/MacroAssemblerMIPS.h:

(JSC::MacroAssemblerMIPS::branch8):
(JSC::MacroAssemblerMIPS::compare8):
(JSC::MacroAssemblerMIPS::branchTest8):
(JSC::MacroAssemblerMIPS::test8):

  • assembler/MacroAssemblerSH4.h:

(JSC::MacroAssemblerSH4::branchTest8):
(JSC::MacroAssemblerSH4::branch8):
(JSC::MacroAssemblerSH4::compare8):
(JSC::MacroAssemblerSH4::test8):

  • assembler/MacroAssemblerX86_64.h:

(JSC::MacroAssemblerX86_64::branch8):

LayoutTests:

Use ownerDocument. Once DOMJIT for ownerDocument is landed, this will use branch8.

  • js/dom/domjit-accessor-owner-document-type-check-expected.txt: Added.
  • js/dom/domjit-accessor-owner-document-type-check.html: Added.
Location:
trunk
Files:
3 added
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r208448 r208450  
     12016-11-07  Yusuke Suzuki  <utatane.tea@gmail.com>
     2
     3        [JSC] The implementation of 8 bit operation in MacroAssembler should care about uint8_t / int8_t
     4        https://bugs.webkit.org/show_bug.cgi?id=164432
     5
     6        Reviewed by Michael Saboff.
     7
     8        Use ownerDocument. Once DOMJIT for ownerDocument is landed, this will use branch8.
     9
     10        * js/dom/domjit-accessor-owner-document-type-check-expected.txt: Added.
     11        * js/dom/domjit-accessor-owner-document-type-check.html: Added.
     12
    1132016-11-08  Antoine Quint  <graouts@apple.com>
    214

  • trunk/Source/JavaScriptCore/ChangeLog

    r208427 r208450  
     12016-11-07  Yusuke Suzuki  <utatane.tea@gmail.com>
     2
     3        [JSC] The implementation of 8 bit operation in MacroAssembler should care about uint8_t / int8_t
     4        https://bugs.webkit.org/show_bug.cgi?id=164432
     5
     6        Reviewed by Michael Saboff.
     7
     8        Except for X86, our supported MacroAssemblers do not have native 8bit instructions.
     9        It means that all the 8bit instructions are converted to 32bit operations by using
     10        scratch registers. For example, ARM64 branch8 implementation is the following.
     11
     12            Jump branch8(RelationCondition cord, Address left, TrustedImm32 right)
     13            {
     14                TrustedImm32 right8(static_cast<int8_t>(right.m_value));
     15                load8(left, getCachedMemoryTempRegisterIDAndInvalidate());
     16                return branch32(cone, memoryTempRegister, right8);
     17            }
     18
     19        The problem is that we exclusively use zero-extended load instruction (load8). Even
     20        for signed RelationConditions, we do not perform sign extension. It makes signed
     21        operations with negative numbers incorrect! Consider the |left| address holds `-1`
     22        in int8_t form. However load8 will load it as 255 into 32bit register. On the other hand,
     23        |right| will be sign extended. If you pass 0 as |right| and LessThan condition, this
     24        branch8 should jump based on the answer of `-1 < 0`. But the current MacroAssembler
     25        performs `255 < 0` in int32_t context and returns the incorrect result.
     26
     27        We should follow the x86 model. So we should select the appropriate load operation and masking
     28        operation based on the RelationCondition. This patch introduces mask8OnCondition and load8OnCondition.
     29        And we use them in 8bit operations including branch8, branchTest8, compare8, and test8.
     30
     31        We intentionally do not change anything on x86 assembler since it has the native signed 8bit operations.
     32
     33        * JavaScriptCore.xcodeproj/project.pbxproj:
     34        * assembler/AbstractMacroAssembler.h:
     35        * assembler/MacroAssembler.h:
     36        (JSC::MacroAssembler::isSigned):
     37        (JSC::MacroAssembler::isUnsigned):
     38        (JSC::MacroAssembler::branchTest8):
     39        * assembler/MacroAssemblerARM.h:
     40        (JSC::MacroAssemblerARM::branch8):
     41        (JSC::MacroAssemblerARM::branchTest8):
     42        (JSC::MacroAssemblerARM::compare8):
     43        (JSC::MacroAssemblerARM::test8):
     44        * assembler/MacroAssemblerARM64.h:
     45        (JSC::MacroAssemblerARM64::load8SignedExtendTo32):
     46        (JSC::MacroAssemblerARM64::branch8):
     47        (JSC::MacroAssemblerARM64::branchTest8):
     48        (JSC::MacroAssemblerARM64::compare8):
     49        (JSC::MacroAssemblerARM64::test8):
     50        * assembler/MacroAssemblerARMv7.h:
     51        (JSC::MacroAssemblerARMv7::branch8):
     52        (JSC::MacroAssemblerARMv7::branchTest8):
     53        (JSC::MacroAssemblerARMv7::compare8):
     54        (JSC::MacroAssemblerARMv7::test8):
     55        * assembler/MacroAssemblerHelpers.h: Added.
     56        (JSC::MacroAssemblerHelpers::isSigned):
     57        (JSC::MacroAssemblerHelpers::isUnsigned):
     58        (JSC::MacroAssemblerHelpers::mask8OnCondition):
     59        (JSC::MacroAssemblerHelpers::load8OnCondition):
     60        * assembler/MacroAssemblerMIPS.h:
     61        (JSC::MacroAssemblerMIPS::branch8):
     62        (JSC::MacroAssemblerMIPS::compare8):
     63        (JSC::MacroAssemblerMIPS::branchTest8):
     64        (JSC::MacroAssemblerMIPS::test8):
     65        * assembler/MacroAssemblerSH4.h:
     66        (JSC::MacroAssemblerSH4::branchTest8):
     67        (JSC::MacroAssemblerSH4::branch8):
     68        (JSC::MacroAssemblerSH4::compare8):
     69        (JSC::MacroAssemblerSH4::test8):
     70        * assembler/MacroAssemblerX86_64.h:
     71        (JSC::MacroAssemblerX86_64::branch8):
     72
    1732016-11-08  Geoffrey Garen  <ggaren@apple.com>
    274

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

    r208401 r208450  
    21982198                E328DAEA1D38D005001A2529 /* BytecodeRewriter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E3D264291D38C042000BE174 /* BytecodeRewriter.cpp */; };
    21992199                E328DAEB1D38D005001A2529 /* BytecodeRewriter.h in Headers */ = {isa = PBXBuildFile; fileRef = E3D2642A1D38C042000BE174 /* BytecodeRewriter.h */; settings = {ATTRIBUTES = (Private, ); }; };
     2200                E32AB2441DCD75F400D7533A /* MacroAssemblerHelpers.h in Headers */ = {isa = PBXBuildFile; fileRef = E380A76B1DCD7195000F89E6 /* MacroAssemblerHelpers.h */; settings = {ATTRIBUTES = (Private, ); }; };
    22002201                E32FF1EA1DA7571C00A8BF21 /* DOMJITSlowPathCalls.h in Headers */ = {isa = PBXBuildFile; fileRef = E3CB1E241DA7540A00FA1E56 /* DOMJITSlowPathCalls.h */; settings = {ATTRIBUTES = (Private, ); }; };
    22012202                E33637A51B63220200EE0840 /* ReflectObject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E33637A31B63220200EE0840 /* ReflectObject.cpp */; };
    … …  
    46664667                E37AD83A1DA4928000F3D412 /* DOMJITPatchpointParams.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DOMJITPatchpointParams.h; sourceTree = "<group>"; };
    46674668                E37AD83B1DA4928000F3D412 /* DOMJITReg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DOMJITReg.h; sourceTree = "<group>"; };
     4669                E380A76B1DCD7195000F89E6 /* MacroAssemblerHelpers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MacroAssemblerHelpers.h; sourceTree = "<group>"; };
    46684670                E3963CEC1B73F75000EB4CE5 /* NodesAnalyzeModule.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NodesAnalyzeModule.cpp; sourceTree = "<group>"; };
    46694671                E39D9D841D39000600667282 /* InterpreterInlines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InterpreterInlines.h; sourceTree = "<group>"; };
    … …  
    70657067                                0F6DB7EB1D617D0F00CDBF8E /* MacroAssemblerCodeRef.cpp */,
    70667068                                863B23DF0FC60E6200703AA4 /* MacroAssemblerCodeRef.h */,
     7069                                E380A76B1DCD7195000F89E6 /* MacroAssemblerHelpers.h */,
    70677070                                86C568DE11A213EE0007F7F0 /* MacroAssemblerMIPS.h */,
    70687071                                FE68C6351B90DDD90042BCB3 /* MacroAssemblerPrinter.cpp */,
    … …  
    80498052                                0F235BEE17178E7300690C7F /* DFGOSRExitPreparation.h in Headers */,
    80508053                                0F6237981AE45CA700D402EA /* DFGPhantomInsertionPhase.h in Headers */,
     8054                                E32AB2441DCD75F400D7533A /* MacroAssemblerHelpers.h in Headers */,
    80518055                                0FFFC95C14EF90AF00C72532 /* DFGPhase.h in Headers */,
    80528056                                0F2B9CEB19D0BA7D00B1D1B5 /* DFGPhiChildren.h in Headers */,

  • trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h

    r207475 r208450  
    3232#include "CodeLocation.h"
    3333#include "MacroAssemblerCodeRef.h"
     34#include "MacroAssemblerHelpers.h"
    3435#include "Options.h"
    3536#include <wtf/CryptographicallyRandomNumber.h>

  • trunk/Source/JavaScriptCore/assembler/MacroAssembler.h

    r207039 r208450  
    6666#endif
    6767
     68#include "MacroAssemblerHelpers.h"
     69
    6870namespace JSC {
    6971
    … …  
    141143
    142144    // Utilities used by the DFG JIT.
    143 #if ENABLE(DFG_JIT)
    144145    using MacroAssemblerBase::invert;
    145146   
    … …  
    234235    }
    235236
    236     // True if this:
    237     //     branch8(cond, value, value)
    238     // Is the same as this:
    239     //     branch32(cond, signExt8(value), signExt8(value))
    240237    static bool isSigned(RelationalCondition cond)
    241238    {
    242         switch (cond) {
    243         case Equal:
    244         case NotEqual:
    245         case GreaterThan:
    246         case GreaterThanOrEqual:
    247         case LessThan:
    248         case LessThanOrEqual:
    249             return true;
    250         default:
    251             return false;
    252         }
    253     }
    254 
    255     // True if this:
    256     //     branch8(cond, value, value)
    257     // Is the same as this:
    258     //     branch32(cond, zeroExt8(value), zeroExt8(value))
     239        return MacroAssemblerHelpers::isSigned<MacroAssembler>(cond);
     240    }
     241
    259242    static bool isUnsigned(RelationalCondition cond)
    260243    {
    261         switch (cond) {
    262         case Equal:
    263         case NotEqual:
    264         case Above:
    265         case AboveOrEqual:
    266         case Below:
    267         case BelowOrEqual:
    268             return true;
    269         default:
    270             return false;
    271         }
    272     }
    273 #endif
     244        return MacroAssemblerHelpers::isUnsigned<MacroAssembler>(cond);
     245    }
     246
     247    static bool isSigned(ResultCondition cond)
     248    {
     249        return MacroAssemblerHelpers::isSigned<MacroAssembler>(cond);
     250    }
     251
     252    static bool isUnsigned(ResultCondition cond)
     253    {
     254        return MacroAssemblerHelpers::isUnsigned<MacroAssembler>(cond);
     255    }
    274256
    275257    // Platform agnostic convenience functions,
    … …  
    798780    Jump branchTest8(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
    799781    {
    800         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    801         return MacroAssemblerBase::branchTest8(cond, Address(address.base, address.offset), mask8);
     782        return MacroAssemblerBase::branchTest8(cond, Address(address.base, address.offset), mask);
    802783    }
    803784

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h

    r206525 r208450  
    633633    Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
    634634    {
    635         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    636         load8(left, ARMRegisters::S1);
     635        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     636        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, ARMRegisters::S1);
    637637        return branch32(cond, ARMRegisters::S1, right8);
    638638    }
    … …  
    640640    Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
    641641    {
    642         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    643         load8(left, ARMRegisters::S1);
     642        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     643        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, ARMRegisters::S1);
    644644        return branch32(cond, ARMRegisters::S1, right8);
    645645    }
    … …  
    647647    Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
    648648    {
    649         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
     649        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
    650650        move(TrustedImmPtr(left.m_ptr), ARMRegisters::S1);
    651         load8(Address(ARMRegisters::S1), ARMRegisters::S1);
     651        MacroAssemblerHelpers::load8OnCondition(*this, cond, Address(ARMRegisters::S1), ARMRegisters::S1);
    652652        return branch32(cond, ARMRegisters::S1, right8);
    653653    }
    … …  
    703703    Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
    704704    {
    705         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    706         load8(address, ARMRegisters::S1);
     705        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     706        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, ARMRegisters::S1);
    707707        return branchTest32(cond, ARMRegisters::S1, mask8);
    708708    }
    … …  
    710710    Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
    711711    {
    712         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    713         load8(address, ARMRegisters::S1);
     712        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     713        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, ARMRegisters::S1);
    714714        return branchTest32(cond, ARMRegisters::S1, mask8);
    715715    }
    … …  
    717717    Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
    718718    {
    719         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
     719        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    720720        move(TrustedImmPtr(address.m_ptr), ARMRegisters::S1);
    721         load8(Address(ARMRegisters::S1), ARMRegisters::S1);
     721        MacroAssemblerHelpers::load8OnCondition(*this, cond, Address(ARMRegisters::S1), ARMRegisters::S1);
    722722        return branchTest32(cond, ARMRegisters::S1, mask8);
    723723    }
    … …  
    986986    void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
    987987    {
    988         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    989         load8(left, ARMRegisters::S1);
     988        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     989        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, ARMRegisters::S1);
    990990        compare32(cond, ARMRegisters::S1, right8, dest);
    991991    }
    … …  
    10091009    void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
    10101010    {
    1011         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    1012         load8(address, ARMRegisters::S1);
     1011        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     1012        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, ARMRegisters::S1);
    10131013        test32(cond, ARMRegisters::S1, mask8, dest);
    10141014    }

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h

    r206539 r208450  
    12011201    }
    12021202
     1203    void load8SignedExtendTo32(const void* address, RegisterID dest)
     1204    {
     1205        moveToCachedReg(TrustedImmPtr(address), cachedMemoryTempRegister());
     1206        m_assembler.ldrsb<32>(dest, memoryTempRegister, ARM64Registers::zr);
     1207        if (dest == memoryTempRegister)
     1208            cachedMemoryTempRegister().invalidate();
     1209    }
     1210
    12031211    void zeroExtend8To32(RegisterID src, RegisterID dest)
    12041212    {
    … …  
    24252433    Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
    24262434    {
    2427         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    2428         load8(left, getCachedMemoryTempRegisterIDAndInvalidate());
     2435        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     2436        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, getCachedMemoryTempRegisterIDAndInvalidate());
    24292437        return branch32(cond, memoryTempRegister, right8);
    24302438    }
    … …  
    24322440    Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
    24332441    {
    2434         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    2435         load8(left, getCachedMemoryTempRegisterIDAndInvalidate());
     2442        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     2443        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, getCachedMemoryTempRegisterIDAndInvalidate());
    24362444        return branch32(cond, memoryTempRegister, right8);
    24372445    }
    … …  
    24392447    Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
    24402448    {
    2441         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    2442         load8(left.m_ptr, getCachedMemoryTempRegisterIDAndInvalidate());
     2449        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     2450        MacroAssemblerHelpers::load8OnCondition(*this, cond, left.m_ptr, getCachedMemoryTempRegisterIDAndInvalidate());
    24432451        return branch32(cond, memoryTempRegister, right8);
    24442452    }
    … …  
    25842592    Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
    25852593    {
    2586         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    2587         load8(address, getCachedDataTempRegisterIDAndInvalidate());
     2594        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     2595        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, getCachedDataTempRegisterIDAndInvalidate());
    25882596        return branchTest32(cond, dataTempRegister, mask8);
    25892597    }
    … …  
    25912599    Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
    25922600    {
    2593         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    2594         load8(address.m_ptr, getCachedDataTempRegisterIDAndInvalidate());
     2601        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     2602        MacroAssemblerHelpers::load8OnCondition(*this, cond, address.m_ptr, getCachedDataTempRegisterIDAndInvalidate());
    25952603        return branchTest32(cond, dataTempRegister, mask8);
    25962604    }
    … …  
    25982606    Jump branchTest8(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
    25992607    {
    2600         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
     2608        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    26012609        move(TrustedImmPtr(reinterpret_cast<void*>(address.offset)), getCachedDataTempRegisterIDAndInvalidate());
    2602         m_assembler.ldrb(dataTempRegister, address.base, dataTempRegister);
     2610
     2611        if (MacroAssemblerHelpers::isUnsigned<MacroAssemblerARM64>(cond))
     2612            m_assembler.ldrb(dataTempRegister, address.base, dataTempRegister);
     2613        else
     2614            m_assembler.ldrsb<32>(dataTempRegister, address.base, dataTempRegister);
     2615
    26032616        return branchTest32(cond, dataTempRegister, mask8);
    26042617    }
    … …  
    26062619    Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
    26072620    {
    2608         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    2609         load8(address, getCachedDataTempRegisterIDAndInvalidate());
     2621        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     2622        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, getCachedDataTempRegisterIDAndInvalidate());
    26102623        return branchTest32(cond, dataTempRegister, mask8);
    26112624    }
    … …  
    30243037    void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
    30253038    {
    3026         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    3027         load8(left, getCachedMemoryTempRegisterIDAndInvalidate());
     3039        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     3040        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, getCachedMemoryTempRegisterIDAndInvalidate());
    30283041        move(right8, getCachedDataTempRegisterIDAndInvalidate());
    30293042        compare32(cond, memoryTempRegister, dataTempRegister, dest);
    … …  
    30503063    void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
    30513064    {
    3052         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    3053         load8(address, getCachedMemoryTempRegisterIDAndInvalidate());
     3065        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     3066        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, getCachedMemoryTempRegisterIDAndInvalidate());
    30543067        test32(cond, memoryTempRegister, mask8, dest);
    30553068    }

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h

    r206525 r208450  
    14911491    Jump branch8(RelationalCondition cond, RegisterID left, TrustedImm32 right)
    14921492    {
    1493         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
     1493        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
    14941494        compare32AndSetFlags(left, right8);
    14951495        return Jump(makeBranch(cond));
    … …  
    14991499    {
    15001500        // use addressTempRegister incase the branch8 we call uses dataTempRegister. :-/
    1501         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    1502         load8(left, addressTempRegister);
     1501        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     1502        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, addressTempRegister);
    15031503        return branch8(cond, addressTempRegister, right8);
    15041504    }
    … …  
    15071507    {
    15081508        // use addressTempRegister incase the branch32 we call uses dataTempRegister. :-/
    1509         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    1510         load8(left, addressTempRegister);
     1509        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     1510        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, addressTempRegister);
    15111511        return branch32(cond, addressTempRegister, right8);
    15121512    }
    … …  
    15151515    {
    15161516        // Use addressTempRegister instead of dataTempRegister, since branch32 uses dataTempRegister.
    1517         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
     1517        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
    15181518        move(TrustedImmPtr(address.m_ptr), addressTempRegister);
    1519         load8(Address(addressTempRegister), addressTempRegister);
     1519        MacroAssemblerHelpers::load8OnCondition(*this, cond, Address(addressTempRegister), addressTempRegister);
    15201520        return branch32(cond, addressTempRegister, right8);
    15211521    }
    … …  
    15521552    {
    15531553        // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/
    1554         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    1555         load8(address, addressTempRegister);
     1554        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     1555        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, addressTempRegister);
    15561556        return branchTest32(cond, addressTempRegister, mask8);
    15571557    }
    … …  
    15601560    {
    15611561        // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/
    1562         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    1563         load8(address, addressTempRegister);
     1562        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     1563        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, addressTempRegister);
    15641564        return branchTest32(cond, addressTempRegister, mask8);
    15651565    }
    … …  
    15681568    {
    15691569        // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/
    1570         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
     1570        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    15711571        move(TrustedImmPtr(address.m_ptr), addressTempRegister);
    1572         load8(Address(addressTempRegister), addressTempRegister);
     1572        MacroAssemblerHelpers::load8OnCondition(*this, cond, Address(addressTempRegister), addressTempRegister);
    15731573        return branchTest32(cond, addressTempRegister, mask8);
    15741574    }
    … …  
    17981798    void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
    17991799    {
    1800         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    1801         load8(left, addressTempRegister);
     1800        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     1801        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, addressTempRegister);
    18021802        compare32(cond, addressTempRegister, right8, dest);
    18031803    }
    … …  
    18261826    void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
    18271827    {
    1828         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    1829         load8(address, dataTempRegister);
     1828        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     1829        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, dataTempRegister);
    18301830        test32(dataTempRegister, mask8);
    18311831        m_assembler.it(armV7Condition(cond), false);

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h

    r206525 r208450  
    14461446    Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
    14471447    {
    1448         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    1449         load8(left, dataTempRegister);
     1448        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     1449        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, dataTempRegister);
    14501450        move(right8, immTempRegister);
    14511451        return branch32(cond, dataTempRegister, immTempRegister);
    … …  
    14541454    Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
    14551455    {
    1456         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    1457         load8(left, dataTempRegister);
     1456        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     1457        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, dataTempRegister);
    14581458        move(right8, immTempRegister);
    14591459        return branch32(cond, dataTempRegister, immTempRegister);
    … …  
    14621462    void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
    14631463    {
    1464         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    1465         load8(left, dataTempRegister);
     1464        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     1465        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, dataTempRegister);
    14661466        move(right8, immTempRegister);
    14671467        compare32(cond, dataTempRegister, immTempRegister, dest);
    … …  
    14701470    Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
    14711471    {
    1472         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    1473         load8(left, dataTempRegister);
     1472        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
     1473        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, dataTempRegister);
    14741474        // Be careful that the previous load8() uses immTempRegister.
    14751475        // So, we need to put move() after load8().
    … …  
    16291629    Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
    16301630    {
    1631         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    1632         load8(address, dataTempRegister);
     1631        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     1632        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, dataTempRegister);
    16331633        return branchTest32(cond, dataTempRegister, mask8);
    16341634    }
    … …  
    16361636    Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
    16371637    {
    1638         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    1639         load8(address, dataTempRegister);
     1638        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     1639        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, dataTempRegister);
    16401640        return branchTest32(cond, dataTempRegister, mask8);
    16411641    }
    … …  
    16431643    Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
    16441644    {
    1645         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
     1645        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    16461646        move(TrustedImmPtr(address.m_ptr), dataTempRegister);
    1647         load8(Address(dataTempRegister), dataTempRegister);
     1647        MacroAssemblerHelpers::load8OnCondition(*this, cond, Address(dataTempRegister), dataTempRegister);
    16481648        return branchTest32(cond, dataTempRegister, mask8);
    16491649    }
    … …  
    22192219    {
    22202220        ASSERT((cond == Zero) || (cond == NonZero));
    2221         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    2222         load8(address, dataTempRegister);
    2223         if (mask8.m_value == -1 && !m_fixedWidth) {
     2221        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     2222        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, dataTempRegister);
     2223        if ((mask8.m_value & 0xff) == 0xff && !m_fixedWidth) {
    22242224            if (cond == Zero)
    22252225                m_assembler.sltiu(dest, dataTempRegister, 1);

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h

    r206525 r208450  
    16061606    Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
    16071607    {
    1608         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
     1608        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    16091609        RegisterID addressTempRegister = claimScratch();
    1610         load8(address, addressTempRegister);
     1610        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, addressTempRegister);
    16111611        Jump jmp = branchTest32(cond, addressTempRegister, mask8);
    16121612        releaseScratch(addressTempRegister);
    … …  
    16161616    Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
    16171617    {
    1618         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
     1618        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    16191619        RegisterID addressTempRegister = claimScratch();
    1620         load8(address, addressTempRegister);
     1620        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, addressTempRegister);
    16211621        Jump jmp = branchTest32(cond, addressTempRegister, mask8);
    16221622        releaseScratch(addressTempRegister);
    … …  
    16261626    Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
    16271627    {
    1628         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
     1628        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    16291629        RegisterID addressTempRegister = claimScratch();
    16301630        move(TrustedImmPtr(address.m_ptr), addressTempRegister);
    1631         load8(Address(addressTempRegister), addressTempRegister);
     1631        MacroAssemblerHelpers::load8OnCondition(*this, cond, Address(addressTempRegister), addressTempRegister);
    16321632        Jump jmp = branchTest32(cond, addressTempRegister, mask8);
    16331633        releaseScratch(addressTempRegister);
    … …  
    16471647    Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
    16481648    {
    1649         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
     1649        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
    16501650        RegisterID addressTempRegister = claimScratch();
    1651         load8(left, addressTempRegister);
     1651        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, addressTempRegister);
    16521652        Jump jmp = branch32(cond, addressTempRegister, right8);
    16531653        releaseScratch(addressTempRegister);
    … …  
    16571657    Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
    16581658    {
    1659         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
     1659        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
    16601660        RegisterID addressTempRegister = claimScratch();
    1661         load8(left, addressTempRegister);
     1661        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, addressTempRegister);
    16621662        Jump jmp = branch32(cond, addressTempRegister, right8);
    16631663        releaseScratch(addressTempRegister);
    … …  
    16671667    void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
    16681668    {
    1669         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
     1669        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
    16701670        RegisterID addressTempRegister = claimScratch();
    1671         load8(left, addressTempRegister);
     1671        MacroAssemblerHelpers::load8OnCondition(*this, cond, left, addressTempRegister);
    16721672        compare32(cond, addressTempRegister, right8, dest);
    16731673        releaseScratch(addressTempRegister);
    … …  
    18421842        ASSERT((cond == Zero) || (cond == NonZero));
    18431843
    1844         TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    1845 
    1846         load8(address, dest);
    1847         if (mask8.m_value == -1)
     1844        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
     1845
     1846        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, dest);
     1847        if ((mask8.m_value & 0xff) == 0xff)
    18481848            compare32(0, dest, static_cast<RelationalCondition>(cond));
    18491849        else
    … …  
    19661966    Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
    19671967    {
    1968         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
     1968        TrustedImm32 right8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, right);
    19691969        RegisterID lefttmp = claimScratch();
    19701970
    19711971        loadEffectiveAddress(left, lefttmp);
    19721972
    1973         load8(lefttmp, lefttmp);
     1973        MacroAssemblerHelpers::load8OnCondition(*this, cond, lefttmp, lefttmp);
    19741974        RegisterID righttmp = claimScratch();
    19751975        m_assembler.loadConstant(right8.m_value, righttmp);

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h

    r206555 r208450  
    12211221    Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
    12221222    {
    1223         TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    12241223        MacroAssemblerX86Common::move(TrustedImmPtr(left.m_ptr), scratchRegister());
    1225         return MacroAssemblerX86Common::branch8(cond, Address(scratchRegister()), right8);
     1224        return MacroAssemblerX86Common::branch8(cond, Address(scratchRegister()), right);
    12261225    }
    12271226   
Note: See TracChangeset for help on using the changeset viewer.