Changeset 225620 in webkit
- Timestamp:
- Dec 6, 2017, 10:10:06 PM (7 years ago)
- Location:
- trunk/Source
- Files:
-
- 23 edited
- 4 moved
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/JavaScriptCore/API/JSCallbackObject.h
r225437 r225620 28 28 #define JSCallbackObject_h 29 29 30 #include "JSC ScrambledPtr.h"30 #include "JSCPoisonedPtr.h" 31 31 #include "JSObjectRef.h" 32 32 #include "JSValueRef.h" … … 235 235 236 236 std::unique_ptr<JSCallbackObjectData> m_callbackObjectData; 237 ClassInfoScrambledPtr m_classInfo;237 PoisonedClassInfoPtr m_classInfo; 238 238 }; 239 239 -
trunk/Source/JavaScriptCore/API/JSObjectRef.cpp
r225437 r225620 432 432 return jsObject->classInfo(vm); 433 433 434 return vm.currentlyDestructingCallbackObjectClassInfo. descrambled();434 return vm.currentlyDestructingCallbackObjectClassInfo.unpoisoned(); 435 435 } 436 436 -
trunk/Source/JavaScriptCore/ChangeLog
r225618 r225620 1 2017-12-06 Mark Lam <[email protected]> 2 3 Refactoring: Rename ScrambledPtr to Poisoned. 4 https://bugs.webkit.org/show_bug.cgi?id=180514 5 6 Reviewed by Saam Barati. 7 8 * API/JSCallbackObject.h: 9 * API/JSObjectRef.cpp: 10 (classInfoPrivate): 11 * JavaScriptCore.xcodeproj/project.pbxproj: 12 * Sources.txt: 13 * assembler/MacroAssemblerCodeRef.h: 14 (JSC::FunctionPtr::FunctionPtr): 15 (JSC::FunctionPtr::value const): 16 (JSC::FunctionPtr::executableAddress const): 17 (JSC::ReturnAddressPtr::ReturnAddressPtr): 18 (JSC::ReturnAddressPtr::value const): 19 (JSC::MacroAssemblerCodePtr::MacroAssemblerCodePtr): 20 (JSC::MacroAssemblerCodePtr::createFromExecutableAddress): 21 (JSC::MacroAssemblerCodePtr::poisonedPtr const): 22 (JSC::MacroAssemblerCodePtr:: const): 23 (JSC::MacroAssemblerCodePtr::operator! const): 24 (JSC::MacroAssemblerCodePtr::operator== const): 25 (JSC::MacroAssemblerCodePtr::emptyValue): 26 (JSC::MacroAssemblerCodePtr::deletedValue): 27 (JSC::MacroAssemblerCodePtr::scrambledPtr const): Deleted. 28 * b3/B3LowerMacros.cpp: 29 * b3/testb3.cpp: 30 (JSC::B3::testInterpreter): 31 * dfg/DFGSpeculativeJIT.cpp: 32 (JSC::DFG::SpeculativeJIT::checkArray): 33 (JSC::DFG::SpeculativeJIT::compileCheckSubClass): 34 (JSC::DFG::SpeculativeJIT::compileNewStringObject): 35 (JSC::DFG::SpeculativeJIT::emitSwitchIntJump): 36 * ftl/FTLLowerDFGToB3.cpp: 37 (JSC::FTL::DFG::LowerDFGToB3::compileNewStringObject): 38 (JSC::FTL::DFG::LowerDFGToB3::compileCheckSubClass): 39 * jit/AssemblyHelpers.h: 40 (JSC::AssemblyHelpers::emitAllocateDestructibleObject): 41 * jit/SpecializedThunkJIT.h: 42 (JSC::SpecializedThunkJIT::loadArgumentWithSpecificClass): 43 * jit/ThunkGenerators.cpp: 44 (JSC::virtualThunkFor): 45 (JSC::boundThisNoArgsFunctionCallGenerator): 46 * llint/LLIntSlowPaths.cpp: 47 (JSC::LLInt::handleHostCall): 48 (JSC::LLInt::setUpCall): 49 * llint/LowLevelInterpreter64.asm: 50 * runtime/InitializeThreading.cpp: 51 (JSC::initializeThreading): 52 * runtime/JSCPoisonedPtr.cpp: Copied from Source/JavaScriptCore/runtime/JSCScrambledPtr.cpp. 53 (JSC::initializePoison): 54 (JSC::initializeScrambledPtrKeys): Deleted. 55 * runtime/JSCPoisonedPtr.h: Copied from Source/JavaScriptCore/runtime/JSCScrambledPtr.h. 56 * runtime/JSCScrambledPtr.cpp: Removed. 57 * runtime/JSCScrambledPtr.h: Removed. 58 * runtime/JSDestructibleObject.h: 59 (JSC::JSDestructibleObject::classInfo const): 60 * runtime/JSSegmentedVariableObject.h: 61 (JSC::JSSegmentedVariableObject::classInfo const): 62 * runtime/Structure.h: 63 * runtime/VM.h: 64 1 65 2017-12-02 Darin Adler <[email protected]> 2 66 -
trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
r225524 r225620 1721 1721 FE20CE9E15F04A9500DF3430 /* LLIntCLoop.h in Headers */ = {isa = PBXBuildFile; fileRef = FE20CE9C15F04A9500DF3430 /* LLIntCLoop.h */; settings = {ATTRIBUTES = (Private, ); }; }; 1722 1722 FE2A87601F02381600EB31B2 /* MinimumReservedZoneSize.h in Headers */ = {isa = PBXBuildFile; fileRef = FE2A875F1F02381600EB31B2 /* MinimumReservedZoneSize.h */; }; 1723 FE2B0B691FD227E00075DA5F /* JSC ScrambledPtr.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, ); }; }; 1724 1724 FE3022D31E3D73A500BAC493 /* SigillCrashAnalyzer.h in Headers */ = {isa = PBXBuildFile; fileRef = FE3022D11E3D739600BAC493 /* SigillCrashAnalyzer.h */; settings = {ATTRIBUTES = (Private, ); }; }; 1725 1725 FE3022D71E42857300BAC493 /* VMInspector.h in Headers */ = {isa = PBXBuildFile; fileRef = FE3022D51E42856700BAC493 /* VMInspector.h */; }; … … 4599 4599 FE20CE9C15F04A9500DF3430 /* LLIntCLoop.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LLIntCLoop.h; path = llint/LLIntCLoop.h; sourceTree = "<group>"; }; 4600 4600 FE2A875F1F02381600EB31B2 /* MinimumReservedZoneSize.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = MinimumReservedZoneSize.h; sourceTree = "<group>"; }; 4601 FE2B0B671FD0D2960075DA5F /* JSC ScrambledPtr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSCScrambledPtr.h; sourceTree = "<group>"; };4602 FE2B0B681FD0D2970075DA5F /* JSC ScrambledPtr.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>"; }; 4603 4603 FE2E6A7A1D6EA5FE0060F896 /* ThrowScope.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ThrowScope.cpp; sourceTree = "<group>"; }; 4604 4604 FE3022D01E3D739600BAC493 /* SigillCrashAnalyzer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SigillCrashAnalyzer.cpp; sourceTree = "<group>"; }; … … 6544 6544 14ABB36E099C076400E2A24F /* JSCJSValue.h */, 6545 6545 865A30F0135007E100CDB49E /* JSCJSValueInlines.h */, 6546 FE2B0B681FD0D2970075DA5F /* JSC ScrambledPtr.cpp */,6547 FE2B0B671FD0D2960075DA5F /* JSC ScrambledPtr.h */,6546 FE2B0B681FD0D2970075DA5F /* JSCPoisonedPtr.cpp */, 6547 FE2B0B671FD0D2960075DA5F /* JSCPoisonedPtr.h */, 6548 6548 72AAF7CB1D0D318B005E60BE /* JSCustomGetterSetterFunction.cpp */, 6549 6549 72AAF7CC1D0D318B005E60BE /* JSCustomGetterSetterFunction.h */, … … 8156 8156 0F37308D1C0BD29100052BFA /* B3PhiChildren.h in Headers */, 8157 8157 0FEC852C1BDACDAC0080FF74 /* B3Procedure.h in Headers */, 8158 FE2B0B691FD227E00075DA5F /* JSC ScrambledPtr.h in Headers */,8158 FE2B0B691FD227E00075DA5F /* JSCPoisonedPtr.h in Headers */, 8159 8159 0FEC852D1BDACDAC0080FF74 /* B3ProcedureInlines.h in Headers */, 8160 8160 0F725CAA1C503DED00AD943A /* B3PureCSE.h in Headers */, -
trunk/Source/JavaScriptCore/Sources.txt
r225524 r225620 773 773 runtime/JSBoundFunction.cpp 774 774 runtime/JSCJSValue.cpp 775 runtime/JSC ScrambledPtr.cpp775 runtime/JSCPoisonedPtr.cpp 776 776 runtime/JSCallee.cpp 777 777 runtime/JSCell.cpp -
trunk/Source/JavaScriptCore/assembler/MacroAssemblerCodeRef.h
r225437 r225620 27 27 28 28 #include "ExecutableAllocator.h" 29 #include "JSC ScrambledPtr.h"29 #include "JSCPoisonedPtr.h" 30 30 #include <wtf/DataLog.h> 31 31 #include <wtf/PrintStream.h> … … 68 68 : m_value((void*)value) 69 69 { 70 MasmScrambledPtr::assertIsNotScrambled(m_value);70 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 71 71 ASSERT_VALID_CODE_POINTER(m_value); 72 72 } … … 76 76 : m_value((void*)value) 77 77 { 78 MasmScrambledPtr::assertIsNotScrambled(m_value);78 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 79 79 ASSERT_VALID_CODE_POINTER(m_value); 80 80 } … … 84 84 : m_value((void*)value) 85 85 { 86 MasmScrambledPtr::assertIsNotScrambled(m_value);86 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 87 87 ASSERT_VALID_CODE_POINTER(m_value); 88 88 } … … 92 92 : m_value((void*)value) 93 93 { 94 MasmScrambledPtr::assertIsNotScrambled(m_value);94 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 95 95 ASSERT_VALID_CODE_POINTER(m_value); 96 96 } … … 100 100 : m_value((void*)value) 101 101 { 102 MasmScrambledPtr::assertIsNotScrambled(m_value);102 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 103 103 ASSERT_VALID_CODE_POINTER(m_value); 104 104 } … … 108 108 : m_value((void*)value) 109 109 { 110 MasmScrambledPtr::assertIsNotScrambled(m_value);110 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 111 111 ASSERT_VALID_CODE_POINTER(m_value); 112 112 } … … 116 116 : m_value((void*)value) 117 117 { 118 MasmScrambledPtr::assertIsNotScrambled(m_value);118 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 119 119 ASSERT_VALID_CODE_POINTER(m_value); 120 120 } … … 127 127 : m_value((void*)value) 128 128 { 129 MasmScrambledPtr::assertIsNotScrambled(m_value);129 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 130 130 ASSERT_VALID_CODE_POINTER(m_value); 131 131 } … … 135 135 : m_value((void*)value) 136 136 { 137 MasmScrambledPtr::assertIsNotScrambled(m_value);137 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 138 138 ASSERT_VALID_CODE_POINTER(m_value); 139 139 } … … 143 143 : m_value((void*)value) 144 144 { 145 MasmScrambledPtr::assertIsNotScrambled(m_value);145 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 146 146 ASSERT_VALID_CODE_POINTER(m_value); 147 147 } … … 151 151 : m_value((void*)value) 152 152 { 153 MasmScrambledPtr::assertIsNotScrambled(m_value);153 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 154 154 ASSERT_VALID_CODE_POINTER(m_value); 155 155 } … … 159 159 : m_value((void*)value) 160 160 { 161 MasmScrambledPtr::assertIsNotScrambled(m_value);161 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 162 162 ASSERT_VALID_CODE_POINTER(m_value); 163 163 } … … 170 170 : m_value((void*)value) 171 171 { 172 MasmScrambledPtr::assertIsNotScrambled(m_value);172 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 173 173 ASSERT_VALID_CODE_POINTER(m_value); 174 174 } … … 178 178 : m_value((void*)value) 179 179 { 180 MasmScrambledPtr::assertIsNotScrambled(m_value);180 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 181 181 ASSERT_VALID_CODE_POINTER(m_value); 182 182 } … … 186 186 : m_value((void*)value) 187 187 { 188 MasmScrambledPtr::assertIsNotScrambled(m_value);188 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 189 189 ASSERT_VALID_CODE_POINTER(m_value); 190 190 } … … 194 194 : m_value((void*)value) 195 195 { 196 MasmScrambledPtr::assertIsNotScrambled(m_value);196 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 197 197 ASSERT_VALID_CODE_POINTER(m_value); 198 198 } … … 202 202 : m_value((void*)value) 203 203 { 204 MasmScrambledPtr::assertIsNotScrambled(m_value);204 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 205 205 ASSERT_VALID_CODE_POINTER(m_value); 206 206 } … … 214 214 : m_value((void*)value) 215 215 { 216 MasmScrambledPtr::assertIsNotScrambled(m_value);216 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 217 217 ASSERT_VALID_CODE_POINTER(m_value); 218 218 } … … 222 222 void* value() const 223 223 { 224 MasmScrambledPtr::assertIsNotScrambled(m_value);224 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 225 225 return m_value; 226 226 } 227 227 void* executableAddress() const 228 228 { 229 MasmScrambledPtr::assertIsNotScrambled(m_value);229 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 230 230 return m_value; 231 231 } … … 248 248 : m_value(value) 249 249 { 250 MasmScrambledPtr::assertIsNotScrambled(m_value);250 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 251 251 ASSERT_VALID_CODE_POINTER(m_value); 252 252 } … … 255 255 : m_value(function.value()) 256 256 { 257 MasmScrambledPtr::assertIsNotScrambled(m_value);257 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 258 258 ASSERT_VALID_CODE_POINTER(m_value); 259 259 } … … 261 261 void* value() const 262 262 { 263 MasmScrambledPtr::assertIsNotScrambled(m_value);263 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 264 264 return m_value; 265 265 } … … 289 289 #endif 290 290 { 291 m_value.assertIs Scrambled();291 m_value.assertIsPoisoned(); 292 292 ASSERT(value); 293 293 ASSERT_VALID_CODE_POINTER(m_value); … … 299 299 ASSERT_VALID_CODE_POINTER(value); 300 300 MacroAssemblerCodePtr result; 301 result.m_value = MasmScrambledPtr(value);302 result.m_value.assertIs Scrambled();301 result.m_value = PoisonedMasmPtr(value); 302 result.m_value.assertIsPoisoned(); 303 303 return result; 304 304 } … … 310 310 { 311 311 ASSERT(ra.value()); 312 m_value.assertIs Scrambled();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; } 317 317 318 318 template<typename T = void*> 319 319 T executableAddress() const 320 320 { 321 m_value.assertIs Scrambled();322 return m_value ? m_value.descrambled<T>() : static_cast<T>(0);321 m_value.assertIsPoisoned(); 322 return m_value.unpoisoned<T>(); 323 323 } 324 324 #if CPU(ARM_THUMB2) … … 327 327 T dataLocation() const 328 328 { 329 m_value.assertIs Scrambled();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); 332 332 } 333 333 #else … … 335 335 T dataLocation() const 336 336 { 337 m_value.assertIs Scrambled();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>(); 340 340 } 341 341 #endif … … 343 343 bool operator!() const 344 344 { 345 #if ENABLE( SCRAMBLED_PTR_ASSERTS)345 #if ENABLE(POISON_ASSERTS) 346 346 if (!isEmptyValue() && !isDeletedValue()) 347 m_value.assertIs Scrambled();347 m_value.assertIsPoisoned(); 348 348 #endif 349 349 return !m_value; … … 353 353 bool operator==(const MacroAssemblerCodePtr& other) const 354 354 { 355 #if ENABLE( SCRAMBLED_PTR_ASSERTS)355 #if ENABLE(POISON_ASSERTS) 356 356 if (!isEmptyValue() && !isDeletedValue()) 357 m_value.assertIs Scrambled();357 m_value.assertIsPoisoned(); 358 358 if (!other.isEmptyValue() && !other.isDeletedValue()) 359 other.m_value.assertIs Scrambled();359 other.m_value.assertIsPoisoned(); 360 360 #endif 361 361 return m_value == other.m_value; … … 363 363 364 364 // 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. 366 366 template<typename T, typename = std::enable_if_t<!std::is_same<T, bool>::value>> 367 367 operator T() = delete; … … 390 390 391 391 private: 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; 396 396 }; 397 397 … … 480 480 : m_value(ptr.executableAddress()) 481 481 { 482 MasmScrambledPtr::assertIsNotScrambled(m_value);482 PoisonedMasmPtr::assertIsNotPoisoned(m_value); 483 483 ASSERT_VALID_CODE_POINTER(m_value); 484 484 } -
trunk/Source/JavaScriptCore/b3/B3LowerMacros.cpp
r225363 r225620 506 506 GPRReg index = params[0].gpr(); 507 507 GPRReg scratch = params.gpScratch(0); 508 GPRReg descramblerKey= params.gpScratch(1);509 510 jit.move(CCallHelpers::TrustedImm64(g_masm ScrambledPtrKey), descramblerKey);508 GPRReg poisonScratch = params.gpScratch(1); 509 510 jit.move(CCallHelpers::TrustedImm64(g_masmPoison), poisonScratch); 511 511 jit.move(CCallHelpers::TrustedImmPtr(jumpTable), scratch); 512 512 jit.load64(CCallHelpers::BaseIndex(scratch, index, CCallHelpers::timesPtr()), scratch); 513 jit.xor64( descramblerKey, scratch);513 jit.xor64(poisonScratch, scratch); 514 514 jit.jump(scratch); 515 515 -
trunk/Source/JavaScriptCore/b3/testb3.cpp
r225363 r225620 13031 13031 13032 13032 GPRReg scratch = params.gpScratch(0); 13033 GPRReg descramblerKey= params.gpScratch(1);13033 GPRReg poisonScratch = params.gpScratch(1); 13034 13034 13035 13035 jit.move(CCallHelpers::TrustedImmPtr(jumpTable), scratch); 13036 jit.move(CCallHelpers::TrustedImm64(g_masm ScrambledPtrKey), descramblerKey);13036 jit.move(CCallHelpers::TrustedImm64(g_masmPoison), poisonScratch); 13037 13037 jit.load64(CCallHelpers::BaseIndex(scratch, params[0].gpr(), CCallHelpers::timesPtr()), scratch); 13038 jit.xor64( descramblerKey, scratch);13038 jit.xor64(poisonScratch, scratch); 13039 13039 jit.jump(scratch); 13040 13040 -
trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
r225437 r225620 869 869 MacroAssembler::NotEqual, 870 870 MacroAssembler::Address(temp.gpr(), Structure::classInfoOffset()), 871 TrustedImmPtr( ClassInfoScrambledPtr(expectedClassInfo).bits())));871 TrustedImmPtr(PoisonedClassInfoPtr(expectedClassInfo).bits()))); 872 872 873 873 noResult(m_currentNode); … … 8707 8707 m_jit.loadPtr(CCallHelpers::Address(otherGPR, Structure::classInfoOffset()), otherGPR); 8708 8708 #if USE(JSVALUE64) 8709 m_jit.move(CCallHelpers::TrustedImm64(g_classInfo ScrambledPtrKey), specifiedGPR);8709 m_jit.move(CCallHelpers::TrustedImm64(g_classInfoPoison), specifiedGPR); 8710 8710 m_jit.xor64(specifiedGPR, otherGPR); 8711 8711 #endif … … 9004 9004 9005 9005 m_jit.storePtr( 9006 TrustedImmPtr( ClassInfoScrambledPtr(StringObject::info()).bits()),9006 TrustedImmPtr(PoisonedClassInfoPtr(StringObject::info()).bits()), 9007 9007 JITCompiler::Address(resultGPR, JSDestructibleObject::classInfoOffset())); 9008 9008 #if USE(JSVALUE64) … … 9775 9775 9776 9776 void SpeculativeJIT::emitSwitchIntJump( 9777 SwitchData* data, GPRReg value, GPRReg scratch, GPRReg descramblerKeyScratch)9777 SwitchData* data, GPRReg value, GPRReg scratch, GPRReg poisonScratch) 9778 9778 { 9779 9779 SimpleJumpTable& table = m_jit.codeBlock()->switchJumpTable(data->switchTableIndex); … … 9783 9783 m_jit.branch32(JITCompiler::AboveOrEqual, value, Imm32(table.ctiOffsets.size())), 9784 9784 data->fallThrough.block); 9785 UNUSED_PARAM( descramblerKeyScratch); // Placate the 32-bit build.9785 UNUSED_PARAM(poisonScratch); // Placate the 32-bit build. 9786 9786 #if USE(JSVALUE64) 9787 m_jit.move(TrustedImm64(g_masm ScrambledPtrKey), descramblerKeyScratch);9787 m_jit.move(TrustedImm64(g_masmPoison), poisonScratch); 9788 9788 #endif 9789 9789 m_jit.move(TrustedImmPtr(table.ctiOffsets.begin()), scratch); … … 9791 9791 9792 9792 #if USE(JSVALUE64) 9793 m_jit.xor64( descramblerKeyScratch, scratch);9793 m_jit.xor64(poisonScratch, scratch); 9794 9794 #endif 9795 9795 m_jit.jump(scratch); -
trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
r225492 r225620 5011 5011 5012 5012 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); 5014 5014 m_out.store64(string, fastResultValue, m_heaps.JSWrapperObject_internalValue); 5015 5015 mutatorFence(); … … 11171 11171 11172 11172 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)); 11175 11175 ValueFromBlock otherAtStart = m_out.anchor(classInfo); 11176 11176 m_out.jump(loop); -
trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h
r225437 r225620 1626 1626 { 1627 1627 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())); 1629 1629 } 1630 1630 -
trunk/Source/JavaScriptCore/jit/SpecializedThunkJIT.h
r225437 r225620 78 78 loadCellArgument(argument, dst); 79 79 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()))); 81 81 // We have to reload the argument since emitLoadStructure clobbered it. 82 82 loadCellArgument(argument, dst); -
trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp
r225363 r225620 215 215 // call. 216 216 #if USE(JSVALUE64) 217 jit.move(CCallHelpers::TrustedImm64(g_masm ScrambledPtrKey), GPRInfo::regT1);217 jit.move(CCallHelpers::TrustedImm64(g_masmPoison), GPRInfo::regT1); 218 218 jit.xor64(GPRInfo::regT1, GPRInfo::regT4); 219 219 #endif … … 1164 1164 1165 1165 #if USE(JSVALUE64) 1166 jit.move(CCallHelpers::TrustedImm64(g_masm ScrambledPtrKey), GPRInfo::regT1);1166 jit.move(CCallHelpers::TrustedImm64(g_masmPoison), GPRInfo::regT1); 1167 1167 jit.xor64(GPRInfo::regT1, GPRInfo::regT0); 1168 1168 #endif -
trunk/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
r225470 r225620 1304 1304 vm.hostCallReturnValue = JSValue::decode(callData.native.function(execCallee)); 1305 1305 1306 MasmScrambledPtr::assertIsNotScrambled(LLInt::getCodePtr(getHostCallReturnValue));1306 PoisonedMasmPtr::assertIsNotPoisoned(LLInt::getCodePtr(getHostCallReturnValue)); 1307 1307 LLINT_CALL_RETURN(execCallee, execCallee, LLInt::getCodePtr(getHostCallReturnValue)); 1308 1308 } … … 1328 1328 vm.hostCallReturnValue = JSValue::decode(constructData.native.function(execCallee)); 1329 1329 1330 MasmScrambledPtr::assertIsNotScrambled(LLInt::getCodePtr(getHostCallReturnValue));1330 PoisonedMasmPtr::assertIsNotPoisoned(LLInt::getCodePtr(getHostCallReturnValue)); 1331 1331 LLINT_CALL_RETURN(execCallee, execCallee, LLInt::getCodePtr(getHostCallReturnValue)); 1332 1332 } … … 1369 1369 } 1370 1370 1371 MasmScrambledPtr::assertIsNotScrambled(codePtr.executableAddress());1371 PoisonedMasmPtr::assertIsNotPoisoned(codePtr.executableAddress()); 1372 1372 LLINT_CALL_RETURN(exec, execCallee, codePtr.executableAddress()); 1373 1373 } … … 1420 1420 } 1421 1421 1422 MasmScrambledPtr::assertIsNotScrambled(codePtr.executableAddress());1422 PoisonedMasmPtr::assertIsNotPoisoned(codePtr.executableAddress()); 1423 1423 LLINT_CALL_RETURN(exec, execCallee, codePtr.executableAddress()); 1424 1424 } -
trunk/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm
r225363 r225620 1951 1951 callTargetFunction(LLIntCallLinkInfo::machineCodeTarget[t1]) 1952 1952 else 1953 loadp _g_masm ScrambledPtrKey, t21953 loadp _g_masmPoison, t2 1954 1954 xorp LLIntCallLinkInfo::machineCodeTarget[t1], t2 1955 1955 prepareCall(t2, t1, t3, t4) -
trunk/Source/JavaScriptCore/runtime/InitializeThreading.cpp
r225437 r225620 60 60 std::call_once(initializeThreadingOnceFlag, []{ 61 61 WTF::initializeThreading(); 62 initialize ScrambledPtrKeys();62 initializePoison(); 63 63 Options::initialize(); 64 64 #if ENABLE(WRITE_BARRIER_PROFILING) -
trunk/Source/JavaScriptCore/runtime/JSCPoisonedPtr.cpp
r225619 r225620 25 25 26 26 #include "config.h" 27 #include "JSC ScrambledPtr.h"27 #include "JSCPoisonedPtr.h" 28 28 29 29 namespace JSC { 30 30 31 uintptr_t g_classInfo ScrambledPtrKey;32 uintptr_t g_masm ScrambledPtrKey;31 uintptr_t g_classInfoPoison; 32 uintptr_t g_masmPoison; 33 33 34 void initialize ScrambledPtrKeys()34 void initializePoison() 35 35 { 36 36 static std::once_flag initializeOnceFlag; 37 37 std::call_once(initializeOnceFlag, [] { 38 g_classInfo ScrambledPtrKey = makeScrambledPtrKey();39 g_masm ScrambledPtrKey = makeScrambledPtrKey();38 g_classInfoPoison = makePoison(); 39 g_masmPoison = makePoison(); 40 40 }); 41 41 } -
trunk/Source/JavaScriptCore/runtime/JSCPoisonedPtr.h
r225619 r225620 26 26 #pragma once 27 27 28 #include <wtf/ ScrambledPtr.h>28 #include <wtf/Poisoned.h> 29 29 30 30 namespace JSC { 31 31 32 extern "C" JS_EXPORTDATA uintptr_t g_classInfo ScrambledPtrKey;33 extern "C" JS_EXPORTDATA uintptr_t g_masm ScrambledPtrKey;32 extern "C" JS_EXPORTDATA uintptr_t g_classInfoPoison; 33 extern "C" JS_EXPORTDATA uintptr_t g_masmPoison; 34 34 35 35 struct ClassInfo; 36 36 37 using ClassInfoScrambledPtr = ScrambledPtr<const ClassInfo*, g_classInfoScrambledPtrKey>;38 using MasmScrambledPtr = ScrambledPtr<void*, g_masmScrambledPtrKey>;37 using PoisonedClassInfoPtr = Poisoned<g_classInfoPoison, const ClassInfo*>; 38 using PoisonedMasmPtr = Poisoned<g_masmPoison, void*>; 39 39 40 void initialize ScrambledPtrKeys();40 void initializePoison(); 41 41 42 42 } // namespace JSC -
trunk/Source/JavaScriptCore/runtime/JSDestructibleObject.h
r225437 r225620 44 44 } 45 45 46 const ClassInfo* classInfo() const { return m_classInfo. descrambled(); }46 const ClassInfo* classInfo() const { return m_classInfo.unpoisoned(); } 47 47 48 48 static ptrdiff_t classInfoOffset() { return OBJECT_OFFSETOF(JSDestructibleObject, m_classInfo); } … … 57 57 58 58 private: 59 ClassInfoScrambledPtr m_classInfo;59 PoisonedClassInfoPtr m_classInfo; 60 60 }; 61 61 -
trunk/Source/JavaScriptCore/runtime/JSSegmentedVariableObject.h
r225437 r225620 95 95 } 96 96 97 const ClassInfo* classInfo() const { return m_classInfo. descrambled(); }97 const ClassInfo* classInfo() const { return m_classInfo.unpoisoned(); } 98 98 99 99 protected: … … 108 108 ConcurrentJSLock m_lock; 109 109 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; 111 111 }; 112 112 -
trunk/Source/JavaScriptCore/runtime/Structure.h
r225437 r225620 469 469 void setObjectToStringValue(ExecState*, VM&, JSString* value, PropertySlot toStringTagSymbolSlot); 470 470 471 const ClassInfo* classInfo() const { return m_classInfo. descrambled(); }471 const ClassInfo* classInfo() const { return m_classInfo.unpoisoned(); } 472 472 473 473 static ptrdiff_t structureIDOffset() … … 799 799 RefPtr<UniquedStringImpl> m_nameInPrevious; 800 800 801 ClassInfoScrambledPtr m_classInfo;801 PoisonedClassInfoPtr m_classInfo; 802 802 803 803 StructureTransitionTable m_transitionTable; -
trunk/Source/JavaScriptCore/runtime/VM.h
r225470 r225620 415 415 416 416 JSCell* currentlyDestructingCallbackObject; 417 ClassInfoScrambledPtr currentlyDestructingCallbackObjectClassInfo;417 PoisonedClassInfoPtr currentlyDestructingCallbackObjectClassInfo; 418 418 419 419 AtomicStringTable* m_atomicStringTable; -
trunk/Source/WTF/ChangeLog
r225618 r225620 1 2017-12-06 Mark Lam <[email protected]> 2 3 Refactoring: Rename ScrambledPtr to Poisoned. 4 https://bugs.webkit.org/show_bug.cgi?id=180514 5 6 Reviewed by Saam Barati. 7 8 We're switching our nomenclature to "poisoning" instead of "scrambling" pointers. 9 This allows us to use shorter names. 10 11 This patch is almost purely refactoring, except for one change: the PoisonedImpl 12 template class (previously ScrambledPtr) has been modified to allow usage of 13 a constexpr uint32_t poison value (see Int32Poisoned) in addition to a runtime 14 determined uintptr_t poison value (see Poisoned). 15 16 * WTF.xcodeproj/project.pbxproj: 17 * wtf/CMakeLists.txt: 18 * wtf/Poisoned.cpp: Copied from Source/WTF/wtf/ScrambledPtr.cpp. 19 (WTF::makePoison): 20 (WTF::makeScrambledPtrKey): Deleted. 21 * wtf/Poisoned.h: Copied from Source/WTF/wtf/ScrambledPtr.h. 22 (WTF::PoisonedImpl::PoisonedImpl): 23 (WTF::PoisonedImpl::assertIsPoisoned const): 24 (WTF::PoisonedImpl::assertIsNotPoisoned const): 25 (WTF::PoisonedImpl::unpoisoned const): 26 (WTF::PoisonedImpl::operator-> const): 27 (WTF::PoisonedImpl::bits const): 28 (WTF::PoisonedImpl::operator! const): 29 (WTF::PoisonedImpl::operator bool const): 30 (WTF::PoisonedImpl::operator== const): 31 (WTF::PoisonedImpl::operator==): 32 (WTF::PoisonedImpl::operator=): 33 (WTF::PoisonedImpl::poison): 34 (WTF::PoisonedImpl::unpoison): 35 (WTF::ScrambledPtr::ScrambledPtr): Deleted. 36 (WTF::ScrambledPtr::assertIsScrambled const): Deleted. 37 (WTF::ScrambledPtr::assertIsNotScrambled const): Deleted. 38 (WTF::ScrambledPtr::descrambled const): Deleted. 39 (WTF::ScrambledPtr::operator-> const): Deleted. 40 (WTF::ScrambledPtr::bits const): Deleted. 41 (WTF::ScrambledPtr::operator! const): Deleted. 42 (WTF::ScrambledPtr::operator bool const): Deleted. 43 (WTF::ScrambledPtr::operator== const): Deleted. 44 (WTF::ScrambledPtr::operator==): Deleted. 45 (WTF::ScrambledPtr::operator=): Deleted. 46 (WTF::ScrambledPtr::scramble): Deleted. 47 (WTF::ScrambledPtr::descramble): Deleted. 48 * wtf/ScrambledPtr.cpp: Removed. 49 * wtf/ScrambledPtr.h: Removed. 50 1 51 2017-12-02 Darin Adler <[email protected]> 2 52 -
trunk/Source/WTF/WTF.xcodeproj/project.pbxproj
r225555 r225620 150 150 E4A0AD391A96245500536DF6 /* WorkQueue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4A0AD371A96245500536DF6 /* WorkQueue.cpp */; }; 151 151 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 */; }; 153 153 FEDACD3D1630F83F00C69634 /* StackStats.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FEDACD3B1630F83F00C69634 /* StackStats.cpp */; }; 154 154 /* End PBXBuildFile section */ … … 611 611 F72BBDB107FA424886178B9E /* SymbolImpl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SymbolImpl.cpp; sourceTree = "<group>"; }; 612 612 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>"; }; 615 615 FE86A8741E59440200111BBF /* ForbidHeapAllocation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ForbidHeapAllocation.h; sourceTree = "<group>"; }; 616 616 FE8925AF1D00DAEC0046907E /* Indenter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Indenter.h; sourceTree = "<group>"; }; … … 966 966 E3200AB41E9A536D003B59D2 /* PlatformRegisters.h */, 967 967 0FF860941BCCBD740045127F /* PointerComparison.h */, 968 FE85416C1FBE285B008DA5DA /* Poisoned.cpp */, 969 FE85416D1FBE285C008DA5DA /* Poisoned.h */, 968 970 0F9D335D165DBA73005AD387 /* PrintStream.cpp */, 969 971 0F9D335E165DBA73005AD387 /* PrintStream.h */, … … 1002 1004 1A3524AA1D63A2FF0031729B /* Scope.h */, 1003 1005 0FEC84B01BDACD390080FF74 /* ScopedLambda.h */, 1004 FE85416C1FBE285B008DA5DA /* ScrambledPtr.cpp */,1005 FE85416D1FBE285C008DA5DA /* ScrambledPtr.h */,1006 1006 0F66B2841DC97BAB004A1D3F /* Seconds.cpp */, 1007 1007 0F66B2851DC97BAB004A1D3F /* Seconds.h */, … … 1463 1463 1469419916EAB0410024E146 /* SchedulePairCF.cpp in Sources */, 1464 1464 1469419716EAAFF80024E146 /* SchedulePairMac.mm in Sources */, 1465 FE85416E1FBE285D008DA5DA /* ScrambledPtr.cpp in Sources */,1465 FE85416E1FBE285D008DA5DA /* Poisoned.cpp in Sources */, 1466 1466 0F66B28E1DC97BAB004A1D3F /* Seconds.cpp in Sources */, 1467 1467 A8A47421151A825B004123FF /* SHA1.cpp in Sources */, -
trunk/Source/WTF/wtf/CMakeLists.txt
r225555 r225620 108 108 Platform.h 109 109 PlatformRegisters.h 110 Poisoned.h 110 111 PrintStream.h 111 112 ProcessID.h … … 131 132 SaturatedArithmetic.h 132 133 ScopedLambda.h 133 ScrambledPtr.h134 134 Seconds.h 135 135 SegmentedVector.h … … 259 259 ParallelJobsGeneric.cpp 260 260 ParkingLot.cpp 261 Poisoned.cpp 261 262 PrintStream.cpp 262 263 RAMSize.cpp … … 267 268 RunLoop.cpp 268 269 SHA1.cpp 269 ScrambledPtr.cpp270 270 Seconds.cpp 271 271 SixCharacterHash.cpp -
trunk/Source/WTF/wtf/Poisoned.cpp
r225619 r225620 25 25 26 26 #include "config.h" 27 #include " ScrambledPtr.h"27 #include "Poisoned.h" 28 28 29 29 #include <wtf/CryptographicallyRandomNumber.h> … … 31 31 namespace WTF { 32 32 33 uintptr_t make ScrambledPtrKey()33 uintptr_t makePoison() 34 34 { 35 35 uintptr_t key = cryptographicallyRandomNumber(); 36 36 #if USE(JSVALUE64) && !OS(WINDOWS) 37 37 key = (key << 32) ^ (static_cast<uintptr_t>(cryptographicallyRandomNumber()) << 3); 38 // Ensure that the scrambled bits (pointer ^ key) do not make a valid pointer and39 // cannot be 0. We ensure that it is zero so that the scrambled bits can also be40 // used for a notmal zero check without needing to de scramblefirst.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. 41 41 key |= (static_cast<uintptr_t>(0x1) << 63); 42 42 #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. 44 44 #endif 45 45 return key; -
trunk/Source/WTF/wtf/Poisoned.h
r225619 r225620 28 28 #include <wtf/Assertions.h> 29 29 30 #define ENABLE_ SCRAMBLED_PTR_ASSERTS 030 #define ENABLE_POISON_ASSERTS 0 31 31 32 32 // Not currently supported for 32-bit or OS(WINDOWS) builds (because of missing llint support). 33 33 // Make sure it's disabled. 34 34 #if USE(JSVALUE32_64) || OS(WINDOWS) 35 #undef ENABLE_ SCRAMBLED_PTR_ASSERTS36 #define ENABLE_ SCRAMBLED_PTR_ASSERTS 035 #undef ENABLE_POISON_ASSERTS 36 #define ENABLE_POISON_ASSERTS 0 37 37 #endif 38 38 39 39 namespace WTF { 40 40 41 using ScrambledPtrBits = uintptr_t;41 using PoisonedBits = uintptr_t; 42 42 43 template<typename T, uintptr_t& key, typename = std::enable_if_t<std::is_pointer<T>::value>>44 class ScrambledPtr{43 template<typename KeyType, KeyType key, typename T, typename = std::enable_if_t<std::is_pointer<T>::value>> 44 class PoisonedImpl { 45 45 public: 46 ScrambledPtr() { }46 PoisonedImpl() { } 47 47 48 explicit ScrambledPtr(T ptr)49 : m_ scrambledBits(scramble(ptr))48 explicit PoisonedImpl(T ptr) 49 : m_poisonedBits(poison(ptr)) 50 50 { 51 ASSERT(ptr && m_ scrambledBits);51 ASSERT(ptr && m_poisonedBits); 52 52 } 53 53 54 ScrambledPtr(const ScrambledPtr&) = default;54 PoisonedImpl(const PoisonedImpl&) = default; 55 55 56 explicit ScrambledPtr(ScrambledPtrBits scrambledBits)57 : m_ scrambledBits(scrambledBits)56 explicit PoisonedImpl(PoisonedBits poisonedBits) 57 : m_poisonedBits(poisonedBits) 58 58 { 59 ASSERT(m_ scrambledBits);59 ASSERT(m_poisonedBits); 60 60 } 61 61 62 #if ENABLE( SCRAMBLED_PTR_ASSERTS)62 #if ENABLE(POISON_ASSERTS) 63 63 template<typename U = void*> 64 static bool is Scrambled(U value) { return !value || (reinterpret_cast<uintptr_t>(value) & 0xffff000000000000); }64 static bool isPoisoned(U value) { return !value || (reinterpret_cast<uintptr_t>(value) & 0xffff000000000000); } 65 65 template<typename U = void*> 66 static void assertIs Scrambled(U value) { RELEASE_ASSERT(isScrambled(value)); }66 static void assertIsPoisoned(U value) { RELEASE_ASSERT(isPoisoned(value)); } 67 67 template<typename U = void*> 68 static void assertIsNot Scrambled(U value) { RELEASE_ASSERT(!isScrambled(value)); }68 static void assertIsNotPoisoned(U value) { RELEASE_ASSERT(!isPoisoned(value)); } 69 69 #else 70 template<typename U = void*> static void assertIs Scrambled(U) { }71 template<typename U = void*> static void assertIsNot Scrambled(U) { }70 template<typename U = void*> static void assertIsPoisoned(U) { } 71 template<typename U = void*> static void assertIsNotPoisoned(U) { } 72 72 #endif 73 void assertIs Scrambled() const { assertIsScrambled(m_scrambledBits); }74 void assertIsNot Scrambled() const { assertIsNotScrambled(m_scrambledBits); }73 void assertIsPoisoned() const { assertIsPoisoned(m_poisonedBits); } 74 void assertIsNotPoisoned() const { assertIsNotPoisoned(m_poisonedBits); } 75 75 76 76 template<typename U = T> 77 U descrambled() const { return descramble<U>(m_scrambledBits); }77 U unpoisoned() const { return unpoison<U>(m_poisonedBits); } 78 78 79 ALWAYS_INLINE T operator->() const { return descramble<T>(m_scrambledBits); }79 ALWAYS_INLINE T operator->() const { return unpoison<T>(m_poisonedBits); } 80 80 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); } 83 83 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; } 86 86 87 bool operator==(const ScrambledPtr& b) const87 bool operator==(const PoisonedImpl& b) const 88 88 { 89 return m_ scrambledBits == b.m_scrambledBits;89 return m_poisonedBits == b.m_poisonedBits; 90 90 } 91 91 … … 93 93 bool operator==(const PtrType b) 94 94 { 95 return descrambled<PtrType>() == b;95 return unpoisoned<PtrType>() == b; 96 96 } 97 97 98 ScrambledPtr& operator=(T ptr)98 PoisonedImpl& operator=(T ptr) 99 99 { 100 m_ scrambledBits = ptr ? scramble(ptr) : 0;100 m_poisonedBits = poison(ptr); 101 101 return *this; 102 102 } 103 ScrambledPtr& operator=(const ScrambledPtr&) = default;103 PoisonedImpl& operator=(const PoisonedImpl&) = default; 104 104 105 105 private: 106 106 #if USE(JSVALUE64) 107 107 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; } 109 109 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); } 111 111 #else 112 112 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); } 114 114 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); } 116 116 #endif 117 117 118 ScrambledPtrBits m_scrambledBits { 0 };118 PoisonedBits m_poisonedBits { 0 }; 119 119 }; 120 120 121 void initializeScrambledPtr(); 122 WTF_EXPORT_PRIVATE uintptr_t makeScrambledPtrKey(); 121 template<uintptr_t& key, typename T> 122 using Poisoned = PoisonedImpl<const uintptr_t&, key, T>; 123 124 #if USE(JSVALUE64) 125 template<uint32_t key, typename T> 126 using Int32Poisoned = PoisonedImpl<uintptr_t, static_cast<uintptr_t>(key) << 32, T>; 127 #else 128 template<uint32_t, typename T> 129 using Int32Poisoned = PoisonedImpl<uintptr_t, 0, T>; 130 #endif 131 132 WTF_EXPORT_PRIVATE uintptr_t makePoison(); 123 133 124 134 } // namespace WTF 125 135 126 using WTF::ScrambledPtr; 127 using WTF::ScrambledPtrBits; 128 using WTF::makeScrambledPtrKey; 136 using WTF::Int32Poisoned; 137 using WTF::Poisoned; 138 using WTF::PoisonedBits; 139 using WTF::makePoison; 129 140
Note:
See TracChangeset
for help on using the changeset viewer.