Implement GetLength Internal Command

Author: rhuanjl

lib/Backend/GlobOpt.cpp

@@ -2424,7 +2424,8 @@ void
 GlobOpt::TryReplaceLdLen(IR::Instr *& instr)
 {
     // Change LdLen on objects other than arrays, strings, and 'arguments' to LdFld. Otherwise, convert the SymOpnd to a RegOpnd here.
-    if (instr->m_opcode == Js::OpCode::LdLen_A && instr->GetSrc1() && instr->GetSrc1()->IsSymOpnd())
+    // Attempt the same optimisation for GetLength as long as the object is not a typed array
+    if ((instr->m_opcode == Js::OpCode::LdLen_A || instr->m_opcode == Js::OpCode::GetLength) && instr->GetSrc1() && instr->GetSrc1()->IsSymOpnd())
     {
         IR::SymOpnd * opnd = instr->GetSrc1()->AsSymOpnd();
         Sym *sym = opnd->m_sym;
@@ -2442,15 +2443,19 @@ GlobOpt::TryReplaceLdLen(IR::Instr *& instr)
             (CurrentBlockData()->argObjSyms && CurrentBlockData()->IsArgumentsOpnd(newopnd))
             )
         {
-            // We need to properly transfer over the information from the old operand, which is
-            // a SymOpnd, to the new one, which is a RegOpnd. Unfortunately, the types mean the
-            // normal copy methods won't work here, so we're going to directly copy data.
-            newopnd->SetIsJITOptimizedReg(opnd->GetIsJITOptimizedReg());
-            newopnd->SetValueType(objectValueInfo->Type());
-            newopnd->SetIsDead(opnd->GetIsDead());
-            instr->ReplaceSrc1(newopnd);
+            // GetLength Op can't be optimised for typed arrays
+            if (instr->m_opcode == Js::OpCode::LdLen_A || !objectValueInfo->IsLikelyTypedArray())
+            {
+                // We need to properly transfer over the information from the old operand, which is
+                // a SymOpnd, to the new one, which is a RegOpnd. Unfortunately, the types mean the
+                // normal copy methods won't work here, so we're going to directly copy data.
+                newopnd->SetIsJITOptimizedReg(opnd->GetIsJITOptimizedReg());
+                newopnd->SetValueType(objectValueInfo->Type());
+                newopnd->SetIsDead(opnd->GetIsDead());
+                instr->ReplaceSrc1(newopnd);
+            }
         }
-        else
+        else if(instr->m_opcode == Js::OpCode::LdLen_A) // retain the GetLength op when not optimising
         {
             // otherwise, change the instruction to an LdFld here.
             instr->m_opcode = Js::OpCode::LdFld;

lib/Backend/IRBuilder.cpp

@@ -1862,6 +1862,7 @@ IRBuilder::BuildReg2(Js::OpCode newOpcode, uint32 offset, Js::RegSlot R0, Js::Re
 
     case Js::OpCode::ToLength:
     case Js::OpCode::ToInteger:
+    case Js::OpCode::GetLength:
         dstOpnd->SetValueType(ValueType::Int.ToLikely());
         break;
 

lib/Backend/JnHelperMethodList.h

@@ -138,6 +138,7 @@ HELPERCALL_MATH(Op_MinInAnArray, Js::JavascriptMath::MinInAnArray, AttrCanThrow)
 
 HELPERCALLCHK(Op_ToInteger, Js::JavascriptOperators::OP_ToInteger, AttrCanThrow)
 HELPERCALLCHK(Op_ToLength, Js::JavascriptOperators::OP_ToLength, AttrCanThrow)
+HELPERCALLCHK(Op_GetIterableLength, Js::JavascriptOperators::OP_GetIterableLength, AttrCanThrow)
 HELPERCALLCHK(Op_ConvString, Js::JavascriptConversion::ToString, AttrCanThrow)
 HELPERCALLCHK(Op_ConvPropertyKey, Js::JavascriptOperators::OP_ToPropertyKey, AttrCanThrow)
 HELPERCALLCHK(Op_CoerseString, Js::JavascriptConversion::CoerseString, AttrCanThrow)

lib/Backend/Lower.cpp

@@ -3151,6 +3151,10 @@ Lowerer::LowerRange(IR::Instr *instrStart, IR::Instr *instrEnd, bool defaultDoFa
             this->LowerUnaryHelperMem(instr, IR::HelperOp_ToLength);
             break;
 
+        case Js::OpCode::GetLength:
+            this->LowerUnaryHelperMem(instr, IR::HelperOp_GetIterableLength);
+            break;
+
 #ifdef ENABLE_DEBUG_CONFIG_OPTIONS
         case Js::OpCode::GeneratorOutputBailInTraceLabel:
 #endif

lib/Parser/InternalCommands.h

@@ -10,5 +10,6 @@
 Command(Conv_Obj, 1)
 Command(ToInteger, 1)
 Command(ToLength, 1)
+Command(GetLength, 1)
 
 #undef Command

lib/Runtime/ByteCode/OpCodes.h

@@ -335,7 +335,8 @@ MACRO_EXTEND_WMS(       Conv_Str,           Reg2,           OpOpndHasImplicitCal
 MACRO_EXTEND_WMS(       Conv_Prop,          Reg2,           OpOpndHasImplicitCall|OpTempNumberSources|OpTempObjectSources|OpCanCSE|OpPostOpDbgBailOut)
 
 MACRO_EXTEND_WMS(       ToInteger,          Reg2,           OpSideEffect|OpTempNumberProducing|OpTempNumberTransfer|OpTempObjectSources|OpOpndHasImplicitCall|OpProducesNumber)
-MACRO_EXTEND_WMS(       ToLength,          Reg2,           OpSideEffect|OpTempNumberProducing|OpTempNumberTransfer|OpTempObjectSources|OpOpndHasImplicitCall|OpProducesNumber)
+MACRO_EXTEND_WMS(       ToLength,           Reg2,           OpSideEffect|OpTempNumberProducing|OpTempNumberTransfer|OpTempObjectSources|OpOpndHasImplicitCall|OpProducesNumber)
+MACRO_EXTEND_WMS(       GetLength,          Reg2,           OpSideEffect|OpTempNumberProducing|OpTempNumberTransfer|OpTempObjectSources|OpOpndHasImplicitCall|OpProducesNumber)
 
 // Conv_Obj:
 //      OpSideEffect - May throw exception on null/undefined.

lib/Runtime/Language/InterpreterHandler.inl

@@ -101,6 +101,7 @@ EXDEF2_WMS(A1toA1Mem,               Conv_Prop,                  JavascriptOperat
 EXDEF2_WMS(A1toA1Mem,               NewUnscopablesWrapperObject,JavascriptOperators::ToUnscopablesWrapperObject)
 EXDEF2_WMS(A1toA1Mem,               ToInteger,                  JavascriptOperators::OP_ToInteger)
 EXDEF2_WMS(A1toA1Mem,               ToLength,                   JavascriptOperators::OP_ToLength)
+EXDEF2_WMS(A1toA1Mem,               GetLength,                  JavascriptOperators::OP_GetIterableLength)
   DEF2_WMS(A1toA1Mem,               Conv_Num,                   JavascriptOperators::ToNumber)
   DEF2_WMS(A1toA1Mem,               Incr_A,                     JavascriptMath::Increment)
   DEF2_WMS(A1toA1Mem,               Decr_A,                     JavascriptMath::Decrement)

lib/Runtime/Language/JavascriptOperators.cpp

@@ -10510,6 +10510,33 @@ using namespace Js;
         JIT_HELPER_END(Op_ToLength);
     }
 
+    Var JavascriptOperators::OP_GetIterableLength(Var iterable, ScriptContext* scriptContext)
+    {
+        JIT_HELPER_REENTRANT_HEADER(Op_GetIterableLength);
+
+        if (!VarIs<TypedArrayBase>(iterable))	
+        {	
+            Var varLength = JavascriptOperators::OP_GetLength(iterable, scriptContext);
+            if (TaggedInt::Is(varLength))
+            {
+                return varLength;
+            }
+            return JavascriptNumber::ToVar(JavascriptConversion::ToLength(varLength, scriptContext), scriptContext);
+        }	
+        else	
+        {	
+            TypedArrayBase* typedArrayBase = UnsafeVarTo<TypedArrayBase>(iterable);	
+            if (typedArrayBase->IsDetachedBuffer())	 
+            {	
+                JavascriptError::ThrowTypeError(scriptContext, JSERR_DetachedTypedArray);	
+            }	
+
+            return JavascriptNumber::ToVar(typedArrayBase->GetLength(), scriptContext);
+        }	
+
+        JIT_HELPER_END(Op_GetIterableLength);
+    }
+
     Js::Var
     JavascriptOperators::BoxStackInstance(Js::Var instance, ScriptContext * scriptContext, bool allowStackFunction, bool deepCopy)
     {

lib/Runtime/Language/JavascriptOperators.h

@@ -655,6 +655,7 @@ namespace Js
 
         static Var OP_ToInteger(Var value, ScriptContext* scriptContext);
         static Var OP_ToLength(Var value, ScriptContext* scriptContext);
+        static Var OP_GetIterableLength(Var iterable, ScriptContext* scriptContext);
 
         template <typename T>
         static void * JitRecyclerAlloc(DECLSPEC_GUARD_OVERFLOW size_t size, Recycler* recycler)

lib/Runtime/Library/JsBuiltIn/JsBuiltIn.js

@@ -54,9 +54,8 @@
                     return { value: undefined, done: true };
                 } else {
                     let index = o.__$nextIndex$__;
-                    let len = @@ToLength(a.length);
 
-                    if (index < len) { // < comparison should happen instead of >= , because len can be NaN
+                    if (index < @@GetLength(a)) { // < comparison should happen instead of >= , because length can be NaN
                         let itemKind = o.__$kind$__;
 
                         o.__$nextIndex$__ = index + 1;