[MERGE #1320 @jianchun] Merge remote-tracking branch 'origin/master' into linux

Merge pull request #1320 from jianchun:filinux

Author: Jianchun Xu

bin/ch/WScriptJsrt.cpp

@@ -3,7 +3,6 @@
 // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
 //-------------------------------------------------------------------------------------------------------
 #include "stdafx.h"
-#include <string>
 
 MessageQueue* WScriptJsrt::messageQueue = nullptr;
 std::map<std::string, JsModuleRecord>  WScriptJsrt::moduleRecordMap;
@@ -1046,4 +1045,3 @@ JsErrorCode WScriptJsrt::NotifyModuleReadyCallback(_In_opt_ JsModuleRecord refer
     }
     return JsNoError;
 }
-

bin/ch/stdafx.h

@@ -26,6 +26,7 @@
 #define ENABLE_TEST_HOOKS 1
 #include "CommonDefines.h"
 #include <map>
+#include <string>
 
 #ifdef _WIN32
 #include <windows.h>

lib/Backend/GlobOpt.cpp

@@ -1061,9 +1061,6 @@ GlobOpt::MergePredBlocksValueMaps(BasicBlock *block)
         this->KillAllObjectTypes();
     }
 
-    this->blockData.capturedArgs = JitAnew(this->alloc, BVSparse<JitArenaAllocator>, this->alloc);
-    this->blockData.changedSyms = JitAnew(this->alloc, BVSparse<JitArenaAllocator>, this->alloc);
-
     this->CopyBlockData(&block->globOptData, &this->blockData);
 
     if (this->IsLoopPrePass())
@@ -1513,7 +1510,6 @@ GlobOpt::NulloutBlockData(GlobOptBlockData *data)
     data->stackLiteralInitFldDataMap = nullptr;
 
     data->capturedValues = nullptr;
-    data->capturedArgs = nullptr;
     data->changedSyms = nullptr;
 
     data->OnDataUnreferenced();
@@ -1562,6 +1558,8 @@ GlobOpt::InitBlockData()
 
     data->stackLiteralInitFldDataMap = nullptr;
 
+    data->changedSyms = JitAnew(alloc, BVSparse<JitArenaAllocator>, alloc);
+
     data->OnDataInitialized(alloc);
 }
 
@@ -1610,9 +1608,7 @@ GlobOpt::ReuseBlockData(GlobOptBlockData *toData, GlobOptBlockData *fromData)
 
     toData->stackLiteralInitFldDataMap = fromData->stackLiteralInitFldDataMap;
 
-    toData->capturedArgs = fromData->capturedArgs;
     toData->changedSyms = fromData->changedSyms;
-    toData->capturedArgs->ClearAll();
     toData->changedSyms->ClearAll();
 
     toData->OnDataReused(fromData);
@@ -1651,9 +1647,7 @@ GlobOpt::CopyBlockData(GlobOptBlockData *toData, GlobOptBlockData *fromData)
     toData->inlinedArgOutCount = fromData->inlinedArgOutCount;
     toData->hasCSECandidates = fromData->hasCSECandidates;
 
-    toData->capturedArgs = fromData->capturedArgs;
     toData->changedSyms = fromData->changedSyms;
-    toData->capturedArgs->ClearAll();
     toData->changedSyms->ClearAll();
 
     toData->stackLiteralInitFldDataMap = fromData->stackLiteralInitFldDataMap;
@@ -1769,6 +1763,9 @@ void GlobOpt::CloneBlockData(BasicBlock *const toBlock, GlobOptBlockData *const
         toData->stackLiteralInitFldDataMap = nullptr;
     }
 
+    toData->changedSyms = JitAnew(alloc, BVSparse<JitArenaAllocator>, alloc);
+    toData->changedSyms->Copy(fromData->changedSyms);
+
     Assert(fromData->HasData());
     toData->OnDataInitialized(alloc);
 }
@@ -1829,6 +1826,60 @@ GlobOpt::CloneValues(BasicBlock *const toBlock, GlobOptBlockData *toData, GlobOp
     ProcessValueKills(toBlock, toData);
 }
 
+template <typename CapturedList, typename CapturedItemsAreEqual>
+void
+GlobOpt::MergeCapturedValues(
+    GlobOptBlockData * toData,
+    SListBase<CapturedList> * toList,
+    SListBase<CapturedList> * fromList,
+    CapturedItemsAreEqual itemsAreEqual)
+{
+    SListBase<CapturedList>::Iterator iterTo(toList);
+    SListBase<CapturedList>::Iterator iterFrom(fromList);
+    bool hasTo = iterTo.Next();
+    bool hasFrom = fromList == nullptr ? false : iterFrom.Next();
+
+    // to be conservative, only copy the captured value for common sym Ids
+    // in from and to CapturedList, mark all non-common sym Ids for re-capture
+    while (hasFrom && hasTo)
+    {
+        Sym * symFrom = iterFrom.Data().Key();
+        Sym * symTo = iterTo.Data().Key();
+
+        if (symFrom->m_id < symTo->m_id) 
+        {
+            toData->changedSyms->Set(symFrom->m_id);
+            hasFrom = iterFrom.Next();
+        }
+        else if(symFrom->m_id > symTo->m_id)
+        {
+            toData->changedSyms->Set(symTo->m_id);
+            hasTo = iterTo.Next();
+        }
+        else
+        {
+            if (!itemsAreEqual(&iterFrom.Data(), &iterTo.Data()))
+            {
+                toData->changedSyms->Set(symTo->m_id);
+            }
+
+            hasFrom = iterFrom.Next();
+            hasTo = iterTo.Next();
+        }
+    }
+    bool hasRemain = hasFrom || hasTo;
+    if (hasRemain)
+    {
+        SListBase<CapturedList>::Iterator iterRemain(hasFrom ? iterFrom : iterTo);
+        do
+        {
+            Sym * symRemain = iterRemain.Data().Key();
+            toData->changedSyms->Set(symRemain->m_id);
+            hasRemain = iterRemain.Next();
+        } while (hasRemain);
+    }
+}
+
 void
 GlobOpt::MergeBlockData(
     GlobOptBlockData *toData,
@@ -1856,6 +1907,39 @@ GlobOpt::MergeBlockData(
     toData->isTempSrc->And(fromData->isTempSrc);
     toData->hasCSECandidates &= fromData->hasCSECandidates;
 
+    if (toData->capturedValues == nullptr)
+    {
+        toData->capturedValues = fromData->capturedValues;
+        toData->changedSyms->Or(fromData->changedSyms);
+    }
+    else
+    {
+        MergeCapturedValues(
+            toData,
+            &toData->capturedValues->constantValues,
+            fromData->capturedValues == nullptr ? nullptr : &fromData->capturedValues->constantValues,
+            [&](ConstantStackSymValue * symValueFrom, ConstantStackSymValue * symValueTo)
+            {
+                return symValueFrom->Value().IsEqual(symValueTo->Value());
+            });
+
+        MergeCapturedValues(
+            toData,
+            &toData->capturedValues->copyPropSyms,
+            fromData->capturedValues == nullptr ? nullptr : &fromData->capturedValues->copyPropSyms,
+            [&](CopyPropSyms * copyPropSymFrom, CopyPropSyms * copyPropSymTo)
+            {
+                if (copyPropSymFrom->Value()->m_id == copyPropSymTo->Value()->m_id)
+                {
+                    Value * val = FindValue(copyPropSymFrom->Key());
+                    Value * copyVal = FindValue(copyPropSymTo->Key());
+                    return (val != nullptr && copyVal != nullptr &&
+                        val->GetValueNumber() == copyVal->GetValueNumber());
+                }
+                return false;
+            });
+    }
+
     if (fromData->maybeWrittenTypeSyms)
     {
         if (toData->maybeWrittenTypeSyms == nullptr)
@@ -2269,6 +2353,8 @@ GlobOpt::DeleteBlockData(GlobOptBlockData *data)
         JitAdelete(alloc, data->stackLiteralInitFldDataMap);
     }
 
+    JitAdelete(alloc, data->changedSyms);
+
     data->OnDataDeleted();
 }
 
@@ -5080,7 +5166,6 @@ GlobOpt::OptInstr(IR::Instr *&instr, bool* isInstrRemoved)
 
     if (instr->HasBailOutInfo() && !this->IsLoopPrePass())
     {
-        this->currentBlock->globOptData.capturedArgs->ClearAll();
         this->currentBlock->globOptData.changedSyms->ClearAll();
         this->currentBlock->globOptData.capturedValues = 
             this->currentBlock->globOptData.capturedValuesCandidate;
@@ -6477,7 +6562,7 @@ GlobOpt::CopyPropReplaceOpnd(IR::Instr * instr, IR::Opnd * opnd, StackSym * copy
                 // We're creating a copy of this operand to be reused in the same spot in the flow, so we can copy all
                 // flow sensitive fields.  However, we will do only a type check here (no property access) and only for
                 // the sake of downstream instructions, so the flags pertaining to this property access are irrelevant.
-                IR::PropertySymOpnd* checkObjTypeOpnd = propertySymOpnd->CopyForTypeCheckOnly(instr->m_func);
+                IR::PropertySymOpnd* checkObjTypeOpnd = CreateOpndForTypeCheckOnly(propertySymOpnd, instr->m_func);
                 IR::Instr* checkObjTypeInstr = IR::Instr::New(Js::OpCode::CheckObjType, instr->m_func);
                 checkObjTypeInstr->SetSrc1(checkObjTypeOpnd);
                 checkObjTypeInstr->SetByteCodeOffset(instr);
@@ -7097,9 +7182,9 @@ GlobOpt::SetSymStoreDirect(ValueInfo * valueInfo, Sym * sym)
 {
     Sym * prevSymStore = valueInfo->GetSymStore();
     if (prevSymStore && prevSymStore->IsStackSym() &&
-        prevSymStore->AsStackSym()->HasByteCodeRegSlot() &&
-        this->blockData.changedSyms)
+        prevSymStore->AsStackSym()->HasByteCodeRegSlot())
     {
+        Assert(this->blockData.changedSyms != nullptr);
         this->blockData.changedSyms->Set(prevSymStore->m_id);
     }
     valueInfo->SetSymStore(sym);
@@ -7122,8 +7207,9 @@ GlobOpt::SetValue(GlobOptBlockData *blockData, Value *val, Sym * sym)
     else
     {
         SetValueToHashTable(blockData->symToValueMap, val, sym);
-        if (blockData->changedSyms && isStackSym && sym->AsStackSym()->HasByteCodeRegSlot())
+        if (isStackSym && sym->AsStackSym()->HasByteCodeRegSlot())
         {
+            Assert(blockData->changedSyms != nullptr);
             blockData->changedSyms->Set(sym->m_id);
         }
     }
@@ -21609,4 +21695,4 @@ ValueNumber JsUtil::ValueToKey<ValueNumber, Value *>::ToKey(Value *const &value)
 {
     Assert(value);
     return value->GetValueNumber();
-}
+}

lib/Backend/GlobOpt.h

@@ -954,7 +954,6 @@ class GlobOptBlockData
         callSequence(nullptr),
         capturedValuesCandidate(nullptr),
         capturedValues(nullptr),
-        capturedArgs(nullptr),
         changedSyms(nullptr),
         hasCSECandidates(false),
         curFunc(func),
@@ -1008,7 +1007,6 @@ class GlobOptBlockData
 
     CapturedValues *                        capturedValuesCandidate;
     CapturedValues *                        capturedValues;
-    BVSparse<JitArenaAllocator> *           capturedArgs;
     BVSparse<JitArenaAllocator> *           changedSyms;
 
     uint                                    inlinedArgOutCount;
@@ -1306,6 +1304,9 @@ class GlobOpt
     void                    CloneBlockData(BasicBlock *const toBlock, BasicBlock *const fromBlock);
     void                    CloneBlockData(BasicBlock *const toBlock, GlobOptBlockData *const toData, BasicBlock *const fromBlock);
     void                    CloneValues(BasicBlock *const toBlock, GlobOptBlockData *toData, GlobOptBlockData *fromData);
+
+    template <typename CapturedList, typename CapturedItemsAreEqual>
+    void                    MergeCapturedValues(GlobOptBlockData * toData, SListBase<CapturedList> * toList, SListBase<CapturedList> * fromList, CapturedItemsAreEqual itemsAreEqual);
     void                    MergeBlockData(GlobOptBlockData *toData, BasicBlock *toBlock, BasicBlock *fromBlock, BVSparse<JitArenaAllocator> *const symsRequiringCompensation, BVSparse<JitArenaAllocator> *const symsCreatedForMerge, bool forceTypeSpecOnLoopHeader);
     void                    DeleteBlockData(GlobOptBlockData *data);
     IR::Instr *             OptInstr(IR::Instr *&instr, bool* isInstrCleared);
@@ -1316,6 +1317,7 @@ class GlobOpt
     bool                    OptTagChecks(IR::Instr *instr);
     void                    TryOptimizeInstrWithFixedDataProperty(IR::Instr * * const pInstr);
     bool                    CheckIfPropOpEmitsTypeCheck(IR::Instr *instr, IR::PropertySymOpnd *opnd);
+    IR::PropertySymOpnd *   CreateOpndForTypeCheckOnly(IR::PropertySymOpnd* opnd, Func* func);
     bool                    FinishOptPropOp(IR::Instr *instr, IR::PropertySymOpnd *opnd, BasicBlock* block = nullptr, bool updateExistingValue = false, bool* emitsTypeCheckOut = nullptr, bool* changesTypeValueOut = nullptr);
     void                    FinishOptHoistedPropOps(Loop * loop);
     IR::Instr *             SetTypeCheckBailOut(IR::Opnd *opnd, IR::Instr *instr, BailOutInfo *bailOutInfo);
@@ -1643,6 +1645,14 @@ class GlobOpt
     static void             TrackByteCodeSymUsed(IR::RegOpnd * opnd, BVSparse<JitArenaAllocator> * instrByteCodeStackSymUsed);
     static void             TrackByteCodeSymUsed(StackSym * sym, BVSparse<JitArenaAllocator> * instrByteCodeStackSymUsed);
     void                    CaptureValues(BasicBlock *block, BailOutInfo * bailOutInfo);
+    void                    GlobOpt::CaptureValuesFromScratch(
+                                BasicBlock * block,
+                                SListBase<ConstantStackSymValue>::EditingIterator & bailOutConstValuesIter,
+                                SListBase<CopyPropSyms>::EditingIterator & bailOutCopyPropIter);
+    void                    GlobOpt::CaptureValuesIncremental(
+                                BasicBlock * block,
+                                SListBase<ConstantStackSymValue>::EditingIterator & bailOutConstValuesIter,
+                                SListBase<CopyPropSyms>::EditingIterator & bailOutCopyPropIter);
     void                    CaptureCopyPropValue(BasicBlock * block, Sym * sym, Value * val, SListBase<CopyPropSyms>::EditingIterator & bailOutCopySymsIter);
     void                    CaptureArguments(BasicBlock *block, BailOutInfo * bailOutInfo, JitArenaAllocator *allocator);
     void                    CaptureByteCodeSymUses(IR::Instr * instr);