Attachment 241156 Details for Bug 138489 – Patch

[patch] Patch

bug-138489-20141107121512.patch (text/plain), 22.65 KB, created by Gyuyoung Kim on 2014-11-06 19:15:03 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Gyuyoung Kim

Created: 2014-11-06 19:15:03 PST

Size: 22.65 KB

patch

obsolete

>Subversion Revision: 175731
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index acb78f5d1a274007dac264d94edbd978b5ba7ab3..0e030e6e4cdcaca58975866d90dd190d1a6fdfc6 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,35 @@
>+2014-11-06  Gyuyoung Kim  <gyuyoung.kim@samsung.com>
>+
>+        Apply std::unique_ptr to slowPathCall()
>+        https://bugs.webkit.org/show_bug.cgi?id=138489
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        As a step to use std::unique_ptr<>, this patch makes slowPathCall() use std::unique_ptr<>,
>+        std::make_unique<>, and WTF::move(). 
>+
>+        * dfg/DFGSlowPathGenerator.h:
>+        (JSC::DFG::slowPathCall):
>+        (JSC::DFG::slowPathMove):
>+        * dfg/DFGSpeculativeJIT.cpp:
>+        (JSC::DFG::SpeculativeJIT::emitAllocateJSArray):
>+        (JSC::DFG::SpeculativeJIT::addSlowPathGenerator):
>+        (JSC::DFG::SpeculativeJIT::arrayify):
>+        (JSC::DFG::SpeculativeJIT::compileIn):
>+        (JSC::DFG::SpeculativeJIT::compileGetByValOnString):
>+        * dfg/DFGSpeculativeJIT.h:
>+        * dfg/DFGSpeculativeJIT32_64.cpp:
>+        (JSC::DFG::SpeculativeJIT::cachedGetById):
>+        (JSC::DFG::SpeculativeJIT::cachedPutById):
>+        (JSC::DFG::SpeculativeJIT::nonSpeculativeNonPeepholeCompare):
>+        (JSC::DFG::SpeculativeJIT::compile):
>+        * dfg/DFGSpeculativeJIT64.cpp:
>+        (JSC::DFG::SpeculativeJIT::cachedGetById):
>+        (JSC::DFG::SpeculativeJIT::cachedPutById):
>+        (JSC::DFG::SpeculativeJIT::nonSpeculativeNonPeepholeCompare):
>+        (JSC::DFG::SpeculativeJIT::nonSpeculativeNonPeepholeStrictEq):
>+        (JSC::DFG::SpeculativeJIT::compile):
>+
> 2014-11-06  Mark Lam  <mark.lam@apple.com>
> 
>         slow_path_get_direct_pname() needs to be hardened against a constant baseValue.
>diff --git a/Source/JavaScriptCore/dfg/DFGSlowPathGenerator.h b/Source/JavaScriptCore/dfg/DFGSlowPathGenerator.h
>index 4e87d4fd5118a7bfadd52bbf4bfa36be99d6eb35..90e3cd971243f47fce19eb946e52f312a53f66b1 100644
>--- a/Source/JavaScriptCore/dfg/DFGSlowPathGenerator.h
>+++ b/Source/JavaScriptCore/dfg/DFGSlowPathGenerator.h
>@@ -329,94 +329,77 @@ protected:
> };
> 
> template<typename JumpType, typename FunctionType, typename ResultType>
>-inline PassOwnPtr<SlowPathGenerator> slowPathCall(
>+inline std::unique_ptr<SlowPathGenerator> slowPathCall(
>     JumpType from, SpeculativeJIT* jit, FunctionType function,
>     ResultType result, SpillRegistersMode spillMode = NeedToSpill)
> {
>-    return adoptPtr(
>-        new CallResultAndNoArgumentsSlowPathGenerator<
>-            JumpType, FunctionType, ResultType>(
>-                from, jit, function, spillMode, result));
>+    return std::make_unique<CallResultAndNoArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType>>(
>+        from, jit, function, spillMode, result);
> }
> 
> template<
>     typename JumpType, typename FunctionType, typename ResultType,
>     typename ArgumentType1>
>-inline PassOwnPtr<SlowPathGenerator> slowPathCall(
>+inline std::unique_ptr<SlowPathGenerator> slowPathCall(
>     JumpType from, SpeculativeJIT* jit, FunctionType function,
>     ResultType result, ArgumentType1 argument1,
>     SpillRegistersMode spillMode = NeedToSpill)
> {
>-    return adoptPtr(
>-        new CallResultAndOneArgumentSlowPathGenerator<
>-            JumpType, FunctionType, ResultType, ArgumentType1>(
>-                from, jit, function, spillMode, result, argument1));
>+    return std::make_unique<CallResultAndOneArgumentSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1>>(
>+        from, jit, function, spillMode, result, argument1);
> }
> 
> template<
>     typename JumpType, typename FunctionType, typename ResultType,
>     typename ArgumentType1, typename ArgumentType2>
>-inline PassOwnPtr<SlowPathGenerator> slowPathCall(
>+inline std::unique_ptr<SlowPathGenerator> slowPathCall(
>     JumpType from, SpeculativeJIT* jit, FunctionType function,
>     ResultType result, ArgumentType1 argument1, ArgumentType2 argument2,
>     SpillRegistersMode spillMode = NeedToSpill)
> {
>-    return adoptPtr(
>-        new CallResultAndTwoArgumentsSlowPathGenerator<
>-            JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2>(
>-                from, jit, function, spillMode, result, argument1, argument2));
>+    return std::make_unique<CallResultAndTwoArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2>>(
>+        from, jit, function, spillMode, result, argument1, argument2);
> }
> 
> template<
>     typename JumpType, typename FunctionType, typename ResultType,
>     typename ArgumentType1, typename ArgumentType2, typename ArgumentType3>
>-inline PassOwnPtr<SlowPathGenerator> slowPathCall(
>+inline std::unique_ptr<SlowPathGenerator> slowPathCall(
>     JumpType from, SpeculativeJIT* jit, FunctionType function,
>     ResultType result, ArgumentType1 argument1, ArgumentType2 argument2,
>     ArgumentType3 argument3, SpillRegistersMode spillMode = NeedToSpill)
> {
>-    return adoptPtr(
>-        new CallResultAndThreeArgumentsSlowPathGenerator<
>-            JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2,
>-            ArgumentType3>(
>-                from, jit, function, spillMode, result, argument1, argument2,
>-                argument3));
>+    return std::make_unique<CallResultAndThreeArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2,
>+        ArgumentType3>>(from, jit, function, spillMode, result, argument1, argument2, argument3);
> }
> 
> template<
>     typename JumpType, typename FunctionType, typename ResultType,
>     typename ArgumentType1, typename ArgumentType2, typename ArgumentType3,
>     typename ArgumentType4>
>-inline PassOwnPtr<SlowPathGenerator> slowPathCall(
>+inline std::unique_ptr<SlowPathGenerator> slowPathCall(
>     JumpType from, SpeculativeJIT* jit, FunctionType function,
>     ResultType result, ArgumentType1 argument1, ArgumentType2 argument2,
>     ArgumentType3 argument3, ArgumentType4 argument4,
>     SpillRegistersMode spillMode = NeedToSpill)
> {
>-    return adoptPtr(
>-        new CallResultAndFourArgumentsSlowPathGenerator<
>-            JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2,
>-            ArgumentType3, ArgumentType4>(
>-                from, jit, function, spillMode, result, argument1, argument2,
>-                argument3, argument4));
>+    return std::make_unique<CallResultAndFourArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2,
>+        ArgumentType3, ArgumentType4>>(from, jit, function, spillMode, result, argument1, argument2, argument3, argument4);
> }
> 
> template<
>     typename JumpType, typename FunctionType, typename ResultType,
>     typename ArgumentType1, typename ArgumentType2, typename ArgumentType3,
>     typename ArgumentType4, typename ArgumentType5>
>-inline PassOwnPtr<SlowPathGenerator> slowPathCall(
>+inline std::unique_ptr<SlowPathGenerator> slowPathCall(
>     JumpType from, SpeculativeJIT* jit, FunctionType function,
>     ResultType result, ArgumentType1 argument1, ArgumentType2 argument2,
>     ArgumentType3 argument3, ArgumentType4 argument4, ArgumentType5 argument5,
>     SpillRegistersMode spillMode = NeedToSpill)
> {
>-    return adoptPtr(
>-        new CallResultAndFiveArgumentsSlowPathGenerator<
>-            JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2,
>-            ArgumentType3, ArgumentType4, ArgumentType5>(
>-                from, jit, function, spillMode, result, argument1, argument2,
>-                argument3, argument4, argument5));
>+    return std::make_unique<CallResultAndFiveArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2,
>+        ArgumentType3, ArgumentType4, ArgumentType5>>(from, jit, function, spillMode, result, argument1, argument2, argument3,
>+        argument4, argument5);
> }
> 
> template<typename JumpType, typename DestinationType, typename SourceType, unsigned numberOfAssignments>
>@@ -449,37 +432,31 @@ private:
> };
> 
> template<typename JumpType, typename DestinationType, typename SourceType, unsigned numberOfAssignments>
>-inline PassOwnPtr<SlowPathGenerator> slowPathMove(
>+inline std::unique_ptr<SlowPathGenerator> slowPathMove(
>     JumpType from, SpeculativeJIT* jit, SourceType source[numberOfAssignments], DestinationType destination[numberOfAssignments])
> {
>-    return adoptPtr(
>-        new AssigningSlowPathGenerator<
>-            JumpType, DestinationType, SourceType, numberOfAssignments>(
>-                from, jit, destination, source));
>+    return std::make_unique<AssigningSlowPathGenerator<JumpType, DestinationType, SourceType, numberOfAssignments>>(
>+        from, jit, destination, source);
> }
> 
> template<typename JumpType, typename DestinationType, typename SourceType>
>-inline PassOwnPtr<SlowPathGenerator> slowPathMove(
>+inline std::unique_ptr<SlowPathGenerator> slowPathMove(
>     JumpType from, SpeculativeJIT* jit, SourceType source, DestinationType destination)
> {
>     SourceType sourceArray[1] = { source };
>     DestinationType destinationArray[1] = { destination };
>-    return adoptPtr(
>-        new AssigningSlowPathGenerator<
>-            JumpType, DestinationType, SourceType, 1>(
>-                from, jit, destinationArray, sourceArray));
>+    return std::make_unique<AssigningSlowPathGenerator<JumpType, DestinationType, SourceType, 1>>(
>+        from, jit, destinationArray, sourceArray);
> }
> 
> template<typename JumpType, typename DestinationType, typename SourceType>
>-inline PassOwnPtr<SlowPathGenerator> slowPathMove(
>+inline std::unique_ptr<SlowPathGenerator> slowPathMove(
>     JumpType from, SpeculativeJIT* jit, SourceType source1, DestinationType destination1, SourceType source2, DestinationType destination2)
> {
>     SourceType sourceArray[2] = { source1, source2 };
>     DestinationType destinationArray[2] = { destination1, destination2 };
>-    return adoptPtr(
>-        new AssigningSlowPathGenerator<
>-            JumpType, DestinationType, SourceType, 2>(
>-                from, jit, destinationArray, sourceArray));
>+    return std::make_unique<AssigningSlowPathGenerator<JumpType, DestinationType, SourceType, 2>>(
>+        from, jit, destinationArray, sourceArray);
> }
> 
> } } // namespace JSC::DFG
>diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
>index b2b335000810ffd57a92661fe2cbe41800e57e2f..07998866bbacbda18c8c0f17e7893e3871a4496a 100644
>--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
>@@ -102,10 +102,9 @@ void SpeculativeJIT::emitAllocateJSArray(GPRReg resultGPR, Structure* structure,
>     // I want a slow path that also loads out the storage pointer, and that's
>     // what this custom CallArrayAllocatorSlowPathGenerator gives me. It's a lot
>     // of work for a very small piece of functionality. :-/
>-    addSlowPathGenerator(adoptPtr(
>-        new CallArrayAllocatorSlowPathGenerator(
>+    addSlowPathGenerator(std::make_unique<CallArrayAllocatorSlowPathGenerator>(
>             slowCases, this, operationNewArrayWithSize, resultGPR, storageGPR,
>-            structure, numElements)));
>+            structure, numElements));
> }
> 
> void SpeculativeJIT::emitAllocateArguments(GPRReg resultGPR, GPRReg scratchGPR1, GPRReg scratchGPR2, MacroAssembler::JumpList& slowPath)
>@@ -257,9 +256,9 @@ RegisterSet SpeculativeJIT::usedRegisters()
>     return result;
> }
> 
>-void SpeculativeJIT::addSlowPathGenerator(PassOwnPtr<SlowPathGenerator> slowPathGenerator)
>+void SpeculativeJIT::addSlowPathGenerator(std::unique_ptr<SlowPathGenerator> slowPathGenerator)
> {
>-    m_slowPathGenerators.append(slowPathGenerator);
>+    m_slowPathGenerators.append(WTF::move(slowPathGenerator));
> }
> 
> void SpeculativeJIT::runSlowPathGenerators()
>@@ -781,8 +780,8 @@ void SpeculativeJIT::arrayify(Node* node, GPRReg baseReg, GPRReg propertyReg)
>         slowPath.append(jumpSlowForUnwantedArrayMode(tempGPR, node->arrayMode()));
>     }
>     
>-    addSlowPathGenerator(adoptPtr(new ArrayifySlowPathGenerator(
>-        slowPath, this, node, baseReg, propertyReg, tempGPR, structureGPR)));
>+    addSlowPathGenerator(std::make_unique<ArrayifySlowPathGenerator>(
>+        slowPath, this, node, baseReg, propertyReg, tempGPR, structureGPR));
>     
>     noResult(m_currentNode);
> }
>@@ -879,7 +878,7 @@ void SpeculativeJIT::compileIn(Node* node)
>             MacroAssembler::PatchableJump jump = m_jit.patchableJump();
>             MacroAssembler::Label done = m_jit.label();
>             
>-            OwnPtr<SlowPathGenerator> slowPath = slowPathCall(
>+            auto slowPath = slowPathCall(
>                 jump.m_jump, this, operationInOptimize,
>                 JSValueRegs::payloadOnly(resultGPR), stubInfo, baseGPR,
>                 string->tryGetValueImpl());
>@@ -889,17 +888,17 @@ void SpeculativeJIT::compileIn(Node* node)
>             stubInfo->patch.valueGPR = static_cast<int8_t>(resultGPR);
>             stubInfo->patch.usedRegisters = usedRegisters();
>             stubInfo->patch.spillMode = NeedToSpill;
>-            
>+
>             m_jit.addIn(InRecord(jump, done, slowPath.get(), stubInfo));
>-            addSlowPathGenerator(slowPath.release());
>-                
>+            addSlowPathGenerator(WTF::move(slowPath));
>+
>             base.use();
>-            
>+
>             blessedBooleanResult(resultGPR, node, UseChildrenCalledExplicitly);
>             return;
>         }
>     }
>-        
>+
>     JSValueOperand key(this, node->child1());
>     JSValueRegs regs = key.jsValueRegs();
>         
>@@ -1779,12 +1778,12 @@ void SpeculativeJIT::compileGetByValOnString(Node* node)
>         JSGlobalObject* globalObject = m_jit.globalObjectFor(node->origin.semantic);
>         if (globalObject->stringPrototypeChainIsSane()) {
> #if USE(JSVALUE64)
>-            addSlowPathGenerator(adoptPtr(new SaneStringGetByValSlowPathGenerator(
>-                outOfBounds, this, JSValueRegs(scratchReg), baseReg, propertyReg)));
>+            addSlowPathGenerator(std::make_unique<SaneStringGetByValSlowPathGenerator>(
>+                outOfBounds, this, JSValueRegs(scratchReg), baseReg, propertyReg));
> #else
>-            addSlowPathGenerator(adoptPtr(new SaneStringGetByValSlowPathGenerator(
>+            addSlowPathGenerator(std::make_unique<SaneStringGetByValSlowPathGenerator>(
>                 outOfBounds, this, JSValueRegs(resultTagReg, scratchReg),
>-                baseReg, propertyReg)));
>+                baseReg, propertyReg));
> #endif
>         } else {
> #if USE(JSVALUE64)
>diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
>index 1a642533af214058bf903016c8e6924787698464..a1caa4ed0afda5416ba22a1a96c69a4429bc44de 100644
>--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
>+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
>@@ -316,7 +316,7 @@ public:
>     GPRReg fillSpeculateBoolean(Edge);
>     GeneratedOperandType checkGeneratedTypeForToInt32(Node*);
> 
>-    void addSlowPathGenerator(PassOwnPtr<SlowPathGenerator>);
>+    void addSlowPathGenerator(std::unique_ptr<SlowPathGenerator>);
>     void runSlowPathGenerators();
>     
>     void compile(Node*);
>@@ -2433,7 +2433,7 @@ public:
>     
>     bool m_isCheckingArgumentTypes;
>     
>-    Vector<OwnPtr<SlowPathGenerator>, 8> m_slowPathGenerators;
>+    Vector<std::unique_ptr<SlowPathGenerator>, 8> m_slowPathGenerators;
>     Vector<SilentRegisterSavePlan> m_plans;
> };
> 
>diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
>index e06da960461ba20d560e0e5ad98ce7931fc85dda..181838914323528ab020816f4266dd4ad43c2bba 100644
>--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
>@@ -189,8 +189,8 @@ void SpeculativeJIT::cachedGetById(
>     if (slowPathTarget.isSet())
>         slowCases.append(slowPathTarget);
>     slowCases.append(gen.slowPathJump());
>-    
>-    OwnPtr<SlowPathGenerator> slowPath;
>+
>+    std::unique_ptr<SlowPathGenerator> slowPath;
>     if (baseTagGPROrNone == InvalidGPRReg) {
>         slowPath = slowPathCall(
>             slowCases, this, operationGetByIdOptimize,
>@@ -203,9 +203,9 @@ void SpeculativeJIT::cachedGetById(
>             JSValueRegs(resultTagGPR, resultPayloadGPR), gen.stubInfo(), baseTagGPROrNone,
>             basePayloadGPR, identifierUID(identifierNumber));
>     }
>-    
>+
>     m_jit.addGetById(gen, slowPath.get());
>-    addSlowPathGenerator(slowPath.release());
>+    addSlowPathGenerator(WTF::move(slowPath));
> }
> 
> void SpeculativeJIT::cachedPutById(CodeOrigin codeOrigin, GPRReg basePayloadGPR, GPRReg valueTagGPR, GPRReg valuePayloadGPR, GPRReg scratchGPR, unsigned identifierNumber, PutKind putKind, JITCompiler::Jump slowPathTarget, SpillRegistersMode spillMode)
>@@ -222,12 +222,12 @@ void SpeculativeJIT::cachedPutById(CodeOrigin codeOrigin, GPRReg basePayloadGPR,
>         slowCases.append(slowPathTarget);
>     slowCases.append(gen.slowPathJump());
> 
>-    OwnPtr<SlowPathGenerator> slowPath = slowPathCall(
>+    auto slowPath = slowPathCall(
>         slowCases, this, gen.slowPathFunction(), NoResult, gen.stubInfo(), valueTagGPR,
>         valuePayloadGPR, basePayloadGPR, identifierUID(identifierNumber));
> 
>     m_jit.addPutById(gen, slowPath.get());
>-    addSlowPathGenerator(slowPath.release());
>+    addSlowPathGenerator(WTF::move(slowPath));
> }
> 
> void SpeculativeJIT::nonSpeculativeNonPeepholeCompareNull(Edge operand, bool invert)
>@@ -513,10 +513,9 @@ void SpeculativeJIT::nonSpeculativeNonPeepholeCompare(Node* node, MacroAssembler
>         m_jit.compare32(cond, arg1PayloadGPR, arg2PayloadGPR, resultPayloadGPR);
>     
>         if (!isKnownInteger(node->child1().node()) || !isKnownInteger(node->child2().node())) {
>-            addSlowPathGenerator(adoptPtr(
>-                new CompareAndBoxBooleanSlowPathGenerator<JITCompiler::JumpList>(
>+            addSlowPathGenerator(std::make_unique<CompareAndBoxBooleanSlowPathGenerator<JITCompiler::JumpList>>(
>                     slowPath, this, helperFunction, resultPayloadGPR, arg1TagGPR,
>-                    arg1PayloadGPR, arg2TagGPR, arg2PayloadGPR)));
>+                    arg1PayloadGPR, arg2TagGPR, arg2PayloadGPR));
>         }
>         
>         booleanResult(resultPayloadGPR, node, UseChildrenCalledExplicitly);
>@@ -3281,12 +3280,11 @@ void SpeculativeJIT::compile(Node* node)
>                 done.link(&m_jit);
>             }
>             
>-            addSlowPathGenerator(adoptPtr(
>-                new CallArrayAllocatorWithVariableSizeSlowPathGenerator(
>+            addSlowPathGenerator(std::make_unique<CallArrayAllocatorWithVariableSizeSlowPathGenerator>(
>                     slowCases, this, operationNewArrayWithSize, resultGPR,
>                     globalObject->arrayStructureForIndexingTypeDuringAllocation(node->indexingType()),
>                     globalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithArrayStorage),
>-                    sizeGPR)));
>+                    sizeGPR));
>             
>             cellResult(resultGPR, node);
>             break;
>diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
>index 38047fdb7084951a45fb7a001b1278da9ab87529..ba176dbdb4d350144959edaf995726e11da9da7c 100644
>--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
>@@ -159,12 +159,12 @@ void SpeculativeJIT::cachedGetById(CodeOrigin codeOrigin, GPRReg baseGPR, GPRReg
>         slowCases.append(slowPathTarget);
>     slowCases.append(gen.slowPathJump());
>     
>-    OwnPtr<SlowPathGenerator> slowPath = slowPathCall(
>+    auto slowPath = slowPathCall(
>         slowCases, this, operationGetByIdOptimize, resultGPR, gen.stubInfo(), baseGPR,
>         identifierUID(identifierNumber), spillMode);
>     
>     m_jit.addGetById(gen, slowPath.get());
>-    addSlowPathGenerator(slowPath.release());
>+    addSlowPathGenerator(WTF::move(slowPath));
> }
> 
> void SpeculativeJIT::cachedPutById(CodeOrigin codeOrigin, GPRReg baseGPR, GPRReg valueGPR, GPRReg scratchGPR, unsigned identifierNumber, PutKind putKind, JITCompiler::Jump slowPathTarget, SpillRegistersMode spillMode)
>@@ -180,12 +180,12 @@ void SpeculativeJIT::cachedPutById(CodeOrigin codeOrigin, GPRReg baseGPR, GPRReg
>         slowCases.append(slowPathTarget);
>     slowCases.append(gen.slowPathJump());
>     
>-    OwnPtr<SlowPathGenerator> slowPath = slowPathCall(
>+    auto slowPath = slowPathCall(
>         slowCases, this, gen.slowPathFunction(), NoResult, gen.stubInfo(), valueGPR, baseGPR,
>         identifierUID(identifierNumber));
> 
>     m_jit.addPutById(gen, slowPath.get());
>-    addSlowPathGenerator(slowPath.release());
>+    addSlowPathGenerator(WTF::move(slowPath));
> }
> 
> void SpeculativeJIT::nonSpeculativeNonPeepholeCompareNull(Edge operand, bool invert)
>@@ -465,9 +465,8 @@ void SpeculativeJIT::nonSpeculativeNonPeepholeCompare(Node* node, MacroAssembler
>         m_jit.or32(TrustedImm32(ValueFalse), resultGPR);
>         
>         if (!isKnownInteger(node->child1().node()) || !isKnownInteger(node->child2().node())) {
>-            addSlowPathGenerator(adoptPtr(
>-                new CompareAndBoxBooleanSlowPathGenerator<JITCompiler::JumpList>(
>-                    slowPath, this, helperFunction, resultGPR, arg1GPR, arg2GPR)));
>+            addSlowPathGenerator(std::make_unique<CompareAndBoxBooleanSlowPathGenerator<JITCompiler::JumpList>>(
>+                slowPath, this, helperFunction, resultGPR, arg1GPR, arg2GPR));
>         }
> 
>         jsValueResult(resultGPR, m_currentNode, DataFormatJSBoolean, UseChildrenCalledExplicitly);
>@@ -597,11 +596,9 @@ void SpeculativeJIT::nonSpeculativeNonPeepholeStrictEq(Node* node, bool invert)
>         
>         m_jit.move(JITCompiler::TrustedImm64(JSValue::encode(jsBoolean(!invert))), resultGPR);
>         
>-        addSlowPathGenerator(
>-            adoptPtr(
>-                new CompareAndBoxBooleanSlowPathGenerator<MacroAssembler::JumpList>(
>+        addSlowPathGenerator(std::make_unique<CompareAndBoxBooleanSlowPathGenerator<MacroAssembler::JumpList>>(
>                     slowPathCases, this, operationCompareStrictEq, resultGPR, arg1GPR,
>-                    arg2GPR)));
>+                    arg2GPR));
>         
>         done.link(&m_jit);
>     }
>@@ -3404,12 +3401,11 @@ void SpeculativeJIT::compile(Node* node)
>                 done.link(&m_jit);
>             }
>             
>-            addSlowPathGenerator(adoptPtr(
>-                new CallArrayAllocatorWithVariableSizeSlowPathGenerator(
>+            addSlowPathGenerator(std::make_unique<CallArrayAllocatorWithVariableSizeSlowPathGenerator>(
>                     slowCases, this, operationNewArrayWithSize, resultGPR,
>                     globalObject->arrayStructureForIndexingTypeDuringAllocation(node->indexingType()),
>                     globalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithArrayStorage),
>-                    sizeGPR)));
>+                    sizeGPR));
>             
>             cellResult(resultGPR, node);
>             break;

Actions: View | Formatted Diff | Diff

Attachments on bug 138489: 241156