<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[246883] branches/safari-607-branch</title>
</head>
<body>

<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt;  }
#msg dl a { font-weight: bold}
#msg dl a:link    { color:#fc3; }
#msg dl a:active  { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff  {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/246883">246883</a></dd>
<dt>Author</dt> <dd>kocsen_chung@apple.com</dd>
<dt>Date</dt> <dd>2019-06-27 09:35:18 -0700 (Thu, 27 Jun 2019)</dd>
</dl>

<h3>Log Message</h3>
<pre>Cherry-pick <a href="http://trac.webkit.org/projects/webkit/changeset/246740">r246740</a>. rdar://problem/52054323

    ArraySlice needs to keep the source array alive.
    https://bugs.webkit.org/show_bug.cgi?id=197374
    <rdar://problem/50304429>

    Reviewed by Michael Saboff and Filip Pizlo.

    JSTests:

    * stress/array-slice-must-keep-source-array-alive.js: Added.

    Source/JavaScriptCore:

    The implementation of the FTL ArraySlice intrinsics may GC while allocating the
    result array and its butterfly.  Previously, ArraySlice already keeps the source
    butterfly alive in order to copy from it to the new butterfly after the allocation.
    Unfortunately, this is not enough.  We also need to keep the source array alive
    so that GC will scan the values in the butterfly as well.  Note: the butterfly
    does not have a visitChildren() method to do this scan.  It's the parent object's
    responsibility to do the scanning.

    This patch fixes this by introducing a keepAlive() utility method, and we use it
    to keep the source array alive while allocating the result array and butterfly.

    keepAlive() works by using a patchpoint to communicate to B3 that a value (the
    source array in this case) is still in use.  It also uses a fence to keep B3 from
    relocating the patchpoint, which may defeat the fix.

    For the DFG's SpeculativeJIT::compileArraySlice(), we may have lucked out and the
    source array cell is kept alive.  This patch makes it explicit that we should
    keep its cell alive till after the result array has been allocated.

    For the Baseline JIT and LLInt, we use the arrayProtoFuncSlice() runtime function
    and there is no issue because the source array (in "thisObj") is in the element
    copying loop that follows the allocation of the result array.  However, for
    documentation purposes, this patch adds a call to HeapCell::use() to indicate that
    the source array need to kept alive at least until after the allocation of the
    result array.

    * dfg/DFGSpeculativeJIT.cpp:
    (JSC::DFG::SpeculativeJIT::compileArraySlice):
    * ftl/FTLLowerDFGToB3.cpp:
    (JSC::FTL::DFG::LowerDFGToB3::compileArraySlice):
    (JSC::FTL::DFG::LowerDFGToB3::allocateJSArray):
    (JSC::FTL::DFG::LowerDFGToB3::keepAlive):
    * runtime/ArrayPrototype.cpp:
    (JSC::arrayProtoFuncSlice):

    git-svn-id: https://svn.webkit.org/repository/webkit/trunk@246740 268f45cc-cd09-0410-ab3c-d52691b4dbfc</pre>

<h3>Modified Paths</h3>
<ul>
<li><a href="#branchessafari607branchJSTestsChangeLog">branches/safari-607-branch/JSTests/ChangeLog</a></li>
<li><a href="#branchessafari607branchSourceJavaScriptCoreChangeLog">branches/safari-607-branch/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#branchessafari607branchSourceJavaScriptCoredfgDFGSpeculativeJITcpp">branches/safari-607-branch/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp</a></li>
<li><a href="#branchessafari607branchSourceJavaScriptCoreftlFTLLowerDFGToB3cpp">branches/safari-607-branch/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp</a></li>
<li><a href="#branchessafari607branchSourceJavaScriptCoreruntimeArrayPrototypecpp">branches/safari-607-branch/Source/JavaScriptCore/runtime/ArrayPrototype.cpp</a></li>
</ul>

<h3>Added Paths</h3>
<ul>
<li><a href="#branchessafari607branchJSTestsstressarrayslicemustkeepsourcearrayalivejs">branches/safari-607-branch/JSTests/stress/array-slice-must-keep-source-array-alive.js</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="branchessafari607branchJSTestsChangeLog"></a>
<div class="modfile"><h4>Modified: branches/safari-607-branch/JSTests/ChangeLog (246882 => 246883)</h4>
<pre class="diff"><span>
<span class="info">--- branches/safari-607-branch/JSTests/ChangeLog     2019-06-27 16:10:01 UTC (rev 246882)
+++ branches/safari-607-branch/JSTests/ChangeLog        2019-06-27 16:35:18 UTC (rev 246883)
</span><span class="lines">@@ -1,3 +1,68 @@
</span><ins>+2019-06-27  Kocsen Chung  <kocsen_chung@apple.com>
+
+        Cherry-pick r246740. rdar://problem/52054323
+
+    ArraySlice needs to keep the source array alive.
+    https://bugs.webkit.org/show_bug.cgi?id=197374
+    <rdar://problem/50304429>
+    
+    Reviewed by Michael Saboff and Filip Pizlo.
+    
+    JSTests:
+    
+    * stress/array-slice-must-keep-source-array-alive.js: Added.
+    
+    Source/JavaScriptCore:
+    
+    The implementation of the FTL ArraySlice intrinsics may GC while allocating the
+    result array and its butterfly.  Previously, ArraySlice already keeps the source
+    butterfly alive in order to copy from it to the new butterfly after the allocation.
+    Unfortunately, this is not enough.  We also need to keep the source array alive
+    so that GC will scan the values in the butterfly as well.  Note: the butterfly
+    does not have a visitChildren() method to do this scan.  It's the parent object's
+    responsibility to do the scanning.
+    
+    This patch fixes this by introducing a keepAlive() utility method, and we use it
+    to keep the source array alive while allocating the result array and butterfly.
+    
+    keepAlive() works by using a patchpoint to communicate to B3 that a value (the
+    source array in this case) is still in use.  It also uses a fence to keep B3 from
+    relocating the patchpoint, which may defeat the fix.
+    
+    For the DFG's SpeculativeJIT::compileArraySlice(), we may have lucked out and the
+    source array cell is kept alive.  This patch makes it explicit that we should
+    keep its cell alive till after the result array has been allocated.
+    
+    For the Baseline JIT and LLInt, we use the arrayProtoFuncSlice() runtime function
+    and there is no issue because the source array (in "thisObj") is in the element
+    copying loop that follows the allocation of the result array.  However, for
+    documentation purposes, this patch adds a call to HeapCell::use() to indicate that
+    the source array need to kept alive at least until after the allocation of the
+    result array.
+    
+    * dfg/DFGSpeculativeJIT.cpp:
+    (JSC::DFG::SpeculativeJIT::compileArraySlice):
+    * ftl/FTLLowerDFGToB3.cpp:
+    (JSC::FTL::DFG::LowerDFGToB3::compileArraySlice):
+    (JSC::FTL::DFG::LowerDFGToB3::allocateJSArray):
+    (JSC::FTL::DFG::LowerDFGToB3::keepAlive):
+    * runtime/ArrayPrototype.cpp:
+    (JSC::arrayProtoFuncSlice):
+    
+    
+    
+    git-svn-id: https://svn.webkit.org/repository/webkit/trunk@246740 268f45cc-cd09-0410-ab3c-d52691b4dbfc
+
+    2019-06-21  Mark Lam  <mark.lam@apple.com>
+
+            ArraySlice needs to keep the source array alive.
+            https://bugs.webkit.org/show_bug.cgi?id=197374
+            <rdar://problem/50304429>
+
+            Reviewed by Michael Saboff and Filip Pizlo.
+
+            * stress/array-slice-must-keep-source-array-alive.js: Added.
+
</ins><span class="cx"> 2019-06-24  Kocsen Chung  <kocsen_chung@apple.com>
</span><span class="cx"> 
</span><span class="cx">         Cherry-pick r246372. rdar://problem/51927634
</span></span></pre></div>
<a id="branchessafari607branchJSTestsstressarrayslicemustkeepsourcearrayalivejs"></a>
<div class="addfile"><h4>Added: branches/safari-607-branch/JSTests/stress/array-slice-must-keep-source-array-alive.js (0 => 246883)</h4>
<pre class="diff"><span>
<span class="info">--- branches/safari-607-branch/JSTests/stress/array-slice-must-keep-source-array-alive.js                            (rev 0)
+++ branches/safari-607-branch/JSTests/stress/array-slice-must-keep-source-array-alive.js       2019-06-27 16:35:18 UTC (rev 246883)
</span><span class="lines">@@ -0,0 +1,19 @@
</span><ins>+//@ runDefault("--useConcurrentGC=false", "--useConcurrentJIT=false", "--thresholdForFTLOptimizeAfterWarmUp=1000")
+
+var functions = [];
+
+function boo() {
+    functions.push(new Function("a", "return a"));
+    return functions.splice(0);
+}
+
+function test() {
+    functions = boo().slice();
+}
+
+noDFG(boo);
+noInline(boo);
+noInline(test);
+
+for (var i = 0; i < 10000; i++)
+    test();
</ins></span></pre></div>
<a id="branchessafari607branchSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: branches/safari-607-branch/Source/JavaScriptCore/ChangeLog (246882 => 246883)</h4>
<pre class="diff"><span>
<span class="info">--- branches/safari-607-branch/Source/JavaScriptCore/ChangeLog       2019-06-27 16:10:01 UTC (rev 246882)
+++ branches/safari-607-branch/Source/JavaScriptCore/ChangeLog  2019-06-27 16:35:18 UTC (rev 246883)
</span><span class="lines">@@ -1,3 +1,101 @@
</span><ins>+2019-06-27  Kocsen Chung  <kocsen_chung@apple.com>
+
+        Cherry-pick r246740. rdar://problem/52054323
+
+    ArraySlice needs to keep the source array alive.
+    https://bugs.webkit.org/show_bug.cgi?id=197374
+    <rdar://problem/50304429>
+    
+    Reviewed by Michael Saboff and Filip Pizlo.
+    
+    JSTests:
+    
+    * stress/array-slice-must-keep-source-array-alive.js: Added.
+    
+    Source/JavaScriptCore:
+    
+    The implementation of the FTL ArraySlice intrinsics may GC while allocating the
+    result array and its butterfly.  Previously, ArraySlice already keeps the source
+    butterfly alive in order to copy from it to the new butterfly after the allocation.
+    Unfortunately, this is not enough.  We also need to keep the source array alive
+    so that GC will scan the values in the butterfly as well.  Note: the butterfly
+    does not have a visitChildren() method to do this scan.  It's the parent object's
+    responsibility to do the scanning.
+    
+    This patch fixes this by introducing a keepAlive() utility method, and we use it
+    to keep the source array alive while allocating the result array and butterfly.
+    
+    keepAlive() works by using a patchpoint to communicate to B3 that a value (the
+    source array in this case) is still in use.  It also uses a fence to keep B3 from
+    relocating the patchpoint, which may defeat the fix.
+    
+    For the DFG's SpeculativeJIT::compileArraySlice(), we may have lucked out and the
+    source array cell is kept alive.  This patch makes it explicit that we should
+    keep its cell alive till after the result array has been allocated.
+    
+    For the Baseline JIT and LLInt, we use the arrayProtoFuncSlice() runtime function
+    and there is no issue because the source array (in "thisObj") is in the element
+    copying loop that follows the allocation of the result array.  However, for
+    documentation purposes, this patch adds a call to HeapCell::use() to indicate that
+    the source array need to kept alive at least until after the allocation of the
+    result array.
+    
+    * dfg/DFGSpeculativeJIT.cpp:
+    (JSC::DFG::SpeculativeJIT::compileArraySlice):
+    * ftl/FTLLowerDFGToB3.cpp:
+    (JSC::FTL::DFG::LowerDFGToB3::compileArraySlice):
+    (JSC::FTL::DFG::LowerDFGToB3::allocateJSArray):
+    (JSC::FTL::DFG::LowerDFGToB3::keepAlive):
+    * runtime/ArrayPrototype.cpp:
+    (JSC::arrayProtoFuncSlice):
+    
+    
+    
+    git-svn-id: https://svn.webkit.org/repository/webkit/trunk@246740 268f45cc-cd09-0410-ab3c-d52691b4dbfc
+
+    2019-06-24  Mark Lam  <mark.lam@apple.com>
+
+            ArraySlice needs to keep the source array alive.
+            https://bugs.webkit.org/show_bug.cgi?id=197374
+            <rdar://problem/50304429>
+
+            Reviewed by Michael Saboff and Filip Pizlo.
+
+            The implementation of the FTL ArraySlice intrinsics may GC while allocating the
+            result array and its butterfly.  Previously, ArraySlice already keeps the source
+            butterfly alive in order to copy from it to the new butterfly after the allocation.
+            Unfortunately, this is not enough.  We also need to keep the source array alive
+            so that GC will scan the values in the butterfly as well.  Note: the butterfly
+            does not have a visitChildren() method to do this scan.  It's the parent object's
+            responsibility to do the scanning.
+
+            This patch fixes this by introducing a keepAlive() utility method, and we use it
+            to keep the source array alive while allocating the result array and butterfly.
+
+            keepAlive() works by using a patchpoint to communicate to B3 that a value (the
+            source array in this case) is still in use.  It also uses a fence to keep B3 from
+            relocating the patchpoint, which may defeat the fix.
+
+            For the DFG's SpeculativeJIT::compileArraySlice(), we may have lucked out and the
+            source array cell is kept alive.  This patch makes it explicit that we should
+            keep its cell alive till after the result array has been allocated.
+
+            For the Baseline JIT and LLInt, we use the arrayProtoFuncSlice() runtime function
+            and there is no issue because the source array (in "thisObj") is in the element
+            copying loop that follows the allocation of the result array.  However, for
+            documentation purposes, this patch adds a call to HeapCell::use() to indicate that
+            the source array need to kept alive at least until after the allocation of the
+            result array.
+
+            * dfg/DFGSpeculativeJIT.cpp:
+            (JSC::DFG::SpeculativeJIT::compileArraySlice):
+            * ftl/FTLLowerDFGToB3.cpp:
+            (JSC::FTL::DFG::LowerDFGToB3::compileArraySlice):
+            (JSC::FTL::DFG::LowerDFGToB3::allocateJSArray):
+            (JSC::FTL::DFG::LowerDFGToB3::keepAlive):
+            * runtime/ArrayPrototype.cpp:
+            (JSC::arrayProtoFuncSlice):
+
</ins><span class="cx"> 2019-06-24  Kocsen Chung  <kocsen_chung@apple.com>
</span><span class="cx"> 
</span><span class="cx">         Cherry-pick r246372. rdar://problem/51927634
</span></span></pre></div>
<a id="branchessafari607branchSourceJavaScriptCoredfgDFGSpeculativeJITcpp"></a>
<div class="modfile"><h4>Modified: branches/safari-607-branch/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp (246882 => 246883)</h4>
<pre class="diff"><span>
<span class="info">--- branches/safari-607-branch/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp       2019-06-27 16:10:01 UTC (rev 246882)
+++ branches/safari-607-branch/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp  2019-06-27 16:35:18 UTC (rev 246883)
</span><span class="lines">@@ -8242,17 +8242,18 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-
</del><span class="cx">     GPRTemporary temp3(this);
</span><span class="cx">     GPRReg tempValue = temp3.gpr();
</span><ins>+
</ins><span class="cx">     {
</span><ins>+        // We need to keep the source array alive at least until after we're done
+        // with anything that can GC (e.g. allocating the result array below).
</ins><span class="cx">         SpeculateCellOperand cell(this, m_jit.graph().varArgChild(node, 0));
</span><ins>+
</ins><span class="cx">         m_jit.load8(MacroAssembler::Address(cell.gpr(), JSCell::indexingTypeAndMiscOffset()), tempValue);
</span><span class="cx">         // We can ignore the writability of the cell since we won't write to the source.
</span><span class="cx">         m_jit.and32(TrustedImm32(AllWritableArrayTypesAndHistory), tempValue);
</span><del>-    }
</del><span class="cx"> 
</span><del>-    {
</del><span class="cx">         JSValueRegsTemporary emptyValue(this);
</span><span class="cx">         JSValueRegs emptyValueRegs = emptyValue.regs();
</span><span class="cx"> 
</span></span></pre></div>
<a id="branchessafari607branchSourceJavaScriptCoreftlFTLLowerDFGToB3cpp"></a>
<div class="modfile"><h4>Modified: branches/safari-607-branch/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp (246882 => 246883)</h4>
<pre class="diff"><span>
<span class="info">--- branches/safari-607-branch/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp 2019-06-27 16:10:01 UTC (rev 246882)
+++ branches/safari-607-branch/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp    2019-06-27 16:35:18 UTC (rev 246883)
</span><span class="lines">@@ -4887,6 +4887,7 @@
</span><span class="cx">     {
</span><span class="cx">         JSGlobalObject* globalObject = m_graph.globalObjectFor(m_node->origin.semantic);
</span><span class="cx"> 
</span><ins>+        LValue sourceArray = lowCell(m_graph.varArgChild(m_node, 0));
</ins><span class="cx">         LValue sourceStorage = lowStorage(m_graph.varArgChild(m_node, m_node->numChildren() - 1));
</span><span class="cx">         LValue inputLength = m_out.load32(sourceStorage, m_heaps.Butterfly_publicLength);
</span><span class="cx"> 
</span><span class="lines">@@ -4912,7 +4913,7 @@
</span><span class="cx"> 
</span><span class="cx">         ArrayValues arrayResult;
</span><span class="cx">         {
</span><del>-            LValue indexingType = m_out.load8ZeroExt32(lowCell(m_graph.varArgChild(m_node, 0)), m_heaps.JSCell_indexingTypeAndMisc);
</del><ins>+            LValue indexingType = m_out.load8ZeroExt32(sourceArray, m_heaps.JSCell_indexingTypeAndMisc);
</ins><span class="cx">             // We can ignore the writability of the cell since we won't write to the source.
</span><span class="cx">             indexingType = m_out.bitAnd(indexingType, m_out.constInt32(AllWritableArrayTypesAndHistory));
</span><span class="cx">             // When we emit an ArraySlice, we dominate the use of the array by a CheckStructure
</span><span class="lines">@@ -4927,6 +4928,9 @@
</span><span class="cx">             arrayResult = allocateJSArray(resultLength, resultLength, structure, indexingType, false, false);
</span><span class="cx">         }
</span><span class="cx"> 
</span><ins>+        // Keep the sourceArray alive at least until after anything that can GC.
+        keepAlive(sourceArray);
+
</ins><span class="cx">         LBasicBlock loop = m_out.newBlock();
</span><span class="cx">         LBasicBlock continuation = m_out.newBlock();
</span><span class="cx"> 
</span><span class="lines">@@ -13393,7 +13397,7 @@
</span><span class="cx">         }
</span><span class="cx">         
</span><span class="cx">         ValueFromBlock noButterfly = m_out.anchor(m_out.intPtrZero);
</span><del>-        
</del><ins>+
</ins><span class="cx">         LValue predicate;
</span><span class="cx">         if (shouldLargeArraySizeCreateArrayStorage)
</span><span class="cx">             predicate = m_out.aboveOrEqual(publicLength, m_out.constInt32(MIN_ARRAY_STORAGE_CONSTRUCTION_LENGTH));
</span><span class="lines">@@ -13403,16 +13407,16 @@
</span><span class="cx">         m_out.branch(predicate, rarely(largeCase), usually(fastCase));
</span><span class="cx">         
</span><span class="cx">         m_out.appendTo(fastCase, largeCase);
</span><del>-            
</del><ins>+
</ins><span class="cx">         LValue payloadSize =
</span><span class="cx">             m_out.shl(m_out.zeroExt(vectorLength, pointerType()), m_out.constIntPtr(3));
</span><del>-            
</del><ins>+
</ins><span class="cx">         LValue butterflySize = m_out.add(
</span><span class="cx">             payloadSize, m_out.constIntPtr(sizeof(IndexingHeader)));
</span><del>-            
</del><ins>+
</ins><span class="cx">         LValue allocator = allocatorForSize(vm().jsValueGigacageAuxiliarySpace, butterflySize, failCase);
</span><span class="cx">         LValue startOfStorage = allocateHeapCell(allocator, failCase);
</span><del>-            
</del><ins>+
</ins><span class="cx">         LValue butterfly = m_out.add(startOfStorage, m_out.constIntPtr(sizeof(IndexingHeader)));
</span><span class="cx">         
</span><span class="cx">         m_out.store32(publicLength, butterfly, m_heaps.Butterfly_publicLength);
</span><span class="lines">@@ -16920,7 +16924,16 @@
</span><span class="cx">             return false;
</span><span class="cx">         return true;
</span><span class="cx">     }
</span><del>-    
</del><ins>+
+    void keepAlive(LValue value)
+    {
+        PatchpointValue* patchpoint = m_out.patchpoint(Void);
+        patchpoint->effects = Effects::none();
+        patchpoint->effects.writesLocalState = true;
+        patchpoint->append(value, ValueRep::ColdAny);
+        patchpoint->setGenerator([=] (CCallHelpers&, const StackmapGenerationParams&) { });
+    }
+
</ins><span class="cx">     void addWeakReference(JSCell* target)
</span><span class="cx">     {
</span><span class="cx">         m_graph.m_plan.weakReferences().addLazily(target);
</span></span></pre></div>
<a id="branchessafari607branchSourceJavaScriptCoreruntimeArrayPrototypecpp"></a>
<div class="modfile"><h4>Modified: branches/safari-607-branch/Source/JavaScriptCore/runtime/ArrayPrototype.cpp (246882 => 246883)</h4>
<pre class="diff"><span>
<span class="info">--- branches/safari-607-branch/Source/JavaScriptCore/runtime/ArrayPrototype.cpp      2019-06-27 16:10:01 UTC (rev 246882)
+++ branches/safari-607-branch/Source/JavaScriptCore/runtime/ArrayPrototype.cpp 2019-06-27 16:35:18 UTC (rev 246883)
</span><span class="lines">@@ -988,6 +988,10 @@
</span><span class="cx">         RETURN_IF_EXCEPTION(scope, { });
</span><span class="cx">     }
</span><span class="cx"> 
</span><ins>+    // Document that we need to keep the source array alive until after anything
+    // that can GC (e.g. allocating the result array).
+    thisObj->use();
+
</ins><span class="cx">     unsigned n = 0;
</span><span class="cx">     for (unsigned k = begin; k < end; k++, n++) {
</span><span class="cx">         JSValue v = getProperty(exec, thisObj, k);
</span></span></pre>
</div>
</div>

</body>
</html>