Changeset 232105 in webkit


Ignore:
Timestamp:
May 22, 2018 9:44:44 PM (6 years ago)
Author:
Yusuke Suzuki
Message:

[JSC] Use branchIfString/branchIfNotString instead of structure checkings
​https://bugs.webkit.org/show_bug.cgi?id=185810

Reviewed by Saam Barati.

Let's use branchIfString/branchIfNotString helper functions instead of
checking structure with jsString's structure. It's easy to read. And
it emits less code since we do not need to embed string structure's
raw pointer in 32bit environment.

  • jit/JIT.h:
  • jit/JITInlines.h:

(JSC::JIT::emitLoadCharacterString):
(JSC::JIT::checkStructure): Deleted.

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::emitSlow_op_eq):
(JSC::JIT::compileOpEqJumpSlow):
(JSC::JIT::emitSlow_op_neq):

  • jit/JITPropertyAccess.cpp:

(JSC::JIT::stringGetByValStubGenerator):
(JSC::JIT::emitSlow_op_get_by_val):
(JSC::JIT::emitByValIdentifierCheck):

  • jit/JITPropertyAccess32_64.cpp:

(JSC::JIT::stringGetByValStubGenerator):
(JSC::JIT::emitSlow_op_get_by_val):

  • jit/JSInterfaceJIT.h:

(JSC::ThunkHelpers::jsStringLengthOffset): Deleted.
(JSC::ThunkHelpers::jsStringValueOffset): Deleted.

  • jit/SpecializedThunkJIT.h:

(JSC::SpecializedThunkJIT::loadJSStringArgument):

  • jit/ThunkGenerators.cpp:

(JSC::stringCharLoad):
(JSC::charCodeAtThunkGenerator):
(JSC::charAtThunkGenerator):

  • runtime/JSString.h:
Location:
trunk/Source/JavaScriptCore
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r232100 r232105  
     12018-05-22  Yusuke Suzuki  <utatane.tea@gmail.com>
     2
     3        [JSC] Use branchIfString/branchIfNotString instead of structure checkings
     4        https://bugs.webkit.org/show_bug.cgi?id=185810
     5
     6        Reviewed by Saam Barati.
     7
     8        Let's use branchIfString/branchIfNotString helper functions instead of
     9        checking structure with jsString's structure. It's easy to read. And
     10        it emits less code since we do not need to embed string structure's
     11        raw pointer in 32bit environment.
     12
     13        * jit/JIT.h:
     14        * jit/JITInlines.h:
     15        (JSC::JIT::emitLoadCharacterString):
     16        (JSC::JIT::checkStructure): Deleted.
     17        * jit/JITOpcodes32_64.cpp:
     18        (JSC::JIT::emitSlow_op_eq):
     19        (JSC::JIT::compileOpEqJumpSlow):
     20        (JSC::JIT::emitSlow_op_neq):
     21        * jit/JITPropertyAccess.cpp:
     22        (JSC::JIT::stringGetByValStubGenerator):
     23        (JSC::JIT::emitSlow_op_get_by_val):
     24        (JSC::JIT::emitByValIdentifierCheck):
     25        * jit/JITPropertyAccess32_64.cpp:
     26        (JSC::JIT::stringGetByValStubGenerator):
     27        (JSC::JIT::emitSlow_op_get_by_val):
     28        * jit/JSInterfaceJIT.h:
     29        (JSC::ThunkHelpers::jsStringLengthOffset): Deleted.
     30        (JSC::ThunkHelpers::jsStringValueOffset): Deleted.
     31        * jit/SpecializedThunkJIT.h:
     32        (JSC::SpecializedThunkJIT::loadJSStringArgument):
     33        * jit/ThunkGenerators.cpp:
     34        (JSC::stringCharLoad):
     35        (JSC::charCodeAtThunkGenerator):
     36        (JSC::charAtThunkGenerator):
     37        * runtime/JSString.h:
     38
    1392018-05-22  Mark Lam  <mark.lam@apple.com>
    240

  • trunk/Source/JavaScriptCore/jit/JIT.h

    r232048 r232105  
    798798        void emitRightShiftFastPath(Instruction* currentInstruction, OpcodeID);
    799799
    800         Jump checkStructure(RegisterID reg, Structure* structure);
    801 
    802800        void updateTopCallFrame();
    803801

  • trunk/Source/JavaScriptCore/jit/JITInlines.h

    r232048 r232105  
    100100ALWAYS_INLINE void JIT::emitLoadCharacterString(RegisterID src, RegisterID dst, JumpList& failures)
    101101{
    102     failures.append(branchStructure(NotEqual, Address(src, JSCell::structureIDOffset()), m_vm->stringStructure.get()));
    103     failures.append(branch32(NotEqual, MacroAssembler::Address(src, ThunkHelpers::jsStringLengthOffset()), TrustedImm32(1)));
    104     loadPtr(MacroAssembler::Address(src, ThunkHelpers::jsStringValueOffset()), dst);
     102    failures.append(branchIfNotString(src));
     103    failures.append(branch32(NotEqual, MacroAssembler::Address(src, JSString::offsetOfLength()), TrustedImm32(1)));
     104    loadPtr(MacroAssembler::Address(src, JSString::offsetOfValue()), dst);
    105105    failures.append(branchTest32(Zero, dst));
    106106    loadPtr(MacroAssembler::Address(dst, StringImpl::flagsOffset()), regT1);
    … …  
    197197#endif
    198198    return call;
    199 }
    200 
    201 ALWAYS_INLINE JIT::Jump JIT::checkStructure(RegisterID reg, Structure* structure)
    202 {
    203     return branchStructure(NotEqual, Address(reg, JSCell::structureIDOffset()), structure);
    204199}
    205200

  • trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp

    r232074 r232105  
    462462
    463463    linkSlowCase(iter); // tags equal and JSCell
    464     genericCase.append(branchPtr(NotEqual, Address(regT0, JSCell::structureIDOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
    465     genericCase.append(branchPtr(NotEqual, Address(regT2, JSCell::structureIDOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
     464    genericCase.append(branchIfNotString(regT0));
     465    genericCase.append(branchIfNotString(regT2));
    466466
    467467    // String case.
    … …  
    500500
    501501    linkSlowCase(iter); // tags equal and JSCell
    502     genericCase.append(branchPtr(NotEqual, Address(regT0, JSCell::structureIDOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
    503     genericCase.append(branchPtr(NotEqual, Address(regT2, JSCell::structureIDOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
     502    genericCase.append(branchIfNotString(regT0));
     503    genericCase.append(branchIfNotString(regT2));
    504504
    505505    // String case.
    … …  
    548548
    549549    linkSlowCase(iter); // tags equal and JSCell
    550     genericCase.append(branchPtr(NotEqual, Address(regT0, JSCell::structureIDOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
    551     genericCase.append(branchPtr(NotEqual, Address(regT2, JSCell::structureIDOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
     550    genericCase.append(branchIfNotString(regT0));
     551    genericCase.append(branchIfNotString(regT2));
    552552
    553553    // String case.

  • trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp

    r232070 r232105  
    5656    JumpList failures;
    5757    jit.tagReturnAddress();
    58     failures.append(jit.branchStructure(
    59         NotEqual,
    60         Address(regT0, JSCell::structureIDOffset()),
    61         vm->stringStructure.get()));
     58    failures.append(jit.branchIfNotString(regT0));
    6259
    6360    // Load string length to regT2, and start the process of loading the data pointer into regT0
    64     jit.load32(Address(regT0, ThunkHelpers::jsStringLengthOffset()), regT2);
    65     jit.loadPtr(Address(regT0, ThunkHelpers::jsStringValueOffset()), regT0);
     61    jit.load32(Address(regT0, JSString::offsetOfLength()), regT2);
     62    jit.loadPtr(Address(regT0, JSString::offsetOfValue()), regT0);
    6663    failures.append(jit.branchTest32(Zero, regT0));
    6764
    … …  
    253250    Jump nonCell = jump();
    254251    linkSlowCase(iter); // base array check
    255     Jump notString = branchStructure(NotEqual,
    256         Address(regT0, JSCell::structureIDOffset()),
    257         m_vm->stringStructure.get());
     252    Jump notString = branchIfNotString(regT0);
    258253    emitNakedCall(CodeLocationLabel<NoPtrTag>(m_vm->getCTIStub(stringGetByValStubGenerator).retaggedCode<NoPtrTag>()));
    259254    Jump failed = branchTest64(Zero, regT0);
    … …  
    12581253        slowCases.append(branchPtr(NotEqual, cell, TrustedImmPtr(byValInfo->cachedSymbol.get())));
    12591254    else {
    1260         slowCases.append(branchStructure(NotEqual, Address(cell, JSCell::structureIDOffset()), m_vm->stringStructure.get()));
     1255        slowCases.append(branchIfNotString(cell));
    12611256        loadPtr(Address(cell, JSString::offsetOfValue()), scratch);
    12621257        slowCases.append(branchPtr(NotEqual, scratch, TrustedImmPtr(propertyName.impl())));

  • trunk/Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp

    r232047 r232105  
    133133    JSInterfaceJIT jit(vm);
    134134    JumpList failures;
    135     failures.append(jit.branchStructure(NotEqual, Address(regT0, JSCell::structureIDOffset()), vm->stringStructure.get()));
     135    failures.append(jit.branchIfNotString(regT0));
    136136   
    137137    // Load string length to regT1, and start the process of loading the data pointer into regT0
    138     jit.load32(Address(regT0, ThunkHelpers::jsStringLengthOffset()), regT1);
    139     jit.loadPtr(Address(regT0, ThunkHelpers::jsStringValueOffset()), regT0);
     138    jit.load32(Address(regT0, JSString::offsetOfLength()), regT1);
     139    jit.loadPtr(Address(regT0, JSString::offsetOfValue()), regT0);
    140140    failures.append(jit.branchTest32(Zero, regT0));
    141141   
    … …  
    309309    Jump nonCell = jump();
    310310    linkSlowCase(iter); // base array check
    311     Jump notString = branchStructure(NotEqual, Address(regT0, JSCell::structureIDOffset()), m_vm->stringStructure.get());
     311    Jump notString = branchIfNotString(regT0);
    312312    emitNakedCall(CodeLocationLabel<NoPtrTag>(m_vm->getCTIStub(stringGetByValStubGenerator).retaggedCode<NoPtrTag>()));
    313313    Jump failed = branchTestPtr(Zero, regT0);

  • trunk/Source/JavaScriptCore/jit/JSInterfaceJIT.h

    r232048 r232105  
    6161
    6262        VM* m_vm;
    63     };
    64 
    65     struct ThunkHelpers {
    66         static unsigned jsStringLengthOffset() { return OBJECT_OFFSETOF(JSString, m_length); }
    67         static unsigned jsStringValueOffset() { return OBJECT_OFFSETOF(JSString, m_value); }
    6863    };
    6964

  • trunk/Source/JavaScriptCore/jit/SpecializedThunkJIT.h

    r232048 r232105  
    6666        }
    6767       
    68         void loadJSStringArgument(VM& vm, int argument, RegisterID dst)
     68        void loadJSStringArgument(int argument, RegisterID dst)
    6969        {
    7070            loadCellArgument(argument, dst);
    71             m_failures.append(branchStructure(NotEqual,
    72                 Address(dst, JSCell::structureIDOffset()),
    73                 vm.stringStructure.get()));
     71            m_failures.append(branchIfNotString(dst));
    7472        }
    7573       

  • trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp

    r232048 r232105  
    613613}
    614614
    615 static void stringCharLoad(SpecializedThunkJIT& jit, VM* vm)
     615static void stringCharLoad(SpecializedThunkJIT& jit)
    616616{
    617617    // load string
    618     jit.loadJSStringArgument(*vm, SpecializedThunkJIT::ThisArgument, SpecializedThunkJIT::regT0);
     618    jit.loadJSStringArgument(SpecializedThunkJIT::ThisArgument, SpecializedThunkJIT::regT0);
    619619
    620620    // Load string length to regT2, and start the process of loading the data pointer into regT0
    621     jit.load32(MacroAssembler::Address(SpecializedThunkJIT::regT0, ThunkHelpers::jsStringLengthOffset()), SpecializedThunkJIT::regT2);
    622     jit.loadPtr(MacroAssembler::Address(SpecializedThunkJIT::regT0, ThunkHelpers::jsStringValueOffset()), SpecializedThunkJIT::regT0);
     621    jit.load32(MacroAssembler::Address(SpecializedThunkJIT::regT0, JSString::offsetOfLength()), SpecializedThunkJIT::regT2);
     622    jit.loadPtr(MacroAssembler::Address(SpecializedThunkJIT::regT0, JSString::offsetOfValue()), SpecializedThunkJIT::regT0);
    623623    jit.appendFailure(jit.branchTest32(MacroAssembler::Zero, SpecializedThunkJIT::regT0));
    624624
    … …  
    654654{
    655655    SpecializedThunkJIT jit(vm, 1);
    656     stringCharLoad(jit, vm);
     656    stringCharLoad(jit);
    657657    jit.returnInt32(SpecializedThunkJIT::regT0);
    658658    return jit.finalize(vm->jitStubs->ctiNativeTailCall(vm), "charCodeAt");
    … …  
    662662{
    663663    SpecializedThunkJIT jit(vm, 1);
    664     stringCharLoad(jit, vm);
     664    stringCharLoad(jit);
    665665    charToString(jit, vm, SpecializedThunkJIT::regT0, SpecializedThunkJIT::regT0, SpecializedThunkJIT::regT1);
    666666    jit.returnJSCell(SpecializedThunkJIT::regT0);

  • trunk/Source/JavaScriptCore/runtime/JSString.h

    r231337 r232105  
    8181    friend class MarkStack;
    8282    friend class SlotVisitor;
    83     friend struct ThunkHelpers;
    8483
    8584    typedef JSCell Base;
Note: See TracChangeset for help on using the changeset viewer.