Changeset 225632 in webkit


Ignore:
Timestamp:
Dec 7, 2017 10:49:51 AM (6 years ago)
Author:
mark.lam@apple.com
Message:

[Re-landing r225620] Refactoring: Rename ScrambledPtr to Poisoned.
https://bugs.webkit.org/show_bug.cgi?id=180514

Reviewed by Saam Barati and JF Bastien.

Re-landing r225620 with speculative build fix for GCC 7.

Source/JavaScriptCore:

  • API/JSCallbackObject.h:
  • API/JSObjectRef.cpp:

(classInfoPrivate):

  • JavaScriptCore.xcodeproj/project.pbxproj:
  • Sources.txt:
  • assembler/MacroAssemblerCodeRef.h:

(JSC::FunctionPtr::FunctionPtr):
(JSC::FunctionPtr::value const):
(JSC::FunctionPtr::executableAddress const):
(JSC::ReturnAddressPtr::ReturnAddressPtr):
(JSC::ReturnAddressPtr::value const):
(JSC::MacroAssemblerCodePtr::MacroAssemblerCodePtr):
(JSC::MacroAssemblerCodePtr::createFromExecutableAddress):
(JSC::MacroAssemblerCodePtr::poisonedPtr const):
(JSC::MacroAssemblerCodePtr:: const):
(JSC::MacroAssemblerCodePtr::operator! const):
(JSC::MacroAssemblerCodePtr::operator== const):
(JSC::MacroAssemblerCodePtr::emptyValue):
(JSC::MacroAssemblerCodePtr::deletedValue):
(JSC::MacroAssemblerCodePtr::scrambledPtr const): Deleted.

  • b3/B3LowerMacros.cpp:
  • b3/testb3.cpp:

(JSC::B3::testInterpreter):

  • dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::checkArray):
(JSC::DFG::SpeculativeJIT::compileCheckSubClass):
(JSC::DFG::SpeculativeJIT::compileNewStringObject):
(JSC::DFG::SpeculativeJIT::emitSwitchIntJump):

  • ftl/FTLLowerDFGToB3.cpp:

(JSC::FTL::DFG::LowerDFGToB3::compileNewStringObject):
(JSC::FTL::DFG::LowerDFGToB3::compileCheckSubClass):

  • jit/AssemblyHelpers.h:

(JSC::AssemblyHelpers::emitAllocateDestructibleObject):

  • jit/SpecializedThunkJIT.h:

(JSC::SpecializedThunkJIT::loadArgumentWithSpecificClass):

  • jit/ThunkGenerators.cpp:

(JSC::virtualThunkFor):
(JSC::boundThisNoArgsFunctionCallGenerator):

  • llint/LLIntSlowPaths.cpp:

(JSC::LLInt::handleHostCall):
(JSC::LLInt::setUpCall):

  • llint/LowLevelInterpreter64.asm:
  • runtime/InitializeThreading.cpp:

(JSC::initializeThreading):

  • runtime/JSCPoisonedPtr.cpp: Copied from Source/JavaScriptCore/runtime/JSCScrambledPtr.cpp.

(JSC::initializePoison):
(JSC::initializeScrambledPtrKeys): Deleted.

  • runtime/JSCPoisonedPtr.h: Copied from Source/JavaScriptCore/runtime/JSCScrambledPtr.h.
  • runtime/JSCScrambledPtr.cpp: Removed.
  • runtime/JSCScrambledPtr.h: Removed.
  • runtime/JSDestructibleObject.h:

(JSC::JSDestructibleObject::classInfo const):

  • runtime/JSSegmentedVariableObject.h:

(JSC::JSSegmentedVariableObject::classInfo const):

  • runtime/Structure.h:
  • runtime/VM.h:

Source/WTF:

  • WTF.xcodeproj/project.pbxproj:
  • wtf/CMakeLists.txt:
  • wtf/Poisoned.cpp: Copied from Source/WTF/wtf/ScrambledPtr.cpp.

(WTF::makePoison):
(WTF::makeScrambledPtrKey): Deleted.

  • wtf/Poisoned.h: Copied from Source/WTF/wtf/ScrambledPtr.h.

(WTF::PoisonedImpl::PoisonedImpl):
(WTF::PoisonedImpl::assertIsPoisoned const):
(WTF::PoisonedImpl::assertIsNotPoisoned const):
(WTF::PoisonedImpl::unpoisoned const):
(WTF::PoisonedImpl::operator-> const):
(WTF::PoisonedImpl::bits const):
(WTF::PoisonedImpl::operator! const):
(WTF::PoisonedImpl::operator bool const):
(WTF::PoisonedImpl::operator== const):
(WTF::PoisonedImpl::operator==):
(WTF::PoisonedImpl::operator=):
(WTF::PoisonedImpl::poison):
(WTF::PoisonedImpl::unpoison):
(WTF::ScrambledPtr::ScrambledPtr): Deleted.
(WTF::ScrambledPtr::assertIsScrambled const): Deleted.
(WTF::ScrambledPtr::assertIsNotScrambled const): Deleted.
(WTF::ScrambledPtr::descrambled const): Deleted.
(WTF::ScrambledPtr::operator-> const): Deleted.
(WTF::ScrambledPtr::bits const): Deleted.
(WTF::ScrambledPtr::operator! const): Deleted.
(WTF::ScrambledPtr::operator bool const): Deleted.
(WTF::ScrambledPtr::operator== const): Deleted.
(WTF::ScrambledPtr::operator==): Deleted.
(WTF::ScrambledPtr::operator=): Deleted.
(WTF::ScrambledPtr::scramble): Deleted.
(WTF::ScrambledPtr::descramble): Deleted.

  • wtf/ScrambledPtr.cpp: Removed.
  • wtf/ScrambledPtr.h: Removed.
Location:
trunk/Source
Files:
23 edited
4 moved

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/API/JSCallbackObject.h

    r225629 r225632  
    2828#define JSCallbackObject_h
    2929
    30 #include "JSCScrambledPtr.h"
     30#include "JSCPoisonedPtr.h"
    3131#include "JSObjectRef.h"
    3232#include "JSValueRef.h"
     
    235235
    236236    std::unique_ptr<JSCallbackObjectData> m_callbackObjectData;
    237     ClassInfoScrambledPtr m_classInfo;
     237    PoisonedClassInfoPtr m_classInfo;
    238238};
    239239
  • trunk/Source/JavaScriptCore/API/JSObjectRef.cpp

    r225629 r225632  
    432432        return jsObject->classInfo(vm);
    433433
    434     return vm.currentlyDestructingCallbackObjectClassInfo.descrambled();
     434    return vm.currentlyDestructingCallbackObjectClassInfo.unpoisoned();
    435435}
    436436
  • trunk/Source/JavaScriptCore/ChangeLog

    r225629 r225632  
     12017-12-07  Mark Lam  <mark.lam@apple.com>
     2
     3        [Re-landing r225620] Refactoring: Rename ScrambledPtr to Poisoned.
     4        https://bugs.webkit.org/show_bug.cgi?id=180514
     5
     6        Reviewed by Saam Barati and JF Bastien.
     7
     8        Re-landing r225620 with speculative build fix for GCC 7.
     9
     10        * API/JSCallbackObject.h:
     11        * API/JSObjectRef.cpp:
     12        (classInfoPrivate):
     13        * JavaScriptCore.xcodeproj/project.pbxproj:
     14        * Sources.txt:
     15        * assembler/MacroAssemblerCodeRef.h:
     16        (JSC::FunctionPtr::FunctionPtr):
     17        (JSC::FunctionPtr::value const):
     18        (JSC::FunctionPtr::executableAddress const):
     19        (JSC::ReturnAddressPtr::ReturnAddressPtr):
     20        (JSC::ReturnAddressPtr::value const):
     21        (JSC::MacroAssemblerCodePtr::MacroAssemblerCodePtr):
     22        (JSC::MacroAssemblerCodePtr::createFromExecutableAddress):
     23        (JSC::MacroAssemblerCodePtr::poisonedPtr const):
     24        (JSC::MacroAssemblerCodePtr:: const):
     25        (JSC::MacroAssemblerCodePtr::operator! const):
     26        (JSC::MacroAssemblerCodePtr::operator== const):
     27        (JSC::MacroAssemblerCodePtr::emptyValue):
     28        (JSC::MacroAssemblerCodePtr::deletedValue):
     29        (JSC::MacroAssemblerCodePtr::scrambledPtr const): Deleted.
     30        * b3/B3LowerMacros.cpp:
     31        * b3/testb3.cpp:
     32        (JSC::B3::testInterpreter):
     33        * dfg/DFGSpeculativeJIT.cpp:
     34        (JSC::DFG::SpeculativeJIT::checkArray):
     35        (JSC::DFG::SpeculativeJIT::compileCheckSubClass):
     36        (JSC::DFG::SpeculativeJIT::compileNewStringObject):
     37        (JSC::DFG::SpeculativeJIT::emitSwitchIntJump):
     38        * ftl/FTLLowerDFGToB3.cpp:
     39        (JSC::FTL::DFG::LowerDFGToB3::compileNewStringObject):
     40        (JSC::FTL::DFG::LowerDFGToB3::compileCheckSubClass):
     41        * jit/AssemblyHelpers.h:
     42        (JSC::AssemblyHelpers::emitAllocateDestructibleObject):
     43        * jit/SpecializedThunkJIT.h:
     44        (JSC::SpecializedThunkJIT::loadArgumentWithSpecificClass):
     45        * jit/ThunkGenerators.cpp:
     46        (JSC::virtualThunkFor):
     47        (JSC::boundThisNoArgsFunctionCallGenerator):
     48        * llint/LLIntSlowPaths.cpp:
     49        (JSC::LLInt::handleHostCall):
     50        (JSC::LLInt::setUpCall):
     51        * llint/LowLevelInterpreter64.asm:
     52        * runtime/InitializeThreading.cpp:
     53        (JSC::initializeThreading):
     54        * runtime/JSCPoisonedPtr.cpp: Copied from Source/JavaScriptCore/runtime/JSCScrambledPtr.cpp.
     55        (JSC::initializePoison):
     56        (JSC::initializeScrambledPtrKeys): Deleted.
     57        * runtime/JSCPoisonedPtr.h: Copied from Source/JavaScriptCore/runtime/JSCScrambledPtr.h.
     58        * runtime/JSCScrambledPtr.cpp: Removed.
     59        * runtime/JSCScrambledPtr.h: Removed.
     60        * runtime/JSDestructibleObject.h:
     61        (JSC::JSDestructibleObject::classInfo const):
     62        * runtime/JSSegmentedVariableObject.h:
     63        (JSC::JSSegmentedVariableObject::classInfo const):
     64        * runtime/Structure.h:
     65        * runtime/VM.h:
     66
    1672017-12-07  Michael Catanzaro  <mcatanzaro@igalia.com>
    268
  • trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

    r225629 r225632  
    17211721                FE20CE9E15F04A9500DF3430 /* LLIntCLoop.h in Headers */ = {isa = PBXBuildFile; fileRef = FE20CE9C15F04A9500DF3430 /* LLIntCLoop.h */; settings = {ATTRIBUTES = (Private, ); }; };
    17221722                FE2A87601F02381600EB31B2 /* MinimumReservedZoneSize.h in Headers */ = {isa = PBXBuildFile; fileRef = FE2A875F1F02381600EB31B2 /* MinimumReservedZoneSize.h */; };
    1723                 FE2B0B691FD227E00075DA5F /* JSCScrambledPtr.h in Headers */ = {isa = PBXBuildFile; fileRef = FE2B0B671FD0D2960075DA5F /* JSCScrambledPtr.h */; settings = {ATTRIBUTES = (Private, ); }; };
     1723                FE2B0B691FD227E00075DA5F /* JSCPoisonedPtr.h in Headers */ = {isa = PBXBuildFile; fileRef = FE2B0B671FD0D2960075DA5F /* JSCPoisonedPtr.h */; settings = {ATTRIBUTES = (Private, ); }; };
    17241724                FE3022D31E3D73A500BAC493 /* SigillCrashAnalyzer.h in Headers */ = {isa = PBXBuildFile; fileRef = FE3022D11E3D739600BAC493 /* SigillCrashAnalyzer.h */; settings = {ATTRIBUTES = (Private, ); }; };
    17251725                FE3022D71E42857300BAC493 /* VMInspector.h in Headers */ = {isa = PBXBuildFile; fileRef = FE3022D51E42856700BAC493 /* VMInspector.h */; };
     
    45994599                FE20CE9C15F04A9500DF3430 /* LLIntCLoop.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LLIntCLoop.h; path = llint/LLIntCLoop.h; sourceTree = "<group>"; };
    46004600                FE2A875F1F02381600EB31B2 /* MinimumReservedZoneSize.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = MinimumReservedZoneSize.h; sourceTree = "<group>"; };
    4601                 FE2B0B671FD0D2960075DA5F /* JSCScrambledPtr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSCScrambledPtr.h; sourceTree = "<group>"; };
    4602                 FE2B0B681FD0D2970075DA5F /* JSCScrambledPtr.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSCScrambledPtr.cpp; sourceTree = "<group>"; };
     4601                FE2B0B671FD0D2960075DA5F /* JSCPoisonedPtr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSCPoisonedPtr.h; sourceTree = "<group>"; };
     4602                FE2B0B681FD0D2970075DA5F /* JSCPoisonedPtr.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSCPoisonedPtr.cpp; sourceTree = "<group>"; };
    46034603                FE2E6A7A1D6EA5FE0060F896 /* ThrowScope.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ThrowScope.cpp; sourceTree = "<group>"; };
    46044604                FE3022D01E3D739600BAC493 /* SigillCrashAnalyzer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SigillCrashAnalyzer.cpp; sourceTree = "<group>"; };
     
    65446544                                14ABB36E099C076400E2A24F /* JSCJSValue.h */,
    65456545                                865A30F0135007E100CDB49E /* JSCJSValueInlines.h */,
    6546                                 FE2B0B681FD0D2970075DA5F /* JSCScrambledPtr.cpp */,
    6547                                 FE2B0B671FD0D2960075DA5F /* JSCScrambledPtr.h */,
     6546                                FE2B0B681FD0D2970075DA5F /* JSCPoisonedPtr.cpp */,
     6547                                FE2B0B671FD0D2960075DA5F /* JSCPoisonedPtr.h */,
    65486548                                72AAF7CB1D0D318B005E60BE /* JSCustomGetterSetterFunction.cpp */,
    65496549                                72AAF7CC1D0D318B005E60BE /* JSCustomGetterSetterFunction.h */,
     
    81568156                                0F37308D1C0BD29100052BFA /* B3PhiChildren.h in Headers */,
    81578157                                0FEC852C1BDACDAC0080FF74 /* B3Procedure.h in Headers */,
    8158                                 FE2B0B691FD227E00075DA5F /* JSCScrambledPtr.h in Headers */,
     8158                                FE2B0B691FD227E00075DA5F /* JSCPoisonedPtr.h in Headers */,
    81598159                                0FEC852D1BDACDAC0080FF74 /* B3ProcedureInlines.h in Headers */,
    81608160                                0F725CAA1C503DED00AD943A /* B3PureCSE.h in Headers */,
  • trunk/Source/JavaScriptCore/Sources.txt

    r225629 r225632  
    773773runtime/JSBoundFunction.cpp
    774774runtime/JSCJSValue.cpp
    775 runtime/JSCScrambledPtr.cpp
     775runtime/JSCPoisonedPtr.cpp
    776776runtime/JSCallee.cpp
    777777runtime/JSCell.cpp
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerCodeRef.h

    r225629 r225632  
    2727
    2828#include "ExecutableAllocator.h"
    29 #include "JSCScrambledPtr.h"
     29#include "JSCPoisonedPtr.h"
    3030#include <wtf/DataLog.h>
    3131#include <wtf/PrintStream.h>
     
    6868        : m_value((void*)value)
    6969    {
    70         MasmScrambledPtr::assertIsNotScrambled(m_value);
     70        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    7171        ASSERT_VALID_CODE_POINTER(m_value);
    7272    }
     
    7676        : m_value((void*)value)
    7777    {
    78         MasmScrambledPtr::assertIsNotScrambled(m_value);
     78        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    7979        ASSERT_VALID_CODE_POINTER(m_value);
    8080    }
     
    8484        : m_value((void*)value)
    8585    {
    86         MasmScrambledPtr::assertIsNotScrambled(m_value);
     86        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    8787        ASSERT_VALID_CODE_POINTER(m_value);
    8888    }
     
    9292        : m_value((void*)value)
    9393    {
    94         MasmScrambledPtr::assertIsNotScrambled(m_value);
     94        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    9595        ASSERT_VALID_CODE_POINTER(m_value);
    9696    }
     
    100100        : m_value((void*)value)
    101101    {
    102         MasmScrambledPtr::assertIsNotScrambled(m_value);
     102        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    103103        ASSERT_VALID_CODE_POINTER(m_value);
    104104    }
     
    108108        : m_value((void*)value)
    109109    {
    110         MasmScrambledPtr::assertIsNotScrambled(m_value);
     110        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    111111        ASSERT_VALID_CODE_POINTER(m_value);
    112112    }
     
    116116        : m_value((void*)value)
    117117    {
    118         MasmScrambledPtr::assertIsNotScrambled(m_value);
     118        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    119119        ASSERT_VALID_CODE_POINTER(m_value);
    120120    }
     
    127127        : m_value((void*)value)
    128128    {
    129         MasmScrambledPtr::assertIsNotScrambled(m_value);
     129        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    130130        ASSERT_VALID_CODE_POINTER(m_value);
    131131    }
     
    135135        : m_value((void*)value)
    136136    {
    137         MasmScrambledPtr::assertIsNotScrambled(m_value);
     137        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    138138        ASSERT_VALID_CODE_POINTER(m_value);
    139139    }
     
    143143        : m_value((void*)value)
    144144    {
    145         MasmScrambledPtr::assertIsNotScrambled(m_value);
     145        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    146146        ASSERT_VALID_CODE_POINTER(m_value);
    147147    }
     
    151151        : m_value((void*)value)
    152152    {
    153         MasmScrambledPtr::assertIsNotScrambled(m_value);
     153        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    154154        ASSERT_VALID_CODE_POINTER(m_value);
    155155    }
     
    159159        : m_value((void*)value)
    160160    {
    161         MasmScrambledPtr::assertIsNotScrambled(m_value);
     161        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    162162        ASSERT_VALID_CODE_POINTER(m_value);
    163163    }
     
    170170        : m_value((void*)value)
    171171    {
    172         MasmScrambledPtr::assertIsNotScrambled(m_value);
     172        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    173173        ASSERT_VALID_CODE_POINTER(m_value);
    174174    }
     
    178178        : m_value((void*)value)
    179179    {
    180         MasmScrambledPtr::assertIsNotScrambled(m_value);
     180        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    181181        ASSERT_VALID_CODE_POINTER(m_value);
    182182    }
     
    186186        : m_value((void*)value)
    187187    {
    188         MasmScrambledPtr::assertIsNotScrambled(m_value);
     188        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    189189        ASSERT_VALID_CODE_POINTER(m_value);
    190190    }
     
    194194        : m_value((void*)value)
    195195    {
    196         MasmScrambledPtr::assertIsNotScrambled(m_value);
     196        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    197197        ASSERT_VALID_CODE_POINTER(m_value);
    198198    }
     
    202202        : m_value((void*)value)
    203203    {
    204         MasmScrambledPtr::assertIsNotScrambled(m_value);
     204        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    205205        ASSERT_VALID_CODE_POINTER(m_value);
    206206    }
     
    214214        : m_value((void*)value)
    215215    {
    216         MasmScrambledPtr::assertIsNotScrambled(m_value);
     216        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    217217        ASSERT_VALID_CODE_POINTER(m_value);
    218218    }
     
    222222    void* value() const
    223223    {
    224         MasmScrambledPtr::assertIsNotScrambled(m_value);
     224        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    225225        return m_value;
    226226    }
    227227    void* executableAddress() const
    228228    {
    229         MasmScrambledPtr::assertIsNotScrambled(m_value);
     229        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    230230        return m_value;
    231231    }
     
    248248        : m_value(value)
    249249    {
    250         MasmScrambledPtr::assertIsNotScrambled(m_value);
     250        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    251251        ASSERT_VALID_CODE_POINTER(m_value);
    252252    }
     
    255255        : m_value(function.value())
    256256    {
    257         MasmScrambledPtr::assertIsNotScrambled(m_value);
     257        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    258258        ASSERT_VALID_CODE_POINTER(m_value);
    259259    }
     
    261261    void* value() const
    262262    {
    263         MasmScrambledPtr::assertIsNotScrambled(m_value);
     263        PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    264264        return m_value;
    265265    }
     
    289289#endif
    290290    {
    291         m_value.assertIsScrambled();
     291        m_value.assertIsPoisoned();
    292292        ASSERT(value);
    293293        ASSERT_VALID_CODE_POINTER(m_value);
     
    299299        ASSERT_VALID_CODE_POINTER(value);
    300300        MacroAssemblerCodePtr result;
    301         result.m_value = MasmScrambledPtr(value);
    302         result.m_value.assertIsScrambled();
     301        result.m_value = PoisonedMasmPtr(value);
     302        result.m_value.assertIsPoisoned();
    303303        return result;
    304304    }
     
    310310    {
    311311        ASSERT(ra.value());
    312         m_value.assertIsScrambled();
    313         ASSERT_VALID_CODE_POINTER(m_value);
    314     }
    315 
    316     MasmScrambledPtr scrambledPtr() const { return m_value; }
     312        m_value.assertIsPoisoned();
     313        ASSERT_VALID_CODE_POINTER(m_value);
     314    }
     315
     316    PoisonedMasmPtr poisonedPtr() const { return m_value; }
    317317
    318318    template<typename T = void*>
    319319    T executableAddress() const
    320320    {
    321         m_value.assertIsScrambled();
    322         return m_value ? m_value.descrambled<T>() : static_cast<T>(0);
     321        m_value.assertIsPoisoned();
     322        return m_value.unpoisoned<T>();
    323323    }
    324324#if CPU(ARM_THUMB2)
     
    327327    T dataLocation() const
    328328    {
    329         m_value.assertIsScrambled();
    330         ASSERT_VALID_CODE_POINTER(m_value);
    331         return bitwise_cast<T>(m_value ? m_value.descrambled<char*>() - 1 : nullptr);
     329        m_value.assertIsPoisoned();
     330        ASSERT_VALID_CODE_POINTER(m_value);
     331        return bitwise_cast<T>(m_value ? m_value.unpoisoned<char*>() - 1 : nullptr);
    332332    }
    333333#else
     
    335335    T dataLocation() const
    336336    {
    337         m_value.assertIsScrambled();
    338         ASSERT_VALID_CODE_POINTER(m_value);
    339         return m_value ? m_value.descrambled<T>() : static_cast<T>(0);
     337        m_value.assertIsPoisoned();
     338        ASSERT_VALID_CODE_POINTER(m_value);
     339        return m_value.unpoisoned<T>();
    340340    }
    341341#endif
     
    343343    bool operator!() const
    344344    {
    345 #if ENABLE(SCRAMBLED_PTR_ASSERTS)
     345#if ENABLE(POISON_ASSERTS)
    346346        if (!isEmptyValue() && !isDeletedValue())
    347             m_value.assertIsScrambled();
     347            m_value.assertIsPoisoned();
    348348#endif
    349349        return !m_value;
     
    353353    bool operator==(const MacroAssemblerCodePtr& other) const
    354354    {
    355 #if ENABLE(SCRAMBLED_PTR_ASSERTS)
     355#if ENABLE(POISON_ASSERTS)
    356356        if (!isEmptyValue() && !isDeletedValue())
    357             m_value.assertIsScrambled();
     357            m_value.assertIsPoisoned();
    358358        if (!other.isEmptyValue() && !other.isDeletedValue())
    359             other.m_value.assertIsScrambled();
     359            other.m_value.assertIsPoisoned();
    360360#endif
    361361        return m_value == other.m_value;
     
    363363
    364364    // Disallow any casting operations (except for booleans). Instead, the client
    365     // should be asking for scrambledPtr() or executableAddress() explicitly.
     365    // should be asking for poisonedPtr() or executableAddress() explicitly.
    366366    template<typename T, typename = std::enable_if_t<!std::is_same<T, bool>::value>>
    367367    operator T() = delete;
     
    390390
    391391private:
    392     static MasmScrambledPtr emptyValue() { return MasmScrambledPtr(1); }
    393     static MasmScrambledPtr deletedValue() { return MasmScrambledPtr(2); }
    394 
    395     MasmScrambledPtr m_value;
     392    static PoisonedMasmPtr emptyValue() { return PoisonedMasmPtr(1); }
     393    static PoisonedMasmPtr deletedValue() { return PoisonedMasmPtr(2); }
     394
     395    PoisonedMasmPtr m_value;
    396396};
    397397
     
    480480    : m_value(ptr.executableAddress())
    481481{
    482     MasmScrambledPtr::assertIsNotScrambled(m_value);
     482    PoisonedMasmPtr::assertIsNotPoisoned(m_value);
    483483    ASSERT_VALID_CODE_POINTER(m_value);
    484484}
  • trunk/Source/JavaScriptCore/b3/B3LowerMacros.cpp

    r225629 r225632  
    506506                        GPRReg index = params[0].gpr();
    507507                        GPRReg scratch = params.gpScratch(0);
    508                         GPRReg descramblerKey = params.gpScratch(1);
    509 
    510                         jit.move(CCallHelpers::TrustedImm64(g_masmScrambledPtrKey), descramblerKey);
     508                        GPRReg poisonScratch = params.gpScratch(1);
     509
     510                        jit.move(CCallHelpers::TrustedImm64(g_masmPoison), poisonScratch);
    511511                        jit.move(CCallHelpers::TrustedImmPtr(jumpTable), scratch);
    512512                        jit.load64(CCallHelpers::BaseIndex(scratch, index, CCallHelpers::timesPtr()), scratch);
    513                         jit.xor64(descramblerKey, scratch);
     513                        jit.xor64(poisonScratch, scratch);
    514514                        jit.jump(scratch);
    515515
  • trunk/Source/JavaScriptCore/b3/testb3.cpp

    r225629 r225632  
    1303113031
    1303213032            GPRReg scratch = params.gpScratch(0);
    13033             GPRReg descramblerKey = params.gpScratch(1);
     13033            GPRReg poisonScratch = params.gpScratch(1);
    1303413034
    1303513035            jit.move(CCallHelpers::TrustedImmPtr(jumpTable), scratch);
    13036             jit.move(CCallHelpers::TrustedImm64(g_masmScrambledPtrKey), descramblerKey);
     13036            jit.move(CCallHelpers::TrustedImm64(g_masmPoison), poisonScratch);
    1303713037            jit.load64(CCallHelpers::BaseIndex(scratch, params[0].gpr(), CCallHelpers::timesPtr()), scratch);
    13038             jit.xor64(descramblerKey, scratch);
     13038            jit.xor64(poisonScratch, scratch);
    1303913039            jit.jump(scratch);
    1304013040
  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp

    r225629 r225632  
    869869            MacroAssembler::NotEqual,
    870870            MacroAssembler::Address(temp.gpr(), Structure::classInfoOffset()),
    871             TrustedImmPtr(ClassInfoScrambledPtr(expectedClassInfo).bits())));
     871            TrustedImmPtr(PoisonedClassInfoPtr(expectedClassInfo).bits())));
    872872
    873873    noResult(m_currentNode);
     
    87078707        m_jit.loadPtr(CCallHelpers::Address(otherGPR, Structure::classInfoOffset()), otherGPR);
    87088708#if USE(JSVALUE64)
    8709         m_jit.move(CCallHelpers::TrustedImm64(g_classInfoScrambledPtrKey), specifiedGPR);
     8709        m_jit.move(CCallHelpers::TrustedImm64(g_classInfoPoison), specifiedGPR);
    87108710        m_jit.xor64(specifiedGPR, otherGPR);
    87118711#endif
     
    90049004   
    90059005    m_jit.storePtr(
    9006         TrustedImmPtr(ClassInfoScrambledPtr(StringObject::info()).bits()),
     9006        TrustedImmPtr(PoisonedClassInfoPtr(StringObject::info()).bits()),
    90079007        JITCompiler::Address(resultGPR, JSDestructibleObject::classInfoOffset()));
    90089008#if USE(JSVALUE64)
     
    97759775
    97769776void SpeculativeJIT::emitSwitchIntJump(
    9777     SwitchData* data, GPRReg value, GPRReg scratch, GPRReg descramblerKeyScratch)
     9777    SwitchData* data, GPRReg value, GPRReg scratch, GPRReg poisonScratch)
    97789778{
    97799779    SimpleJumpTable& table = m_jit.codeBlock()->switchJumpTable(data->switchTableIndex);
     
    97839783        m_jit.branch32(JITCompiler::AboveOrEqual, value, Imm32(table.ctiOffsets.size())),
    97849784        data->fallThrough.block);
    9785     UNUSED_PARAM(descramblerKeyScratch); // Placate the 32-bit build.
     9785    UNUSED_PARAM(poisonScratch); // Placate the 32-bit build.
    97869786#if USE(JSVALUE64)
    9787     m_jit.move(TrustedImm64(g_masmScrambledPtrKey), descramblerKeyScratch);
     9787    m_jit.move(TrustedImm64(g_masmPoison), poisonScratch);
    97889788#endif
    97899789    m_jit.move(TrustedImmPtr(table.ctiOffsets.begin()), scratch);
     
    97919791   
    97929792#if USE(JSVALUE64)
    9793     m_jit.xor64(descramblerKeyScratch, scratch);
     9793    m_jit.xor64(poisonScratch, scratch);
    97949794#endif
    97959795    m_jit.jump(scratch);
  • trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp

    r225629 r225632  
    50115011
    50125012        LValue fastResultValue = allocateObject<StringObject>(structure, m_out.intPtrZero, slowCase);
    5013         m_out.storePtr(m_out.constIntPtr(ClassInfoScrambledPtr(StringObject::info()).bits()), fastResultValue, m_heaps.JSDestructibleObject_classInfo);
     5013        m_out.storePtr(m_out.constIntPtr(PoisonedClassInfoPtr(StringObject::info()).bits()), fastResultValue, m_heaps.JSDestructibleObject_classInfo);
    50145014        m_out.store64(string, fastResultValue, m_heaps.JSWrapperObject_internalValue);
    50155015        mutatorFence();
     
    1117111171
    1117211172            LValue structure = loadStructure(cell);
    11173             LValue scrambledClassInfo = m_out.loadPtr(structure, m_heaps.Structure_classInfo);
    11174             LValue classInfo = m_out.bitXor(scrambledClassInfo, m_out.constInt64(g_classInfoScrambledPtrKey));
     11173            LValue poisonedClassInfo = m_out.loadPtr(structure, m_heaps.Structure_classInfo);
     11174            LValue classInfo = m_out.bitXor(poisonedClassInfo, m_out.constInt64(g_classInfoPoison));
    1117511175            ValueFromBlock otherAtStart = m_out.anchor(classInfo);
    1117611176            m_out.jump(loop);
  • trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h

    r225629 r225632  
    16261626    {
    16271627        emitAllocateJSObject<ClassType>(vm, resultGPR, TrustedImmPtr(structure), TrustedImmPtr(0), scratchGPR1, scratchGPR2, slowPath);
    1628         storePtr(TrustedImmPtr(ClassInfoScrambledPtr(structure->classInfo()).bits()), Address(resultGPR, JSDestructibleObject::classInfoOffset()));
     1628        storePtr(TrustedImmPtr(PoisonedClassInfoPtr(structure->classInfo()).bits()), Address(resultGPR, JSDestructibleObject::classInfoOffset()));
    16291629    }
    16301630   
  • trunk/Source/JavaScriptCore/jit/SpecializedThunkJIT.h

    r225629 r225632  
    7878            loadCellArgument(argument, dst);
    7979            emitLoadStructure(*vm(), dst, scratch, dst);
    80             appendFailure(branchPtr(NotEqual, Address(scratch, Structure::classInfoOffset()), TrustedImmPtr(ClassInfoScrambledPtr(classInfo).bits())));
     80            appendFailure(branchPtr(NotEqual, Address(scratch, Structure::classInfoOffset()), TrustedImmPtr(PoisonedClassInfoPtr(classInfo).bits())));
    8181            // We have to reload the argument since emitLoadStructure clobbered it.
    8282            loadCellArgument(argument, dst);
  • trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp

    r225629 r225632  
    215215    // call.
    216216#if USE(JSVALUE64)
    217     jit.move(CCallHelpers::TrustedImm64(g_masmScrambledPtrKey), GPRInfo::regT1);
     217    jit.move(CCallHelpers::TrustedImm64(g_masmPoison), GPRInfo::regT1);
    218218    jit.xor64(GPRInfo::regT1, GPRInfo::regT4);
    219219#endif
     
    11641164   
    11651165#if USE(JSVALUE64)
    1166     jit.move(CCallHelpers::TrustedImm64(g_masmScrambledPtrKey), GPRInfo::regT1);
     1166    jit.move(CCallHelpers::TrustedImm64(g_masmPoison), GPRInfo::regT1);
    11671167    jit.xor64(GPRInfo::regT1, GPRInfo::regT0);
    11681168#endif
  • trunk/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp

    r225629 r225632  
    13041304            vm.hostCallReturnValue = JSValue::decode(callData.native.function(execCallee));
    13051305           
    1306             MasmScrambledPtr::assertIsNotScrambled(LLInt::getCodePtr(getHostCallReturnValue));
     1306            PoisonedMasmPtr::assertIsNotPoisoned(LLInt::getCodePtr(getHostCallReturnValue));
    13071307            LLINT_CALL_RETURN(execCallee, execCallee, LLInt::getCodePtr(getHostCallReturnValue));
    13081308        }
     
    13281328        vm.hostCallReturnValue = JSValue::decode(constructData.native.function(execCallee));
    13291329
    1330         MasmScrambledPtr::assertIsNotScrambled(LLInt::getCodePtr(getHostCallReturnValue));
     1330        PoisonedMasmPtr::assertIsNotPoisoned(LLInt::getCodePtr(getHostCallReturnValue));
    13311331        LLINT_CALL_RETURN(execCallee, execCallee, LLInt::getCodePtr(getHostCallReturnValue));
    13321332    }
     
    13691369            }
    13701370
    1371             MasmScrambledPtr::assertIsNotScrambled(codePtr.executableAddress());
     1371            PoisonedMasmPtr::assertIsNotPoisoned(codePtr.executableAddress());
    13721372            LLINT_CALL_RETURN(exec, execCallee, codePtr.executableAddress());
    13731373        }
     
    14201420    }
    14211421
    1422     MasmScrambledPtr::assertIsNotScrambled(codePtr.executableAddress());
     1422    PoisonedMasmPtr::assertIsNotPoisoned(codePtr.executableAddress());
    14231423    LLINT_CALL_RETURN(exec, execCallee, codePtr.executableAddress());
    14241424}
  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm

    r225629 r225632  
    19511951        callTargetFunction(LLIntCallLinkInfo::machineCodeTarget[t1])
    19521952    else
    1953         loadp _g_masmScrambledPtrKey, t2
     1953        loadp _g_masmPoison, t2
    19541954        xorp LLIntCallLinkInfo::machineCodeTarget[t1], t2
    19551955        prepareCall(t2, t1, t3, t4)
  • trunk/Source/JavaScriptCore/runtime/InitializeThreading.cpp

    r225629 r225632  
    6060    std::call_once(initializeThreadingOnceFlag, []{
    6161        WTF::initializeThreading();
    62         initializeScrambledPtrKeys();
     62        initializePoison();
    6363        Options::initialize();
    6464#if ENABLE(WRITE_BARRIER_PROFILING)
  • trunk/Source/JavaScriptCore/runtime/JSCPoisonedPtr.cpp

    r225631 r225632  
    2525
    2626#include "config.h"
    27 #include "JSCScrambledPtr.h"
     27#include "JSCPoisonedPtr.h"
    2828
    2929namespace JSC {
    3030
    31 uintptr_t g_classInfoScrambledPtrKey;
    32 uintptr_t g_masmScrambledPtrKey;
     31uintptr_t g_classInfoPoison;
     32uintptr_t g_masmPoison;
    3333
    34 void initializeScrambledPtrKeys()
     34void initializePoison()
    3535{
    3636    static std::once_flag initializeOnceFlag;
    3737    std::call_once(initializeOnceFlag, [] {
    38         g_classInfoScrambledPtrKey = makeScrambledPtrKey();
    39         g_masmScrambledPtrKey = makeScrambledPtrKey();
     38        g_classInfoPoison = makePoison();
     39        g_masmPoison = makePoison();
    4040    });
    4141}
  • trunk/Source/JavaScriptCore/runtime/JSCPoisonedPtr.h

    r225631 r225632  
    2626#pragma once
    2727
    28 #include <wtf/ScrambledPtr.h>
     28#include <wtf/Poisoned.h>
    2929
    3030namespace JSC {
    3131
    32 extern "C" JS_EXPORTDATA uintptr_t g_classInfoScrambledPtrKey;
    33 extern "C" JS_EXPORTDATA uintptr_t g_masmScrambledPtrKey;
     32extern "C" JS_EXPORTDATA uintptr_t g_classInfoPoison;
     33extern "C" JS_EXPORTDATA uintptr_t g_masmPoison;
    3434
    3535struct ClassInfo;
    3636
    37 using ClassInfoScrambledPtr = ScrambledPtr<const ClassInfo*, g_classInfoScrambledPtrKey>;
    38 using MasmScrambledPtr = ScrambledPtr<void*, g_masmScrambledPtrKey>;
     37using PoisonedClassInfoPtr = Poisoned<g_classInfoPoison, const ClassInfo*>;
     38using PoisonedMasmPtr = Poisoned<g_masmPoison, void*>;
    3939
    40 void initializeScrambledPtrKeys();
     40void initializePoison();
    4141
    4242} // namespace JSC
  • trunk/Source/JavaScriptCore/runtime/JSDestructibleObject.h

    r225629 r225632  
    4444    }
    4545
    46     const ClassInfo* classInfo() const { return m_classInfo.descrambled(); }
     46    const ClassInfo* classInfo() const { return m_classInfo.unpoisoned(); }
    4747   
    4848    static ptrdiff_t classInfoOffset() { return OBJECT_OFFSETOF(JSDestructibleObject, m_classInfo); }
     
    5757
    5858private:
    59     ClassInfoScrambledPtr m_classInfo;
     59    PoisonedClassInfoPtr m_classInfo;
    6060};
    6161
  • trunk/Source/JavaScriptCore/runtime/JSSegmentedVariableObject.h

    r225629 r225632  
    9595    }
    9696   
    97     const ClassInfo* classInfo() const { return m_classInfo.descrambled(); }
     97    const ClassInfo* classInfo() const { return m_classInfo.unpoisoned(); }
    9898   
    9999protected:
     
    108108    ConcurrentJSLock m_lock;
    109109    bool m_alreadyDestroyed { false }; // We use these assertions to check that we aren't doing ancient hacks that result in this being destroyed more than once.
    110     ClassInfoScrambledPtr m_classInfo;
     110    PoisonedClassInfoPtr m_classInfo;
    111111};
    112112
  • trunk/Source/JavaScriptCore/runtime/Structure.h

    r225629 r225632  
    469469    void setObjectToStringValue(ExecState*, VM&, JSString* value, PropertySlot toStringTagSymbolSlot);
    470470
    471     const ClassInfo* classInfo() const { return m_classInfo.descrambled(); }
     471    const ClassInfo* classInfo() const { return m_classInfo.unpoisoned(); }
    472472
    473473    static ptrdiff_t structureIDOffset()
     
    799799    RefPtr<UniquedStringImpl> m_nameInPrevious;
    800800
    801     ClassInfoScrambledPtr m_classInfo;
     801    PoisonedClassInfoPtr m_classInfo;
    802802
    803803    StructureTransitionTable m_transitionTable;
  • trunk/Source/JavaScriptCore/runtime/VM.h

    r225629 r225632  
    415415   
    416416    JSCell* currentlyDestructingCallbackObject;
    417     ClassInfoScrambledPtr currentlyDestructingCallbackObjectClassInfo;
     417    PoisonedClassInfoPtr currentlyDestructingCallbackObjectClassInfo;
    418418
    419419    AtomicStringTable* m_atomicStringTable;
  • trunk/Source/WTF/ChangeLog

    r225629 r225632  
     12017-12-07  Mark Lam  <mark.lam@apple.com>
     2
     3        [Re-landing r225620] Refactoring: Rename ScrambledPtr to Poisoned.
     4        https://bugs.webkit.org/show_bug.cgi?id=180514
     5
     6        Reviewed by Saam Barati and JF Bastien.
     7
     8        Re-landing r225620 with speculative build fix for GCC 7.
     9
     10        * WTF.xcodeproj/project.pbxproj:
     11        * wtf/CMakeLists.txt:
     12        * wtf/Poisoned.cpp: Copied from Source/WTF/wtf/ScrambledPtr.cpp.
     13        (WTF::makePoison):
     14        (WTF::makeScrambledPtrKey): Deleted.
     15        * wtf/Poisoned.h: Copied from Source/WTF/wtf/ScrambledPtr.h.
     16        (WTF::PoisonedImpl::PoisonedImpl):
     17        (WTF::PoisonedImpl::assertIsPoisoned const):
     18        (WTF::PoisonedImpl::assertIsNotPoisoned const):
     19        (WTF::PoisonedImpl::unpoisoned const):
     20        (WTF::PoisonedImpl::operator-> const):
     21        (WTF::PoisonedImpl::bits const):
     22        (WTF::PoisonedImpl::operator! const):
     23        (WTF::PoisonedImpl::operator bool const):
     24        (WTF::PoisonedImpl::operator== const):
     25        (WTF::PoisonedImpl::operator==):
     26        (WTF::PoisonedImpl::operator=):
     27        (WTF::PoisonedImpl::poison):
     28        (WTF::PoisonedImpl::unpoison):
     29        (WTF::ScrambledPtr::ScrambledPtr): Deleted.
     30        (WTF::ScrambledPtr::assertIsScrambled const): Deleted.
     31        (WTF::ScrambledPtr::assertIsNotScrambled const): Deleted.
     32        (WTF::ScrambledPtr::descrambled const): Deleted.
     33        (WTF::ScrambledPtr::operator-> const): Deleted.
     34        (WTF::ScrambledPtr::bits const): Deleted.
     35        (WTF::ScrambledPtr::operator! const): Deleted.
     36        (WTF::ScrambledPtr::operator bool const): Deleted.
     37        (WTF::ScrambledPtr::operator== const): Deleted.
     38        (WTF::ScrambledPtr::operator==): Deleted.
     39        (WTF::ScrambledPtr::operator=): Deleted.
     40        (WTF::ScrambledPtr::scramble): Deleted.
     41        (WTF::ScrambledPtr::descramble): Deleted.
     42        * wtf/ScrambledPtr.cpp: Removed.
     43        * wtf/ScrambledPtr.h: Removed.
     44
    1452017-12-07  Michael Catanzaro  <mcatanzaro@igalia.com>
    246
  • trunk/Source/WTF/WTF.xcodeproj/project.pbxproj

    r225629 r225632  
    150150                E4A0AD391A96245500536DF6 /* WorkQueue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4A0AD371A96245500536DF6 /* WorkQueue.cpp */; };
    151151                E4A0AD3D1A96253C00536DF6 /* WorkQueueCocoa.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4A0AD3C1A96253C00536DF6 /* WorkQueueCocoa.cpp */; };
    152                 FE85416E1FBE285D008DA5DA /* ScrambledPtr.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE85416C1FBE285B008DA5DA /* ScrambledPtr.cpp */; };
     152                FE85416E1FBE285D008DA5DA /* Poisoned.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE85416C1FBE285B008DA5DA /* Poisoned.cpp */; };
    153153                FEDACD3D1630F83F00C69634 /* StackStats.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FEDACD3B1630F83F00C69634 /* StackStats.cpp */; };
    154154/* End PBXBuildFile section */
     
    611611                F72BBDB107FA424886178B9E /* SymbolImpl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SymbolImpl.cpp; sourceTree = "<group>"; };
    612612                FE8225301B2A1E5B00BA68FD /* NakedPtr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NakedPtr.h; sourceTree = "<group>"; };
    613                 FE85416C1FBE285B008DA5DA /* ScrambledPtr.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ScrambledPtr.cpp; sourceTree = "<group>"; };
    614                 FE85416D1FBE285C008DA5DA /* ScrambledPtr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrambledPtr.h; sourceTree = "<group>"; };
     613                FE85416C1FBE285B008DA5DA /* Poisoned.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Poisoned.cpp; sourceTree = "<group>"; };
     614                FE85416D1FBE285C008DA5DA /* Poisoned.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Poisoned.h; sourceTree = "<group>"; };
    615615                FE86A8741E59440200111BBF /* ForbidHeapAllocation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ForbidHeapAllocation.h; sourceTree = "<group>"; };
    616616                FE8925AF1D00DAEC0046907E /* Indenter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Indenter.h; sourceTree = "<group>"; };
     
    966966                                E3200AB41E9A536D003B59D2 /* PlatformRegisters.h */,
    967967                                0FF860941BCCBD740045127F /* PointerComparison.h */,
     968                                FE85416C1FBE285B008DA5DA /* Poisoned.cpp */,
     969                                FE85416D1FBE285C008DA5DA /* Poisoned.h */,
    968970                                0F9D335D165DBA73005AD387 /* PrintStream.cpp */,
    969971                                0F9D335E165DBA73005AD387 /* PrintStream.h */,
     
    10021004                                1A3524AA1D63A2FF0031729B /* Scope.h */,
    10031005                                0FEC84B01BDACD390080FF74 /* ScopedLambda.h */,
    1004                                 FE85416C1FBE285B008DA5DA /* ScrambledPtr.cpp */,
    1005                                 FE85416D1FBE285C008DA5DA /* ScrambledPtr.h */,
    10061006                                0F66B2841DC97BAB004A1D3F /* Seconds.cpp */,
    10071007                                0F66B2851DC97BAB004A1D3F /* Seconds.h */,
     
    14631463                                1469419916EAB0410024E146 /* SchedulePairCF.cpp in Sources */,
    14641464                                1469419716EAAFF80024E146 /* SchedulePairMac.mm in Sources */,
    1465                                 FE85416E1FBE285D008DA5DA /* ScrambledPtr.cpp in Sources */,
     1465                                FE85416E1FBE285D008DA5DA /* Poisoned.cpp in Sources */,
    14661466                                0F66B28E1DC97BAB004A1D3F /* Seconds.cpp in Sources */,
    14671467                                A8A47421151A825B004123FF /* SHA1.cpp in Sources */,
  • trunk/Source/WTF/wtf/CMakeLists.txt

    r225629 r225632  
    108108    Platform.h
    109109    PlatformRegisters.h
     110    Poisoned.h
    110111    PrintStream.h
    111112    ProcessID.h
     
    131132    SaturatedArithmetic.h
    132133    ScopedLambda.h
    133     ScrambledPtr.h
    134134    Seconds.h
    135135    SegmentedVector.h
     
    259259    ParallelJobsGeneric.cpp
    260260    ParkingLot.cpp
     261    Poisoned.cpp
    261262    PrintStream.cpp
    262263    RAMSize.cpp
     
    267268    RunLoop.cpp
    268269    SHA1.cpp
    269     ScrambledPtr.cpp
    270270    Seconds.cpp
    271271    SixCharacterHash.cpp
  • trunk/Source/WTF/wtf/Poisoned.cpp

    r225631 r225632  
    2525
    2626#include "config.h"
    27 #include "ScrambledPtr.h"
     27#include "Poisoned.h"
    2828
    2929#include <wtf/CryptographicallyRandomNumber.h>
     
    3131namespace WTF {
    3232
    33 uintptr_t makeScrambledPtrKey()
     33uintptr_t makePoison()
    3434{
    3535    uintptr_t key = cryptographicallyRandomNumber();
    3636#if USE(JSVALUE64) && !OS(WINDOWS)
    3737    key = (key << 32) ^ (static_cast<uintptr_t>(cryptographicallyRandomNumber()) << 3);
    38     // Ensure that the scrambled bits (pointer ^ key) do not make a valid pointer and
    39     // cannot be 0. We ensure that it is zero so that the scrambled bits can also be
    40     // used for a notmal zero check without needing to descramble first.
     38    // Ensure that the poisoned bits (pointer ^ key) do not make a valid pointer and
     39    // cannot be 0. We ensure that it is zero so that the poisoned bits can also be
     40    // used for a notmal zero check without needing to decoded first.
    4141    key |= (static_cast<uintptr_t>(0x1) << 63);
    4242#else
    43     key = 0; // Scrambling is not supported on 32-bit or non-darwin platforms yet.
     43    key = 0; // Poisoning is not supported on 32-bit or non-darwin platforms yet.
    4444#endif
    4545    return key;
  • trunk/Source/WTF/wtf/Poisoned.h

    r225631 r225632  
    2828#include <wtf/Assertions.h>
    2929
    30 #define ENABLE_SCRAMBLED_PTR_ASSERTS 0
     30#define ENABLE_POISON_ASSERTS 0
    3131
    3232// Not currently supported for 32-bit or OS(WINDOWS) builds (because of missing llint support).
    3333// Make sure it's disabled.
    3434#if USE(JSVALUE32_64) || OS(WINDOWS)
    35 #undef ENABLE_SCRAMBLED_PTR_ASSERTS
    36 #define ENABLE_SCRAMBLED_PTR_ASSERTS 0
     35#undef ENABLE_POISON_ASSERTS
     36#define ENABLE_POISON_ASSERTS 0
    3737#endif
    3838
    3939namespace WTF {
    4040
    41 using ScrambledPtrBits = uintptr_t;
     41using PoisonedBits = uintptr_t;
    4242
    43 template<typename T, uintptr_t& key, typename = std::enable_if_t<std::is_pointer<T>::value>>
    44 class ScrambledPtr {
     43template<typename KeyType, KeyType key, typename T, typename = std::enable_if_t<std::is_pointer<T>::value>>
     44class PoisonedImpl {
    4545public:
    46     ScrambledPtr() { }
     46    PoisonedImpl() { }
    4747
    48     explicit ScrambledPtr(T ptr)
    49         : m_scrambledBits(scramble(ptr))
     48    explicit PoisonedImpl(T ptr)
     49        : m_poisonedBits(poison(ptr))
    5050    {
    51         ASSERT(ptr && m_scrambledBits);
     51        ASSERT(ptr && m_poisonedBits);
    5252    }
    5353
    54     ScrambledPtr(const ScrambledPtr&) = default;
     54    PoisonedImpl(const PoisonedImpl&) = default;
    5555
    56     explicit ScrambledPtr(ScrambledPtrBits scrambledBits)
    57         : m_scrambledBits(scrambledBits)
     56    explicit PoisonedImpl(PoisonedBits poisonedBits)
     57        : m_poisonedBits(poisonedBits)
    5858    {
    59         ASSERT(m_scrambledBits);
     59        ASSERT(m_poisonedBits);
    6060    }
    6161
    62 #if ENABLE(SCRAMBLED_PTR_ASSERTS)
     62#if ENABLE(POISON_ASSERTS)
    6363    template<typename U = void*>
    64     static bool isScrambled(U value) { return !value || (reinterpret_cast<uintptr_t>(value) & 0xffff000000000000); }
     64    static bool isPoisoned(U value) { return !value || (reinterpret_cast<uintptr_t>(value) & 0xffff000000000000); }
    6565    template<typename U = void*>
    66     static void assertIsScrambled(U value) { RELEASE_ASSERT(isScrambled(value)); }
     66    static void assertIsPoisoned(U value) { RELEASE_ASSERT(isPoisoned(value)); }
    6767    template<typename U = void*>
    68     static void assertIsNotScrambled(U value) { RELEASE_ASSERT(!isScrambled(value)); }
     68    static void assertIsNotPoisoned(U value) { RELEASE_ASSERT(!isPoisoned(value)); }
    6969#else
    70     template<typename U = void*> static void assertIsScrambled(U) { }
    71     template<typename U = void*> static void assertIsNotScrambled(U) { }
     70    template<typename U = void*> static void assertIsPoisoned(U) { }
     71    template<typename U = void*> static void assertIsNotPoisoned(U) { }
    7272#endif
    73     void assertIsScrambled() const { assertIsScrambled(m_scrambledBits); }
    74     void assertIsNotScrambled() const { assertIsNotScrambled(m_scrambledBits); }
     73    void assertIsPoisoned() const { assertIsPoisoned(m_poisonedBits); }
     74    void assertIsNotPoisoned() const { assertIsNotPoisoned(m_poisonedBits); }
    7575
    7676    template<typename U = T>
    77     U descrambled() const { return descramble<U>(m_scrambledBits); }
     77    U unpoisoned() const { return unpoison<U>(m_poisonedBits); }
    7878
    79     ALWAYS_INLINE T operator->() const { return descramble<T>(m_scrambledBits); }
     79    ALWAYS_INLINE T operator->() const { return unpoison<T>(m_poisonedBits); }
    8080
    81     template<typename U = ScrambledPtrBits>
    82     U bits() const { return bitwise_cast<U>(m_scrambledBits); }
     81    template<typename U = PoisonedBits>
     82    U bits() const { return bitwise_cast<U>(m_poisonedBits); }
    8383
    84     bool operator!() const { return !m_scrambledBits; }
    85     explicit operator bool() const { return !!m_scrambledBits; }
     84    bool operator!() const { return !m_poisonedBits; }
     85    explicit operator bool() const { return !!m_poisonedBits; }
    8686
    87     bool operator==(const ScrambledPtr& b) const
     87    bool operator==(const PoisonedImpl& b) const
    8888    {
    89         return m_scrambledBits == b.m_scrambledBits;
     89        return m_poisonedBits == b.m_poisonedBits;
    9090    }
    9191
     
    9393    bool operator==(const PtrType b)
    9494    {
    95         return descrambled<PtrType>() == b;
     95        return unpoisoned<PtrType>() == b;
    9696    }
    9797
    98     ScrambledPtr& operator=(T ptr)
     98    PoisonedImpl& operator=(T ptr)
    9999    {
    100         m_scrambledBits = ptr ? scramble(ptr) : 0;
     100        m_poisonedBits = poison(ptr);
    101101        return *this;
    102102    }
    103     ScrambledPtr& operator=(const ScrambledPtr&) = default;
     103    PoisonedImpl& operator=(const PoisonedImpl&) = default;
    104104
    105105private:
    106106#if USE(JSVALUE64)
    107107    template<typename U>
    108     ALWAYS_INLINE static ScrambledPtrBits scramble(U ptr) { return bitwise_cast<ScrambledPtrBits>(ptr) ^ key; }
     108    ALWAYS_INLINE static PoisonedBits poison(U ptr) { return ptr ? bitwise_cast<PoisonedBits>(ptr) ^ key : 0; }
    109109    template<typename U>
    110     ALWAYS_INLINE static U descramble(ScrambledPtrBits scrambledBits) { return bitwise_cast<U>(scrambledBits ^ key); }
     110    ALWAYS_INLINE static U unpoison(PoisonedBits poisonedBits) { return poisonedBits ? bitwise_cast<U>(poisonedBits ^ key) : bitwise_cast<U>(0ll); }
    111111#else
    112112    template<typename U>
    113     ALWAYS_INLINE static ScrambledPtrBits scramble(U ptr) { return bitwise_cast<ScrambledPtrBits>(ptr); }
     113    ALWAYS_INLINE static PoisonedBits poison(U ptr) { return bitwise_cast<PoisonedBits>(ptr); }
    114114    template<typename U>
    115     ALWAYS_INLINE static U descramble(ScrambledPtrBits scrambledBits) { return bitwise_cast<U>(scrambledBits); }
     115    ALWAYS_INLINE static U unpoison(PoisonedBits poisonedBits) { return bitwise_cast<U>(poisonedBits); }
    116116#endif
    117117
    118     ScrambledPtrBits m_scrambledBits { 0 };
     118    PoisonedBits m_poisonedBits { 0 };
    119119};
    120120
    121 void initializeScrambledPtr();
    122 WTF_EXPORT_PRIVATE uintptr_t makeScrambledPtrKey();
     121template<uintptr_t& key, typename T>
     122using Poisoned = PoisonedImpl<uintptr_t&, key, T>;
     123
     124#if USE(JSVALUE64)
     125template<uint32_t key, typename T>
     126using Int32Poisoned = PoisonedImpl<uintptr_t, static_cast<uintptr_t>(key) << 32, T>;
     127#else
     128template<uint32_t, typename T>
     129using Int32Poisoned = PoisonedImpl<uintptr_t, 0, T>;
     130#endif
     131
     132WTF_EXPORT_PRIVATE uintptr_t makePoison();
    123133
    124134} // namespace WTF
    125135
    126 using WTF::ScrambledPtr;
    127 using WTF::ScrambledPtrBits;
    128 using WTF::makeScrambledPtrKey;
     136using WTF::Int32Poisoned;
     137using WTF::Poisoned;
     138using WTF::PoisonedBits;
     139using WTF::makePoison;
    129140
Note: See TracChangeset for help on using the changeset viewer.