chakra-core · chakrabot · May 8, 2018 · Apr 11, 2018 · Apr 11, 2018 · Apr 18, 2018
diff --git a/Build/NuGet/.pack-version b/Build/NuGet/.pack-version
@@ -1  1 @@
-1.8.3
 1.8.4
diff --git a/lib/Backend/BackwardPass.cpp b/lib/Backend/BackwardPass.cpp
@@ -4124,8  4124,9 @@ BackwardPass::UpdateArrayBailOutKind(IR::Instr *const instr)
 
     IR::BailOutKind includeBailOutKinds = IR::BailOutInvalid;
     if(!baseValueType.IsNotNativeArray() &&
-        (!baseValueType.IsLikelyNativeArray() || instr->GetSrc1()->IsVar()) &&
-        !currentBlock->noImplicitCallNativeArrayUses->IsEmpty())
         (!baseValueType.IsLikelyNativeArray() || !instr->GetSrc1()->IsInt32()) &&
         !currentBlock->noImplicitCallNativeArrayUses->IsEmpty() &&
         !(instr->GetBailOutKind() & IR::BailOutOnArrayAccessHelperCall))
     {
         // There is an upwards-exposed use of a native array. Since the array referenced by this instruction can be aliased,
         // this instruction needs to bail out if it converts the native array even if this array specifically is not
@@ -4231,6  4232,11 @@ BackwardPass::ProcessStackSymUse(StackSym * stackSym, BOOLEAN isNonByteCodeUse)
         return true;
     }
 
     if (this->DoMarkTempNumbers())
     {
         Assert((block->loop != nullptr) == block->tempNumberTracker->HasTempTransferDependencies());
         block->tempNumberTracker->ProcessUse(stackSym, this);
     }
     if (this->DoMarkTempObjects())
     {
         Assert((block->loop != nullptr) == block->tempObjectTracker->HasTempTransferDependencies());
@@ -4293,17  4299,7 @@ BackwardPass::ProcessSymUse(Sym * sym, bool isRegOpndUse, BOOLEAN isNonByteCodeU
         }
     }
 
-    StackSym * stackSym = sym->AsStackSym();
-    bool isUsed = ProcessStackSymUse(stackSym, isNonByteCodeUse);
-
-    if (!IsCollectionPass() && isRegOpndUse && this->DoMarkTempNumbers())
-    {
-        // Collect mark temp number information
-        Assert((block->loop != nullptr) == block->tempNumberTracker->HasTempTransferDependencies());
-        block->tempNumberTracker->ProcessUse(stackSym, this);
-    }
-
-    return isUsed;
     return ProcessStackSymUse(sym->AsStackSym(), isNonByteCodeUse);
 }
 
 bool

diff --git a/lib/Backend/GlobOpt.cpp b/lib/Backend/GlobOpt.cpp
@@ -6482,6  6482,8 @@ GlobOpt::OptConstPeep(IR::Instr *instr, IR::Opnd *constSrc, Value **pDstVal, Val
 
     instr->m_opcode = Js::OpCode::Ld_A;
 
     InvalidateInductionVariables(instr);
 
     return true;
 }
 
@@ -7088,16  7090,7 @@ GlobOpt::OptConstFoldUnary(
         }
     }
 
-    // If this is an induction variable, then treat it the way the prepass would have if it had seen
-    // the assignment and the resulting change to the value number, and mark it as indeterminate.
-    for (Loop * loop = this->currentBlock->loop; loop; loop = loop->parent)
-    {
-        InductionVariable *iv = nullptr;
-        if (loop->inductionVariables && loop->inductionVariables->TryGetReference(dstSym->m_id, &iv))
-        {
-            iv->SetChangeIsIndeterminate();
-        }
-    }
     InvalidateInductionVariables(instr);
 
     return true;
 }
@@ -12422,16  12415,7 @@ GlobOpt::OptConstFoldBinary(
         this->ToInt32Dst(instr, dst->AsRegOpnd(), this->currentBlock);
     }
 
-    // If this is an induction variable, then treat it the way the prepass would have if it had seen
-    // the assignment and the resulting change to the value number, and mark it as indeterminate.
-    for (Loop * loop = this->currentBlock->loop; loop; loop = loop->parent)
-    {
-        InductionVariable *iv = nullptr;
-        if (loop->inductionVariables && loop->inductionVariables->TryGetReference(dstSym->m_id, &iv))
-        {
-            iv->SetChangeIsIndeterminate();
-        }
-    }
     InvalidateInductionVariables(instr);
 
     return true;
 }

diff --git a/lib/Backend/GlobOpt.h b/lib/Backend/GlobOpt.h
@@ -685,6  685,7 @@ class GlobOpt
     void                    DetectUnknownChangesToInductionVariables(GlobOptBlockData *const blockData);
     void                    SetInductionVariableValueNumbers(GlobOptBlockData *const blockData);
     void                    FinalizeInductionVariables(Loop *const loop, GlobOptBlockData *const headerData);
     void                    InvalidateInductionVariables(IR::Instr * instr);
     enum class SymBoundType {OFFSET, VALUE, UNKNOWN};
     SymBoundType DetermineSymBoundOffsetOrValueRelativeToLandingPad(StackSym *const sym, const bool landingPadValueIsLowerBound, ValueInfo *const valueInfo, const IntBounds *const bounds, GlobOptBlockData *const landingPadGlobOptBlockData, int *const boundOffsetOrValueRef);
 

diff --git a/lib/Backend/GlobOptIntBounds.cpp b/lib/Backend/GlobOptIntBounds.cpp
@@ -1262,6  1262,30 @@ void GlobOpt::FinalizeInductionVariables(Loop *const loop, GlobOptBlockData *con
     }
 }
 
 void
 GlobOpt::InvalidateInductionVariables(IR::Instr * instr)
 {
     Assert(instr->GetDst() != nullptr && instr->GetDst()->IsRegOpnd());
 
     // Induction variables are always var syms.
     StackSym * dstSym = instr->GetDst()->AsRegOpnd()->m_sym;
     if (!dstSym->IsVar())
     {
         dstSym = dstSym->GetVarEquivSym(this->func);
     }
 
     // If this is an induction variable, then treat it the way the prepass would have if it had seen
     // the assignment and the resulting change to the value number, and mark it as indeterminate.
     for (Loop * loop = this->currentBlock->loop; loop; loop = loop->parent)
     {
         InductionVariable *iv = nullptr;
         if (loop->inductionVariables && loop->inductionVariables->TryGetReference(dstSym->m_id, &iv))
         {
             iv->SetChangeIsIndeterminate();
         }
     }
 }
 
 GlobOpt::SymBoundType GlobOpt::DetermineSymBoundOffsetOrValueRelativeToLandingPad(
     StackSym *const sym,
     const bool landingPadValueIsLowerBound,

diff --git a/lib/Backend/Inline.cpp b/lib/Backend/Inline.cpp
@@ -2089,11  2089,11 @@ Inline::InlineBuiltInFunction(IR::Instr *callInstr, const FunctionJITTimeInfo *
         callInstr->m_opcode = inlineCallOpCode;
         SetupInlineInstrForCallDirect(builtInFunctionId, callInstr, argoutInstr);
 
         WrapArgsOutWithCoerse(builtInFunctionId, callInstr);
 
         // Generate ByteCodeArgOutCaptures and move the ArgOut_A/ArgOut_A_Inline close to the call instruction
         callInstr->MoveArgs(/*generateByteCodeCapture*/ true);
 
-        WrapArgsOutWithCoerse(builtInFunctionId, callInstr);
-
         inlineBuiltInEndInstr = callInstr;
     }
     else