Merge branch 'master' into pr/arunetm/wasm.simd

arunetm-zz · arunetm-zz · commit 982f59e6f0c2 · 2017-12-09T22:19:23.000-08:00
diff --git a/lib/Backend/LinearScan.cpp b/lib/Backend/LinearScan.cpp
@@ -1775,8 +1775,12 @@ LinearScan::FillBailOutRecord(IR::Instr * instr)
             uint outParamCount = bailOutInfo->GetStartCallOutParamCount(i);
             startCallOutParamCounts[i] = outParamCount;
 #ifdef _M_IX86
-            uint orphanedArgCount = 0;
-            uint deadArgCount = 0;
+            if (bailOutInfo->startCallInfo[i].instr->m_opcode == Js::OpCode::StartCall)
+            {
+                // Deadcode might have eliminated the argouts and the call instruction due to a BailOnNoProfile after StartCall
+                // In such cases, StartCall opcode is not changed to LoweredStartCall, mark the StartCall instruction accordingly
+                bailOutInfo->startCallInfo[i].isOrphanedCall = true;
+            }
             // Only x86 has a progression of pushes of out args, with stack alignment.
             bool fDoStackAdjust = false;
             if (!bailOutInfo->inlinedStartCall->Test(i))
@@ -1871,11 +1875,6 @@ LinearScan::FillBailOutRecord(IR::Instr * instr)
                 StackSym * sym = bailOutInfo->argOutSyms[argOutSlot];
                 if (sym == nullptr)
                 {
-#ifdef _M_IX86
-#if DBG
-                    deadArgCount++;
-#endif
-#endif
                     // This can happen when instr with bailout occurs before all ArgOuts for current call instr are processed.
                     continue;
                 }
@@ -2027,10 +2026,7 @@ LinearScan::FillBailOutRecord(IR::Instr * instr)
 #endif
 #ifdef _M_IX86
                                     isOrphanedArgSlot->Set(outParamOffsetIndex);
-                                    bailOutInfo->startCallInfo[i].isOrphanedCall = true;
-#if DBG
-                                    orphanedArgCount++;
-#endif
+                                    Assert(bailOutInfo->startCallInfo[i].isOrphanedCall == true);
 #endif
                                 }
 #ifdef _M_IX86
@@ -2152,13 +2148,6 @@ LinearScan::FillBailOutRecord(IR::Instr * instr)
 #endif
                 }
             }
-#ifdef _M_IX86
-            uint liveArgCount = bailOutInfo->startCallInfo[i /*startCallCount*/].argCount - orphanedArgCount - deadArgCount;
-            if (liveArgCount == 0)
-            {
-                bailOutInfo->startCallInfo[i].isOrphanedCall = true;
-            }
-#endif
         }
 
         for (int i = startCallCount - 1; i >= 0; i--)
diff --git a/lib/Runtime/Base/FunctionBody.cpp b/lib/Runtime/Base/FunctionBody.cpp
@@ -5440,7 +5440,21 @@ namespace Js
         return ScopeType_WithScope;
     }
 
+    // ScopeSlots
+    bool ScopeSlots::IsDebuggerScopeSlotArray() 
+    {
+        return DebuggerScope::Is(slotArray[ScopeMetadataSlotIndex]);
+    }
+
     // DebuggerScope
+    bool DebuggerScope::Is(void* ptr)
+    {
+        if (!ptr)
+        {
+            return false;
+        }
+        return VirtualTableInfo<DebuggerScope>::HasVirtualTable(ptr);
+    }
 
     // Get the sibling for the current debugger scope.
     DebuggerScope * DebuggerScope::GetSiblingScope(RegSlot location, FunctionBody *functionBody)
diff --git a/lib/Runtime/Base/FunctionBody.h b/lib/Runtime/Base/FunctionBody.h
@@ -3582,20 +3582,17 @@ namespace Js
         {
         }
 
-        bool IsFunctionScopeSlotArray()
-        {
-            return FunctionInfo::Is(slotArray[ScopeMetadataSlotIndex]);
-        }
+        bool IsDebuggerScopeSlotArray();
 
         FunctionInfo* GetFunctionInfo()
         {
-            Assert(IsFunctionScopeSlotArray());
+            Assert(!IsDebuggerScopeSlotArray());
             return (FunctionInfo*)PointerValue(slotArray[ScopeMetadataSlotIndex]);
         }
 
         DebuggerScope* GetDebuggerScope()
         {
-            Assert(!IsFunctionScopeSlotArray());
+            Assert(IsDebuggerScopeSlotArray());
             return (DebuggerScope*)PointerValue(slotArray[ScopeMetadataSlotIndex]);
         }
 
@@ -3921,6 +3918,9 @@ namespace Js
     // Used to track with, catch, and block scopes for the debugger to determine context.
     class DebuggerScope
     {
+    protected:
+        DEFINE_VTABLE_CTOR_NOBASE(DebuggerScope);
+
     public:
         typedef JsUtil::List<DebuggerScopeProperty> DebuggerScopePropertyList;
 
@@ -3936,6 +3936,9 @@ namespace Js
             this->range.end = -1;
         }
 
+        virtual ~DebuggerScope() {}
+
+        static bool Is(void* ptr);
         DebuggerScope * GetSiblingScope(RegSlot location, FunctionBody *functionBody);
         void AddProperty(RegSlot location, Js::PropertyId propertyId, DebuggerScopePropertyFlags flags);
         bool GetPropertyIndex(Js::PropertyId propertyId, int& i);
@@ -3997,10 +4000,10 @@ namespace Js
         void EnsurePropertyListIsAllocated();
 
     private:
+        FieldNoBarrier(Recycler*) recycler;
         Field(DebuggerScope*) parentScope;
         Field(regex::Interval) range; // The start and end byte code writer offsets used when comparing where the debugger is currently stopped at (breakpoint location).
         Field(RegSlot) scopeLocation;
-        FieldNoBarrier(Recycler*) recycler;
     };
 
     class ScopeObjectChain
diff --git a/lib/Runtime/Base/FunctionInfo.cpp b/lib/Runtime/Base/FunctionInfo.cpp
@@ -29,15 +29,6 @@ namespace Js
 
     }
 
-    bool FunctionInfo::Is(void* ptr)
-    {
-        if(!ptr)
-        {
-            return false;
-        }
-        return VirtualTableInfo<FunctionInfo>::HasVirtualTable(ptr);
-    }
-
     void FunctionInfo::VerifyOriginalEntryPoint() const
     {
         Assert(!this->HasBody() || this->IsDeferredParseFunction() || this->IsDeferredDeserializeFunction() || this->GetFunctionProxy()->HasValidEntryPoint());
diff --git a/lib/Runtime/Base/FunctionInfo.h b/lib/Runtime/Base/FunctionInfo.h
@@ -9,13 +9,11 @@ namespace Js
     class ParseableFunctionInfo;
     class DeferDeserializeFunctionInfo;
 
-    class FunctionInfo: public FinalizableObject
+    class FunctionInfo
     {
         friend class RemoteFunctionBody;
-    protected:
-        DEFINE_VTABLE_CTOR_NOBASE(FunctionInfo);
-    public:
 
+    public:
         enum Attributes : uint32
         {
             None                           = 0x00000,
@@ -46,7 +44,6 @@ namespace Js
         FunctionInfo(JavascriptMethod entryPoint, _no_write_barrier_tag, Attributes attributes = None, LocalFunctionId functionId = Js::Constants::NoFunctionId, FunctionProxy* functionBodyImpl = nullptr);
         FunctionInfo(FunctionInfo& that); // Todo: (leish)(swb) find a way to prevent non-static initializer calling this ctor
 
-        static bool Is(void *ptr);
         static DWORD GetFunctionBodyImplOffset() { return offsetof(FunctionInfo, functionBodyImpl); }
         static BYTE GetOffsetOfFunctionProxy()
         {
@@ -116,16 +113,6 @@ namespace Js
         uint GetCompileCount() const { return compileCount; }
         void SetCompileCount(uint count) { compileCount = count; }
 
-        virtual void Finalize(bool isShutdown) override
-        {
-        }
-
-        virtual void Dispose(bool isShutdown) override
-        {
-        }
-
-        virtual void Mark(Recycler *recycler) override { AssertMsg(false, "Mark called on object that isn't TrackableObject"); }
-
         BOOL IsDeferredDeserializeFunction() const { return ((this->attributes & DeferredDeserialize) == DeferredDeserialize); }
         BOOL IsDeferredParseFunction() const { return ((this->attributes & DeferredParse) == DeferredParse); }
         void SetCapturesThis() { attributes = (Attributes)(attributes | Attributes::CapturesThis); }
diff --git a/lib/Runtime/Debug/DiagObjectModel.cpp b/lib/Runtime/Debug/DiagObjectModel.cpp
@@ -610,7 +610,7 @@ namespace Js
             ArenaAllocator *arena = pFrame->GetArena();
             ScopeSlots slotArray = GetSlotArray();
 
-            if (slotArray.IsFunctionScopeSlotArray())
+            if (!slotArray.IsDebuggerScopeSlotArray())
             {
                 DebuggerScope *formalScope = GetScopeWhenHaltAtFormals();
                 bool isInParamScope = IsInParamScope(formalScope, pFrame);
@@ -4083,15 +4083,15 @@ namespace Js
             // The scope is defined by a slot array object so grab the function body out to get the function name.
             ScopeSlots slotArray = ScopeSlots(reinterpret_cast<Var*>(instance));
 
-            if(slotArray.IsFunctionScopeSlotArray())
+            if(slotArray.IsDebuggerScopeSlotArray())
             {
-                Js::FunctionBody *functionBody = slotArray.GetFunctionInfo()->GetFunctionBody();
-                return functionBody->GetDisplayName();
+                // handling for block/catch scope
+                return _u("");
             }
             else
             {
-                // handling for block/catch scope
-                return _u("");
+                Js::FunctionBody *functionBody = slotArray.GetFunctionInfo()->GetFunctionBody();
+                return functionBody->GetDisplayName();
             }
         }
     }
diff --git a/lib/Runtime/Debug/TTSnapshotExtractor.cpp b/lib/Runtime/Debug/TTSnapshotExtractor.cpp
@@ -107,7 +107,7 @@ namespace TTD
                 slotInfo->Slots[j] = slots.Get(j);
             }
 
-            if(slots.IsFunctionScopeSlotArray())
+            if(!slots.IsDebuggerScopeSlotArray())
             {
                 Js::FunctionBody* fb = slots.GetFunctionInfo()->GetFunctionBody();
 
@@ -324,7 +324,7 @@ namespace TTD
                     {
                         Js::ScopeSlots slotArray = (Js::Var*)scope;
                         uint slotArrayCount = static_cast<uint>(slotArray.GetCount());
-                        if(slotArray.IsFunctionScopeSlotArray())
+                        if(!slotArray.IsDebuggerScopeSlotArray())
                         {
                             this->MarkFunctionBody(slotArray.GetFunctionInfo()->GetFunctionBody());
                         }
diff --git a/lib/Runtime/Library/ScriptFunction.cpp b/lib/Runtime/Library/ScriptFunction.cpp
@@ -578,13 +578,13 @@ namespace Js
                 uint slotArrayCount = static_cast<uint>(slotArray.GetCount());
 
                 //get the function body associated with the scope
-                if(slotArray.IsFunctionScopeSlotArray())
+                if (slotArray.IsDebuggerScopeSlotArray())
                 {
-                    rctxInfo->EnqueueNewFunctionBodyObject(this, slotArray.GetFunctionInfo()->GetFunctionBody(), scopePathString.GetStrValue());
+                    rctxInfo->AddWellKnownDebuggerScopePath(this, slotArray.GetDebuggerScope(), i);
                 }
                 else
                 {
-                    rctxInfo->AddWellKnownDebuggerScopePath(this, slotArray.GetDebuggerScope(), i);
+                    rctxInfo->EnqueueNewFunctionBodyObject(this, slotArray.GetFunctionInfo()->GetFunctionBody(), scopePathString.GetStrValue());
                 }
 
                 for(uint j = 0; j < slotArrayCount; j++)
diff --git a/lib/Runtime/Library/StackScriptFunction.cpp b/lib/Runtime/Library/StackScriptFunction.cpp
@@ -357,13 +357,17 @@ namespace Js
                     for (i = 0; i < frameDisplay->GetLength(); i++)
                     {
                         Var *slotArray = (Var*)frameDisplay->GetItem(i);
-                        ScopeSlots slots(slotArray);
-                        if (slots.IsFunctionScopeSlotArray())
+
+                        if (ScopeSlots::Is(slotArray))
                         {
-                            FunctionProxy *functionProxy = slots.GetFunctionInfo()->GetFunctionProxy();
-                            if (functionProxy->IsFunctionBody() && this->NeedBoxFrame(functionProxy->GetFunctionBody()))
+                            ScopeSlots slots(slotArray);
+                            if (!slots.IsDebuggerScopeSlotArray())
                             {
-                                break;
+                                FunctionProxy *functionProxy = slots.GetFunctionInfo()->GetFunctionProxy();
+                                if (functionProxy->IsFunctionBody() && this->NeedBoxFrame(functionProxy->GetFunctionBody()))
+                                {
+                                    break;
+                                }
                             }
                         }
                     }

Original file line number	Diff line number	Diff line change
`@@ -29,15 +29,6 @@ namespace Js`
`29`	`29`
`30`	`30`	`}`
`31`	`31`
`32`		`- bool FunctionInfo::Is(void* ptr)`
`33`		`- {`
`34`		`- if(!ptr)`
`35`		`- {`
`36`		`- return false;`
`37`		`- }`
`38`		`- return VirtualTableInfo<FunctionInfo>::HasVirtualTable(ptr);`
`39`		`- }`
`40`		`-`
`41`	`32`	`void FunctionInfo::VerifyOriginalEntryPoint() const`
`42`	`33`	`{`
`43`	`34`	`Assert(!this->HasBody() \|\| this->IsDeferredParseFunction() \|\| this->IsDeferredDeserializeFunction() \|\| this->GetFunctionProxy()->HasValidEntryPoint());`
Original file line number	Diff line number	Diff line change
`@@ -610,7 +610,7 @@ namespace Js`
`610`	`610`	`ArenaAllocator *arena = pFrame->GetArena();`
`611`	`611`	`ScopeSlots slotArray = GetSlotArray();`
`612`	`612`
`613`		`- if (slotArray.IsFunctionScopeSlotArray())`
	`613`	`+ if (!slotArray.IsDebuggerScopeSlotArray())`
`614`	`614`	`{`
`615`	`615`	`DebuggerScope *formalScope = GetScopeWhenHaltAtFormals();`
`616`	`616`	`bool isInParamScope = IsInParamScope(formalScope, pFrame);`
`@@ -4083,15 +4083,15 @@ namespace Js`
`4083`	`4083`	`// The scope is defined by a slot array object so grab the function body out to get the function name.`
`4084`	`4084`	`ScopeSlots slotArray = ScopeSlots(reinterpret_cast<Var*>(instance));`
`4085`	`4085`
`4086`		`- if(slotArray.IsFunctionScopeSlotArray())`
	`4086`	`+ if(slotArray.IsDebuggerScopeSlotArray())`
`4087`	`4087`	`{`
`4088`		`- Js::FunctionBody *functionBody = slotArray.GetFunctionInfo()->GetFunctionBody();`
`4089`		`- return functionBody->GetDisplayName();`
	`4088`	`+ // handling for block/catch scope`
	`4089`	`+ return _u("");`
`4090`	`4090`	`}`
`4091`	`4091`	`else`
`4092`	`4092`	`{`
`4093`		`- // handling for block/catch scope`
`4094`		`- return _u("");`
	`4093`	`+ Js::FunctionBody *functionBody = slotArray.GetFunctionInfo()->GetFunctionBody();`
	`4094`	`+ return functionBody->GetDisplayName();`
`4095`	`4095`	`}`
`4096`	`4096`	`}`
`4097`	`4097`	`}`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ namespace TTD`
`107`	`107`	`slotInfo->Slots[j] = slots.Get(j);`
`108`	`108`	`}`
`109`	`109`
`110`		`- if(slots.IsFunctionScopeSlotArray())`
	`110`	`+ if(!slots.IsDebuggerScopeSlotArray())`
`111`	`111`	`{`
`112`	`112`	`Js::FunctionBody* fb = slots.GetFunctionInfo()->GetFunctionBody();`
`113`	`113`
`@@ -324,7 +324,7 @@ namespace TTD`
`324`	`324`	`{`
`325`	`325`	`Js::ScopeSlots slotArray = (Js::Var*)scope;`
`326`	`326`	`uint slotArrayCount = static_cast<uint>(slotArray.GetCount());`
`327`		`- if(slotArray.IsFunctionScopeSlotArray())`
	`327`	`+ if(!slotArray.IsDebuggerScopeSlotArray())`
`328`	`328`	`{`
`329`	`329`	`this->MarkFunctionBody(slotArray.GetFunctionInfo()->GetFunctionBody());`
`330`	`330`	`}`
Original file line number	Diff line number	Diff line change
`@@ -578,13 +578,13 @@ namespace Js`
`578`	`578`	`uint slotArrayCount = static_cast<uint>(slotArray.GetCount());`
`579`	`579`
`580`	`580`	`//get the function body associated with the scope`
`581`		`- if(slotArray.IsFunctionScopeSlotArray())`
	`581`	`+ if (slotArray.IsDebuggerScopeSlotArray())`
`582`	`582`	`{`
`583`		`- rctxInfo->EnqueueNewFunctionBodyObject(this, slotArray.GetFunctionInfo()->GetFunctionBody(), scopePathString.GetStrValue());`
	`583`	`+ rctxInfo->AddWellKnownDebuggerScopePath(this, slotArray.GetDebuggerScope(), i);`
`584`	`584`	`}`
`585`	`585`	`else`
`586`	`586`	`{`
`587`		`- rctxInfo->AddWellKnownDebuggerScopePath(this, slotArray.GetDebuggerScope(), i);`
	`587`	`+ rctxInfo->EnqueueNewFunctionBodyObject(this, slotArray.GetFunctionInfo()->GetFunctionBody(), scopePathString.GetStrValue());`
`588`	`588`	`}`
`589`	`589`
`590`	`590`	`for(uint j = 0; j < slotArrayCount; j++)`
Original file line number	Diff line number	Diff line change
`@@ -357,13 +357,17 @@ namespace Js`
`357`	`357`	`for (i = 0; i < frameDisplay->GetLength(); i++)`
`358`	`358`	`{`
`359`	`359`	`Var slotArray = (Var)frameDisplay->GetItem(i);`
`360`		`- ScopeSlots slots(slotArray);`
`361`		`- if (slots.IsFunctionScopeSlotArray())`
	`360`	`+`
	`361`	`+ if (ScopeSlots::Is(slotArray))`
`362`	`362`	`{`
`363`		`- FunctionProxy *functionProxy = slots.GetFunctionInfo()->GetFunctionProxy();`
`364`		`- if (functionProxy->IsFunctionBody() && this->NeedBoxFrame(functionProxy->GetFunctionBody()))`
	`363`	`+ ScopeSlots slots(slotArray);`
	`364`	`+ if (!slots.IsDebuggerScopeSlotArray())`
`365`	`365`	`{`
`366`		`- break;`
	`366`	`+ FunctionProxy *functionProxy = slots.GetFunctionInfo()->GetFunctionProxy();`
	`367`	`+ if (functionProxy->IsFunctionBody() && this->NeedBoxFrame(functionProxy->GetFunctionBody()))`
	`368`	`+ {`
	`369`	`+ break;`
	`370`	`+ }`
`367`	`371`	`}`
`368`	`372`	`}`
`369`	`373`	`}`