Change to address CVE-2016-7200,CVE-2016-7201,CVE-2016-7202,CVE-2016-7203,CVE-2016-7208,CVE-2016-7240,CVE-2016-7241,CVE-2016-7242,CVE-2016-7243

Suwei Chen · Suwei Chen · commit c2787ef8fdb7 · 2016-11-10T16:04:50.000-08:00
Type confusion in Array.prototype.filter Type confusion due to reentrancy can cause a Var to be written into a native int array. Fix by making sure type-specialized code path is used only when ArraySpeciesCreate() invokes built-in Array constructor. Heap overflow in Array.prototype.splice In Array.prototype.splice, array length is cached before ArraySpeciesCreate() is invoked. Side-effect from ArraySpeciesCreate() can change array length and result in inconsistent states and possibly heap overflow. Fix by adding length check to keep cases with side effects out of fast path with pre-calculated length. Also tweak logic in ArraySpeciesCreate() to flag a non-built-in constructor with missing [@species] property. Type confusion in FillFromPrototypes In ForEachOwnMissingArrayIndexOfObject(), existing array enumeration logic assumes Var array. A native array from caller can cause type confusion and leak. Fix by converting incoming native arrays to Var arrays. Parameter type confusion in eval Extra argument signified by CallFlags_ExtraArg shall be cast to FrameDisplay unless the extra argument is used for new.target, in which case CallFlags_NewTarget is be set. Type confusion and AV occur because existing logic in eval() does not check if CallFlags_NewTarget is cleared before using extra argument as FrameDisplay. Fix by adding CallFlags_NewTarget check to eval() before cast to FrameDisplay. Type confusion in JSON.parse Non-native array is expected in JSONParser::Walk(). A native array from caller can cause type confusion and heap overflow Fix by converting native arrays to Var arrays. Type confusion in Array.prototype.concat and .splice Array newly created by ArraySpeciesCreate is not being checked if it is a JavascriptCopyOnAccessNativeIntArray, causing near-nullptr AVs. Fix by adding check-and-convert against JavascriptCopyOnAccessNativeIntArray in affected built-ins.
diff --git a/lib/Runtime/Base/CallInfo.h b/lib/Runtime/Base/CallInfo.h
@@ -65,6 +65,16 @@ namespace Js
         static const ushort ksizeofCount;
         static const ushort ksizeofCallFlags;
         static const uint kMaxCountArgs;
+
+        static bool isDirectEvalCall(CallFlags flags)
+        {
+            // This was recognized as an eval call at compile time. The last one or two args are internal to us.
+            // Argcount will be one of the following when called from global code
+            //  - eval("...")     : argcount 3 : this, evalString, frameDisplay
+            //  - eval.call("..."): argcount 2 : this(which is string) , frameDisplay
+
+            return (flags & (CallFlags_ExtraArg | CallFlags_NewTarget)) == CallFlags_ExtraArg;  // ExtraArg == 1 && NewTarget == 0
+        }
     };
 
     struct InlineeCallInfo
diff --git a/lib/Runtime/Library/GlobalObject.cpp b/lib/Runtime/Library/GlobalObject.cpp
@@ -491,7 +491,7 @@ namespace Js
         // TODO: Handle call from global scope, strict mode
         BOOL isIndirect = FALSE;
 
-        if (args.Info.Flags & CallFlags_ExtraArg)
+        if (Js::CallInfo::isDirectEvalCall(args.Info.Flags))
         {
             // This was recognized as an eval call at compile time. The last one or two args are internal to us.
             // Argcount will be one of the following when called from global code
diff --git a/lib/Runtime/Library/JSONParser.cpp b/lib/Runtime/Library/JSONParser.cpp
@@ -83,8 +83,7 @@ namespace JSON
         // this is a post order walk. Visit the children before calling walk on this object
         if (Js::DynamicObject::IsAnyArray(value))
         {
-            Js::JavascriptArray* arrayVal = Js::JavascriptArray::FromAnyArray(value);
-            // REVIEW: How do we guarantee that JSON objects are not native arrays?
+            Js::JavascriptArray* arrayVal = JavascriptArray::EnsureNonNativeArray(Js::JavascriptArray::FromAnyArray(value));
             Assert(!Js::JavascriptNativeIntArray::Is(arrayVal) && !Js::JavascriptNativeFloatArray::Is(arrayVal));
             uint length = arrayVal->GetLength();
             if (!arrayVal->IsCrossSiteObject())
diff --git a/lib/Runtime/Library/JavascriptArray.cpp b/lib/Runtime/Library/JavascriptArray.cpp
@@ -714,6 +714,40 @@ namespace Js
         return IsMissingHeadSegmentItemImpl<double>(index);
     }
 
+    template<typename T>
+    void JavascriptArray::InternalFillFromPrototype(JavascriptArray *dstArray, const T& dstIndex, JavascriptArray *srcArray, uint32 start, uint32 end, uint32 count)
+    {
+        RecyclableObject* prototype = srcArray->GetPrototype();
+        while (start + count != end && JavascriptOperators::GetTypeId(prototype) != TypeIds_Null)
+        {
+            ForEachOwnMissingArrayIndexOfObject(srcArray, dstArray, prototype, start, end, dstIndex, [&](uint32 index, Var value) {
+                T n = dstIndex + (index - start);
+                dstArray->DirectSetItemAt(n, value);
+
+                count++;
+            });
+
+            prototype = prototype->GetPrototype();
+        }
+    }
+
+    template<>
+    void JavascriptArray::InternalFillFromPrototype<uint32>(JavascriptArray *dstArray, const uint32& dstIndex, JavascriptArray *srcArray, uint32 start, uint32 end, uint32 count)
+    {
+        RecyclableObject* prototype = srcArray->GetPrototype();
+        while (start + count != end && JavascriptOperators::GetTypeId(prototype) != TypeIds_Null)
+        {
+            ForEachOwnMissingArrayIndexOfObject(srcArray, dstArray, prototype, start, end, dstIndex, [&](uint32 index, Var value) {
+                uint32 n = dstIndex + (index - start);
+                dstArray->SetItem(n, value, PropertyOperation_None);
+
+                count++;
+            });
+
+            prototype = prototype->GetPrototype();
+        }
+    }
+
     /* static */
     bool JavascriptArray::HasInlineHeadSegment(uint32 length)
     {
@@ -3308,6 +3342,9 @@ namespace Js
         pDestObj = ArraySpeciesCreate(args[0], 0, scriptContext);
         if (pDestObj)
         {
+#if ENABLE_COPYONACCESS_ARRAY
+            JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(pDestObj);
+#endif
             // Check the thing that species create made. If it's a native array that can't handle the source
             // data, convert it. If it's a more conservative kind of array than the source data, indicate that
             // so that the data will be converted on copy.
@@ -5863,13 +5900,19 @@ namespace Js
             }
 
             newArr = CreateNewArrayHelper(static_cast<uint32>(newLenT), isIntArray, isFloatArray, pArr, scriptContext);
+#if ENABLE_COPYONACCESS_ARRAY
+            JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(newArr);
+#endif
             newObj = newArr;
         }
         else
         {
             // If the new object we created is an array, remember that as it will save us time setting properties in the object below
             if (JavascriptArray::Is(newObj))
             {
+#if ENABLE_COPYONACCESS_ARRAY
+                JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(newObj);
+#endif
                 newArr = JavascriptArray::FromVar(newObj);
             }
         }
@@ -6649,6 +6692,9 @@ namespace Js
                 // If the new object we created is an array, remember that as it will save us time setting properties in the object below
                 if (JavascriptArray::Is(newObj))
                 {
+#if ENABLE_COPYONACCESS_ARRAY
+                    JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(newObj);
+#endif
                     newArr = JavascriptArray::FromVar(newObj);
                 }
             }
@@ -6657,10 +6703,13 @@ namespace Js
             {
                 pArr->GetArrayTypeAndConvert(&isIntArray, &isFloatArray);
                 newArr = CreateNewArrayHelper(deleteLen, isIntArray, isFloatArray, pArr, scriptContext);
+#if ENABLE_COPYONACCESS_ARRAY
+                JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(newArr);
+#endif
             }
 
             // If return object is a JavascriptArray, we can use all the array splice helpers
-            if (newArr && isBuiltinArrayCtor)
+            if (newArr && isBuiltinArrayCtor && len == pArr->length)
             {
 
                 // Array has a single segment (need not start at 0) and splice start lies in the range
@@ -7151,6 +7200,9 @@ namespace Js
 
         if (JavascriptArray::Is(pNewObj))
         {
+#if ENABLE_COPYONACCESS_ARRAY
+            JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(pNewObj);
+#endif
             pnewArr = JavascriptArray::FromVar(pNewObj);
         }
 
@@ -8924,6 +8976,9 @@ namespace Js
             // If the new object we created is an array, remember that as it will save us time setting properties in the object below
             if (JavascriptArray::Is(newObj))
             {
+#if ENABLE_COPYONACCESS_ARRAY
+                JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(newObj);
+#endif
                 newArr = JavascriptArray::FromVar(newObj);
             }
         }
@@ -9123,7 +9178,8 @@ namespace Js
         }
 
         // If the source object is an Array exotic object we should try to load the constructor property and use it to construct the return object.
-        RecyclableObject* newObj = ArraySpeciesCreate(obj, 0, scriptContext);
+        bool isBuiltinArrayCtor = true;
+        RecyclableObject* newObj = ArraySpeciesCreate(obj, 0, scriptContext, nullptr, nullptr, &isBuiltinArrayCtor);
         JavascriptArray* newArr = nullptr;
 
         if (newObj == nullptr)
@@ -9137,6 +9193,9 @@ namespace Js
             // If the new object we created is an array, remember that as it will save us time setting properties in the object below
             if (JavascriptArray::Is(newObj))
             {
+#if ENABLE_COPYONACCESS_ARRAY
+                JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(newObj);
+#endif
                 newArr = JavascriptArray::FromVar(newObj);
             }
         }
@@ -9164,7 +9223,7 @@ namespace Js
                 if (JavascriptConversion::ToBoolean(selected, scriptContext))
                 {
                     // Try to fast path if the return object is an array
-                    if (newArr)
+                    if (newArr && isBuiltinArrayCtor)
                     {
                         newArr->DirectSetItemAt(i, element);
                     }
@@ -10041,6 +10100,7 @@ namespace Js
         {
             if (JavascriptArray::Is(arr))
             {
+                arr = EnsureNonNativeArray(arr);
                 ArrayElementEnumerator e(arr, startIndex, limitIndex);
 
                 while(e.MoveNext<Var>())
@@ -10096,6 +10156,7 @@ namespace Js
         {
             if (JavascriptArray::Is(arr))
             {
+                arr = EnsureNonNativeArray(arr);
                 ArrayElementEnumerator e(arr, startIndex, limitIndex);
 
                 while(e.MoveNext<Var>())
@@ -10849,6 +10910,9 @@ namespace Js
 
     JavascriptArray *JavascriptArray::EnsureNonNativeArray(JavascriptArray *arr)
     {
+#if ENABLE_COPYONACCESS_ARRAY
+        JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(arr);
+#endif
         if (JavascriptNativeIntArray::Is(arr))
         {
             arr = JavascriptNativeIntArray::ToVarArray((JavascriptNativeIntArray*)arr);
@@ -10931,23 +10995,6 @@ namespace Js
         }
     }
 
-    template<typename T>
-    void JavascriptArray::InternalFillFromPrototype(JavascriptArray *dstArray, const T& dstIndex, JavascriptArray *srcArray, uint32 start, uint32 end, uint32 count)
-    {
-        RecyclableObject* prototype = srcArray->GetPrototype();
-        while (start + count != end && JavascriptOperators::GetTypeId(prototype) != TypeIds_Null)
-        {
-            ForEachOwnMissingArrayIndexOfObject(srcArray, dstArray, prototype, start, end, dstIndex, [&](uint32 index, Var value) {
-                T n = dstIndex + (index - start);
-                dstArray->DirectSetItemAt(n, value);
-
-                count++;
-            });
-
-            prototype = prototype->GetPrototype();
-        }
-    }
-
     Var JavascriptArray::SpreadArrayArgs(Var arrayToSpread, const Js::AuxArray<uint32> *spreadIndices, ScriptContext *scriptContext)
     {
         // At this stage we have an array literal with some arguments to be spread.
@@ -11458,6 +11505,11 @@ namespace Js
             {
                 if (!JavascriptOperators::GetProperty((RecyclableObject*)constructor, PropertyIds::_symbolSpecies, &constructor, scriptContext))
                 {
+                    if (pIsBuiltinArrayCtor != nullptr)
+                    {
+                        *pIsBuiltinArrayCtor = false;
+                    }
+
                     return nullptr;
                 }
                 if (constructor == scriptContext->GetLibrary()->GetNull())
diff --git a/lib/Runtime/Library/JavascriptPromise.cpp b/lib/Runtime/Library/JavascriptPromise.cpp
@@ -910,7 +910,7 @@ namespace Js
 
         try
         {
-            values->DirectSetItemAt(index, x);
+            values->SetItem(index, x, PropertyOperation_None);
         }
         catch (JavascriptExceptionObject* e)
         {
diff --git a/test/Array/Array_TypeConfusion_bugs.js b/test/Array/Array_TypeConfusion_bugs.js
diff --git a/test/es6/ES6NewTarget_bugfixes.js b/test/es6/ES6NewTarget_bugfixes.js

Original file line number	Diff line number	Diff line change
`@@ -491,7 +491,7 @@ namespace Js`
`491`	`491`	`// TODO: Handle call from global scope, strict mode`
`492`	`492`	`BOOL isIndirect = FALSE;`
`493`	`493`
`494`		`- if (args.Info.Flags & CallFlags_ExtraArg)`
	`494`	`+ if (Js::CallInfo::isDirectEvalCall(args.Info.Flags))`
`495`	`495`	`{`
`496`	`496`	`// This was recognized as an eval call at compile time. The last one or two args are internal to us.`
`497`	`497`	`// Argcount will be one of the following when called from global code`
Original file line number	Diff line number	Diff line change
`@@ -714,6 +714,40 @@ namespace Js`
`714`	`714`	`return IsMissingHeadSegmentItemImpl<double>(index);`
`715`	`715`	`}`
`716`	`716`
	`717`	`+ template<typename T>`
	`718`	`+ void JavascriptArray::InternalFillFromPrototype(JavascriptArray dstArray, const T& dstIndex, JavascriptArray srcArray, uint32 start, uint32 end, uint32 count)`
	`719`	`+ {`
	`720`	`+ RecyclableObject* prototype = srcArray->GetPrototype();`
	`721`	`+ while (start + count != end && JavascriptOperators::GetTypeId(prototype) != TypeIds_Null)`
	`722`	`+ {`
	`723`	`+ ForEachOwnMissingArrayIndexOfObject(srcArray, dstArray, prototype, start, end, dstIndex, [&](uint32 index, Var value) {`
	`724`	`+ T n = dstIndex + (index - start);`
	`725`	`+ dstArray->DirectSetItemAt(n, value);`
	`726`	`+`
	`727`	`+ count++;`
	`728`	`+ });`
	`729`	`+`
	`730`	`+ prototype = prototype->GetPrototype();`
	`731`	`+ }`
	`732`	`+ }`
	`733`	`+`
	`734`	`+ template<>`
	`735`	`+ void JavascriptArray::InternalFillFromPrototype<uint32>(JavascriptArray dstArray, const uint32& dstIndex, JavascriptArray srcArray, uint32 start, uint32 end, uint32 count)`
	`736`	`+ {`
	`737`	`+ RecyclableObject* prototype = srcArray->GetPrototype();`
	`738`	`+ while (start + count != end && JavascriptOperators::GetTypeId(prototype) != TypeIds_Null)`
	`739`	`+ {`
	`740`	`+ ForEachOwnMissingArrayIndexOfObject(srcArray, dstArray, prototype, start, end, dstIndex, [&](uint32 index, Var value) {`
	`741`	`+ uint32 n = dstIndex + (index - start);`
	`742`	`+ dstArray->SetItem(n, value, PropertyOperation_None);`
	`743`	`+`
	`744`	`+ count++;`
	`745`	`+ });`
	`746`	`+`
	`747`	`+ prototype = prototype->GetPrototype();`
	`748`	`+ }`
	`749`	`+ }`
	`750`	`+`
`717`	`751`	`/* static */`
`718`	`752`	`bool JavascriptArray::HasInlineHeadSegment(uint32 length)`
`719`	`753`	`{`
`@@ -3308,6 +3342,9 @@ namespace Js`
`3308`	`3342`	`pDestObj = ArraySpeciesCreate(args[0], 0, scriptContext);`
`3309`	`3343`	`if (pDestObj)`
`3310`	`3344`	`{`
	`3345`	`+#if ENABLE_COPYONACCESS_ARRAY`
	`3346`	`+ JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(pDestObj);`
	`3347`	`+#endif`
`3311`	`3348`	`// Check the thing that species create made. If it's a native array that can't handle the source`
`3312`	`3349`	`// data, convert it. If it's a more conservative kind of array than the source data, indicate that`
`3313`	`3350`	`// so that the data will be converted on copy.`
`@@ -5863,13 +5900,19 @@ namespace Js`
`5863`	`5900`	`}`
`5864`	`5901`
`5865`	`5902`	`newArr = CreateNewArrayHelper(static_cast<uint32>(newLenT), isIntArray, isFloatArray, pArr, scriptContext);`
	`5903`	`+#if ENABLE_COPYONACCESS_ARRAY`
	`5904`	`+ JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(newArr);`
	`5905`	`+#endif`
`5866`	`5906`	`newObj = newArr;`
`5867`	`5907`	`}`
`5868`	`5908`	`else`
`5869`	`5909`	`{`
`5870`	`5910`	`// If the new object we created is an array, remember that as it will save us time setting properties in the object below`
`5871`	`5911`	`if (JavascriptArray::Is(newObj))`
`5872`	`5912`	`{`
	`5913`	`+#if ENABLE_COPYONACCESS_ARRAY`
	`5914`	`+ JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(newObj);`
	`5915`	`+#endif`
`5873`	`5916`	`newArr = JavascriptArray::FromVar(newObj);`
`5874`	`5917`	`}`
`5875`	`5918`	`}`
`@@ -6649,6 +6692,9 @@ namespace Js`
`6649`	`6692`	`// If the new object we created is an array, remember that as it will save us time setting properties in the object below`
`6650`	`6693`	`if (JavascriptArray::Is(newObj))`
`6651`	`6694`	`{`
	`6695`	`+#if ENABLE_COPYONACCESS_ARRAY`
	`6696`	`+ JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(newObj);`
	`6697`	`+#endif`
`6652`	`6698`	`newArr = JavascriptArray::FromVar(newObj);`
`6653`	`6699`	`}`
`6654`	`6700`	`}`
`@@ -6657,10 +6703,13 @@ namespace Js`
`6657`	`6703`	`{`
`6658`	`6704`	`pArr->GetArrayTypeAndConvert(&isIntArray, &isFloatArray);`
`6659`	`6705`	`newArr = CreateNewArrayHelper(deleteLen, isIntArray, isFloatArray, pArr, scriptContext);`
	`6706`	`+#if ENABLE_COPYONACCESS_ARRAY`
	`6707`	`+ JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(newArr);`
	`6708`	`+#endif`
`6660`	`6709`	`}`
`6661`	`6710`
`6662`	`6711`	`// If return object is a JavascriptArray, we can use all the array splice helpers`
`6663`		`- if (newArr && isBuiltinArrayCtor)`
	`6712`	`+ if (newArr && isBuiltinArrayCtor && len == pArr->length)`
`6664`	`6713`	`{`
`6665`	`6714`
`6666`	`6715`	`// Array has a single segment (need not start at 0) and splice start lies in the range`
`@@ -7151,6 +7200,9 @@ namespace Js`
`7151`	`7200`
`7152`	`7201`	`if (JavascriptArray::Is(pNewObj))`
`7153`	`7202`	`{`
	`7203`	`+#if ENABLE_COPYONACCESS_ARRAY`
	`7204`	`+ JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(pNewObj);`
	`7205`	`+#endif`
`7154`	`7206`	`pnewArr = JavascriptArray::FromVar(pNewObj);`
`7155`	`7207`	`}`
`7156`	`7208`
`@@ -8924,6 +8976,9 @@ namespace Js`
`8924`	`8976`	`// If the new object we created is an array, remember that as it will save us time setting properties in the object below`
`8925`	`8977`	`if (JavascriptArray::Is(newObj))`
`8926`	`8978`	`{`
	`8979`	`+#if ENABLE_COPYONACCESS_ARRAY`
	`8980`	`+ JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(newObj);`
	`8981`	`+#endif`
`8927`	`8982`	`newArr = JavascriptArray::FromVar(newObj);`
`8928`	`8983`	`}`
`8929`	`8984`	`}`
`@@ -9123,7 +9178,8 @@ namespace Js`
`9123`	`9178`	`}`
`9124`	`9179`
`9125`	`9180`	`// If the source object is an Array exotic object we should try to load the constructor property and use it to construct the return object.`
`9126`		`- RecyclableObject* newObj = ArraySpeciesCreate(obj, 0, scriptContext);`
	`9181`	`+ bool isBuiltinArrayCtor = true;`
	`9182`	`+ RecyclableObject* newObj = ArraySpeciesCreate(obj, 0, scriptContext, nullptr, nullptr, &isBuiltinArrayCtor);`
`9127`	`9183`	`JavascriptArray* newArr = nullptr;`
`9128`	`9184`
`9129`	`9185`	`if (newObj == nullptr)`
`@@ -9137,6 +9193,9 @@ namespace Js`
`9137`	`9193`	`// If the new object we created is an array, remember that as it will save us time setting properties in the object below`
`9138`	`9194`	`if (JavascriptArray::Is(newObj))`
`9139`	`9195`	`{`
	`9196`	`+#if ENABLE_COPYONACCESS_ARRAY`
	`9197`	`+ JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(newObj);`
	`9198`	`+#endif`
`9140`	`9199`	`newArr = JavascriptArray::FromVar(newObj);`
`9141`	`9200`	`}`
`9142`	`9201`	`}`
`@@ -9164,7 +9223,7 @@ namespace Js`
`9164`	`9223`	`if (JavascriptConversion::ToBoolean(selected, scriptContext))`
`9165`	`9224`	`{`
`9166`	`9225`	`// Try to fast path if the return object is an array`
`9167`		`- if (newArr)`
	`9226`	`+ if (newArr && isBuiltinArrayCtor)`
`9168`	`9227`	`{`
`9169`	`9228`	`newArr->DirectSetItemAt(i, element);`
`9170`	`9229`	`}`
`@@ -10041,6 +10100,7 @@ namespace Js`
`10041`	`10100`	`{`
`10042`	`10101`	`if (JavascriptArray::Is(arr))`
`10043`	`10102`	`{`
	`10103`	`+ arr = EnsureNonNativeArray(arr);`
`10044`	`10104`	`ArrayElementEnumerator e(arr, startIndex, limitIndex);`
`10045`	`10105`
`10046`	`10106`	`while(e.MoveNext<Var>())`
`@@ -10096,6 +10156,7 @@ namespace Js`
`10096`	`10156`	`{`
`10097`	`10157`	`if (JavascriptArray::Is(arr))`
`10098`	`10158`	`{`
	`10159`	`+ arr = EnsureNonNativeArray(arr);`
`10099`	`10160`	`ArrayElementEnumerator e(arr, startIndex, limitIndex);`
`10100`	`10161`
`10101`	`10162`	`while(e.MoveNext<Var>())`
`@@ -10849,6 +10910,9 @@ namespace Js`
`10849`	`10910`
`10850`	`10911`	`JavascriptArray JavascriptArray::EnsureNonNativeArray(JavascriptArray arr)`
`10851`	`10912`	`{`
	`10913`	`+#if ENABLE_COPYONACCESS_ARRAY`
	`10914`	`+ JavascriptLibrary::CheckAndConvertCopyOnAccessNativeIntArray<Var>(arr);`
	`10915`	`+#endif`
`10852`	`10916`	`if (JavascriptNativeIntArray::Is(arr))`
`10853`	`10917`	`{`
`10854`	`10918`	`arr = JavascriptNativeIntArray::ToVarArray((JavascriptNativeIntArray*)arr);`
`@@ -10931,23 +10995,6 @@ namespace Js`
`10931`	`10995`	`}`
`10932`	`10996`	`}`
`10933`	`10997`
`10934`		`- template<typename T>`
`10935`		`- void JavascriptArray::InternalFillFromPrototype(JavascriptArray dstArray, const T& dstIndex, JavascriptArray srcArray, uint32 start, uint32 end, uint32 count)`
`10936`		`- {`
`10937`		`- RecyclableObject* prototype = srcArray->GetPrototype();`
`10938`		`- while (start + count != end && JavascriptOperators::GetTypeId(prototype) != TypeIds_Null)`
`10939`		`- {`
`10940`		`- ForEachOwnMissingArrayIndexOfObject(srcArray, dstArray, prototype, start, end, dstIndex, [&](uint32 index, Var value) {`
`10941`		`- T n = dstIndex + (index - start);`
`10942`		`- dstArray->DirectSetItemAt(n, value);`
`10943`		`-`
`10944`		`- count++;`
`10945`		`- });`
`10946`		`-`
`10947`		`- prototype = prototype->GetPrototype();`
`10948`		`- }`
`10949`		`- }`
`10950`		`-`
`10951`	`10998`	`Var JavascriptArray::SpreadArrayArgs(Var arrayToSpread, const Js::AuxArray<uint32> spreadIndices, ScriptContext scriptContext)`
`10952`	`10999`	`{`
`10953`	`11000`	`// At this stage we have an array literal with some arguments to be spread.`
`@@ -11458,6 +11505,11 @@ namespace Js`
`11458`	`11505`	`{`
`11459`	`11506`	`if (!JavascriptOperators::GetProperty((RecyclableObject*)constructor, PropertyIds::_symbolSpecies, &constructor, scriptContext))`
`11460`	`11507`	`{`
	`11508`	`+ if (pIsBuiltinArrayCtor != nullptr)`
	`11509`	`+ {`
	`11510`	`+ *pIsBuiltinArrayCtor = false;`
	`11511`	`+ }`
	`11512`	`+`
`11461`	`11513`	`return nullptr;`
`11462`	`11514`	`}`
`11463`	`11515`	`if (constructor == scriptContext->GetLibrary()->GetNull())`
Original file line number	Diff line number	Diff line change
`@@ -910,7 +910,7 @@ namespace Js`
`910`	`910`
`911`	`911`	`try`
`912`	`912`	`{`
`913`		`- values->DirectSetItemAt(index, x);`
	`913`	`+ values->SetItem(index, x, PropertyOperation_None);`
`914`	`914`	`}`
`915`	`915`	`catch (JavascriptExceptionObject* e)`
`916`	`916`	`{`