swb: fix build failures on Windows

Jianchun Xu · Jianchun Xu · commit 589e7432b38c · 2016-11-11T15:18:24.000-08:00
diff --git a/lib/Backend/CodeGenNumberAllocator.h b/lib/Backend/CodeGenNumberAllocator.h
@@ -100,8 +100,8 @@ class CodeGenNumberThreadAllocator
     bool hasNewChunkBlock;
     struct BlockRecord
     {
-        BlockRecord(__in_ecount_pagesize char * blockAddress, PageSegment * segment) 
-            : blockAddress(blockAddress), segment(segment) 
+        BlockRecord(__in_ecount_pagesize char * blockAddress, PageSegment * segment)
+            : blockAddress(blockAddress), segment(segment)
         {
         }
         char * blockAddress;
@@ -114,19 +114,19 @@ class CodeGenNumberThreadAllocator
     size_t pendingIntegrationChunkSegmentPageCount;
     DListBase<PageSegment> pendingIntegrationNumberSegment;
     DListBase<PageSegment> pendingIntegrationChunkSegment;
-    SListBase<BlockRecord> pendingIntegrationNumberBlock;
-    SListBase<BlockRecord> pendingIntegrationChunkBlock;
+    SListBase<BlockRecord, NoThrowHeapAllocator> pendingIntegrationNumberBlock;
+    SListBase<BlockRecord, NoThrowHeapAllocator> pendingIntegrationChunkBlock;
 
     // These are finished pages during the code gen of the current function
     // We can't integrate them until the code gen is done for the function,
     // because the references for the number is not set on the entry point yet.
-    SListBase<BlockRecord> pendingFlushNumberBlock;
-    SListBase<BlockRecord> pendingFlushChunkBlock;
+    SListBase<BlockRecord, NoThrowHeapAllocator> pendingFlushNumberBlock;
+    SListBase<BlockRecord, NoThrowHeapAllocator> pendingFlushChunkBlock;
 
     // Numbers are reference by the chunks, so we need to wait until that is ready
     // to be flushed before the number page can be flushed. Otherwise, we might have number
     // integrated back to the GC, but the chunk hasn't yet, thus GC won't see the reference.
-    SListBase<BlockRecord> pendingReferenceNumberBlock;
+    SListBase<BlockRecord, NoThrowHeapAllocator> pendingReferenceNumberBlock;
 };
 
 class CodeGenNumberAllocator
diff --git a/lib/Backend/PageAllocatorPool.cpp b/lib/Backend/PageAllocatorPool.cpp
@@ -86,7 +86,7 @@ PageAllocator* PageAllocatorPool::GetPageAllocator()
 void PageAllocatorPool::ReturnPageAllocator(PageAllocator* pageAllocator)
 {
     AutoCriticalSection autoCS(&cs);
-    if (!this->pageAllocators.PrependNoThrow(&HeapAllocator::Instance, pageAllocator))
+    if (!this->pageAllocators.PrependNoThrow(&NoThrowHeapAllocator::Instance, pageAllocator))
     {
         HeapDelete(pageAllocator);
     }
diff --git a/lib/Common/Memory/HeapAllocator.h b/lib/Common/Memory/HeapAllocator.h
@@ -182,9 +182,21 @@ class NoThrowHeapAllocator
 {
 public:
     static const bool FakeZeroLengthArray = false;
+
     char * Alloc(DECLSPEC_GUARD_OVERFLOW size_t byteSize);
     char * AllocZero(DECLSPEC_GUARD_OVERFLOW size_t byteSize);
     void Free(void * buffer, size_t byteSize);
+
+    char * NoThrowAlloc(DECLSPEC_GUARD_OVERFLOW size_t byteSize)
+    {
+        return Alloc(byteSize);
+    }
+
+    char * NoThrowAllocZero(DECLSPEC_GUARD_OVERFLOW size_t byteSize)
+    {
+        return AllocZero(byteSize);
+    }
+
     static NoThrowHeapAllocator Instance;
 
 #ifdef TRACK_ALLOC
diff --git a/lib/Common/Memory/PageAllocator.cpp b/lib/Common/Memory/PageAllocator.cpp
@@ -62,9 +62,9 @@ SegmentBase<T>::~SegmentBase()
         {
             RecyclerWriteBarrierManager::ToggleBarrier(this->address, this->segmentPageCount * AutoSystemInfo::PageSize, false);
         }
-#endif
 #endif
         RecyclerWriteBarrierManager::OnSegmentFree(this->address, this->segmentPageCount);
+#endif
     }
 }
 
@@ -343,7 +343,7 @@ PageSegmentBase<T>::AllocPages(uint pageCount)
                 MemoryOperationLastError::RecordLastError();
                 if (this->GetAllocator()->processHandle == GetCurrentProcess())
                 {
-                    Assert(false);                    
+                    Assert(false);
                 }
                 return nullptr;
             }
diff --git a/lib/Common/Memory/RecyclerWriteBarrierManager.cpp b/lib/Common/Memory/RecyclerWriteBarrierManager.cpp
@@ -21,7 +21,7 @@
 
 #ifdef RECYCLER_WRITE_BARRIER
 #if ENABLE_DEBUG_CONFIG_OPTIONS
-namespace Memory 
+namespace Memory
 {
     FN_VerifyIsNotBarrierAddress* g_verifyIsNotBarrierAddress = nullptr;
 }
@@ -377,11 +377,11 @@ RecyclerWriteBarrierManager::IsBarrierAddress(void * address)
 bool
 RecyclerWriteBarrierManager::IsBarrierAddress(uintptr_t index)
 {
-    return cardTable[index] & WRITE_BARRIER_PAGE_BIT;
+    return (cardTable[index] & WRITE_BARRIER_PAGE_BIT) == WRITE_BARRIER_PAGE_BIT;
 }
 
-// TODO: SWB, looks we didn't initialize card table for heap allocation. 
-// we didn't hit such issue because we are not allocating write barrier 
+// TODO: SWB, looks we didn't initialize card table for heap allocation.
+// we didn't hit such issue because we are not allocating write barrier
 // annotated struct with heap today.
 // after SWB is widely enabled and if an annotated structure can be allocated
 // with both Heap and Recycler/Arena we'll capture the issue
@@ -406,10 +406,10 @@ RecyclerWriteBarrierManager::VerifyIsBarrierAddress(void * address, size_t bytes
         uintptr_t startIndex = GetCardTableIndex(address);
         char * endAddress = (char *)Math::Align<INT_PTR>((INT_PTR)((char *)address + bytes), s_WriteBarrierPageSize);
         uintptr_t endIndex = GetCardTableIndex(endAddress);
-        do 
+        do
         {
             // no need to check if cardTable is commited or not, if it's not commited it'll AV instead of assertion
-            if (!IsBarrierAddress(startIndex)) 
+            if (!IsBarrierAddress(startIndex))
             {
                 Js::Throw::FatalInternalError();
             }
@@ -425,11 +425,11 @@ RecyclerWriteBarrierManager::VerifyIsNotBarrierAddress(void * address, size_t by
         uintptr_t startIndex = GetCardTableIndex(address);
         char * endAddress = (char *)Math::Align<INT_PTR>((INT_PTR)((char *)address + bytes), s_WriteBarrierPageSize);
         uintptr_t endIndex = GetCardTableIndex(endAddress);
-        do 
+        do
         {
             if(IsCardTableCommited(startIndex))
             {
-                if (IsBarrierAddress(startIndex)) 
+                if (IsBarrierAddress(startIndex))
                 {
                     Js::Throw::FatalInternalError();
                 }
@@ -439,13 +439,13 @@ RecyclerWriteBarrierManager::VerifyIsNotBarrierAddress(void * address, size_t by
     }
 }
 
-bool 
+bool
 RecyclerWriteBarrierManager::Initialize()
 {
     g_verifyIsNotBarrierAddress = RecyclerWriteBarrierManager::VerifyIsNotBarrierAddress;
     return true;
 }
-#endif 
+#endif
 
 uintptr_t
 RecyclerWriteBarrierManager::GetCardTableIndex(void *address)
diff --git a/lib/JITServer/JITServer.h b/lib/JITServer/JITServer.h
@@ -12,7 +12,7 @@ class ServerContextManager
     static void CleanUpForProcess(HANDLE hProcess);
 
     static void RegisterScriptContext(ServerScriptContext* scriptContext);
-    static void UnRegisterScriptContext(ServerScriptContext* scriptContext);    
+    static void UnRegisterScriptContext(ServerScriptContext* scriptContext);
 
     static bool CheckLivenessAndAddref(ServerScriptContext* context);
     static bool CheckLivenessAndAddref(ServerThreadContext* context);
@@ -44,19 +44,19 @@ class ServerContextManager
         T* context;
         union {
             DWORD runtimeProcId;
-            ServerThreadContext* threadCtx; 
+            ServerThreadContext* threadCtx;
         };
         StackBackTrace* stack;
     };
 
     static void RecordCloseContext(ServerThreadContext* context)
     {
         auto record = HeapNewNoThrow(ClosedContextEntry<ServerThreadContext>, context);
-        if (record) 
+        if (record)
         {
             record->runtimeProcId = context->GetRuntimePid();
         }
-        ClosedThreadContextList.PrependNoThrow(&HeapAllocator::Instance, record);
+        ClosedThreadContextList.PrependNoThrow(&NoThrowHeapAllocator::Instance, record);
     }
     static void RecordCloseContext(ServerScriptContext* context)
     {
@@ -65,7 +65,7 @@ class ServerContextManager
         {
             record->threadCtx = context->GetThreadContext();
         }
-        ClosedScriptContextList.PrependNoThrow(&HeapAllocator::Instance, record);
+        ClosedScriptContextList.PrependNoThrow(&NoThrowHeapAllocator::Instance, record);
     }
 
     static SList<ClosedContextEntry<ServerThreadContext>*, NoThrowHeapAllocator> ClosedThreadContextList;
diff --git a/lib/Runtime/Base/ThreadContext.cpp b/lib/Runtime/Base/ThreadContext.cpp
@@ -4130,7 +4130,7 @@ void ThreadContext::RemoveExternalWeakReferenceCache(ExternalWeakReferenceCache
 
 void ThreadContext::MarkExternalWeakReferencedObjects(bool inPartialCollect)
 {
-    SListBase<ExternalWeakReferenceCache *>::Iterator iteratorWeakRefCache(&this->externalWeakReferenceCacheList);
+    SListBase<ExternalWeakReferenceCache *, HeapAllocator>::Iterator iteratorWeakRefCache(&this->externalWeakReferenceCacheList);
     while (iteratorWeakRefCache.Next())
     {
         iteratorWeakRefCache.Data()->MarkNow(recycler, inPartialCollect);
@@ -4139,7 +4139,7 @@ void ThreadContext::MarkExternalWeakReferencedObjects(bool inPartialCollect)
 
 void ThreadContext::ResolveExternalWeakReferencedObjects()
 {
-    SListBase<ExternalWeakReferenceCache *>::Iterator iteratorWeakRefCache(&this->externalWeakReferenceCacheList);
+    SListBase<ExternalWeakReferenceCache *, HeapAllocator>::Iterator iteratorWeakRefCache(&this->externalWeakReferenceCacheList);
     while (iteratorWeakRefCache.Next())
     {
         iteratorWeakRefCache.Data()->ResolveNow(recycler);
diff --git a/lib/Runtime/Base/ThreadContext.h b/lib/Runtime/Base/ThreadContext.h
@@ -654,7 +654,7 @@ class ThreadContext sealed :
     uint32 polymorphicCacheState;
 
 #ifdef ENABLE_PROJECTION
-    SListBase<ExternalWeakReferenceCache *> externalWeakReferenceCacheList;
+    SListBase<ExternalWeakReferenceCache *, HeapAllocator> externalWeakReferenceCacheList;
 #if DBG_DUMP
     IProjectionContextMemoryInfo *projectionMemoryInformation;
 #endif
diff --git a/lib/Runtime/Library/ForInObjectEnumerator.h b/lib/Runtime/Library/ForInObjectEnumerator.h
@@ -13,10 +13,12 @@ namespace Js
         struct ShadowData
         {
             ShadowData(RecyclableObject * initObject, RecyclableObject * firstPrototype, Recycler * recycler);
+
             Field(RecyclableObject *) currentObject;
             Field(RecyclableObject *) firstPrototype;
             Field(BVSparse<Recycler>) propertyIds;
-            Field(SListBase<Js::PropertyRecord const *, Recycler>) newPropertyStrings;
+            typedef SListBase<Js::PropertyRecord const *, Recycler> _PropertyStringsListType;
+            Field(_PropertyStringsListType) newPropertyStrings;
         } *shadowData;
 
         // States

Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ PageAllocator* PageAllocatorPool::GetPageAllocator()`
`86`	`86`	`void PageAllocatorPool::ReturnPageAllocator(PageAllocator* pageAllocator)`
`87`	`87`	`{`
`88`	`88`	`AutoCriticalSection autoCS(&cs);`
`89`		`- if (!this->pageAllocators.PrependNoThrow(&HeapAllocator::Instance, pageAllocator))`
	`89`	`+ if (!this->pageAllocators.PrependNoThrow(&NoThrowHeapAllocator::Instance, pageAllocator))`
`90`	`90`	`{`
`91`	`91`	`HeapDelete(pageAllocator);`
`92`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,9 +62,9 @@ SegmentBase<T>::~SegmentBase()`
`62`	`62`	`{`
`63`	`63`	`RecyclerWriteBarrierManager::ToggleBarrier(this->address, this->segmentPageCount * AutoSystemInfo::PageSize, false);`
`64`	`64`	`}`
`65`		`-#endif`
`66`	`65`	`#endif`
`67`	`66`	`RecyclerWriteBarrierManager::OnSegmentFree(this->address, this->segmentPageCount);`
	`67`	`+#endif`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`@@ -343,7 +343,7 @@ PageSegmentBase<T>::AllocPages(uint pageCount)`
`343`	`343`	`MemoryOperationLastError::RecordLastError();`
`344`	`344`	`if (this->GetAllocator()->processHandle == GetCurrentProcess())`
`345`	`345`	`{`
`346`		`- Assert(false);`
	`346`	`+ Assert(false);`
`347`	`347`	`}`
`348`	`348`	`return nullptr;`
`349`	`349`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@`
`21`	`21`
`22`	`22`	`#ifdef RECYCLER_WRITE_BARRIER`
`23`	`23`	`#if ENABLE_DEBUG_CONFIG_OPTIONS`
`24`		`-namespace Memory`
	`24`	`+namespace Memory`
`25`	`25`	`{`
`26`	`26`	`FN_VerifyIsNotBarrierAddress* g_verifyIsNotBarrierAddress = nullptr;`
`27`	`27`	`}`
`@@ -377,11 +377,11 @@ RecyclerWriteBarrierManager::IsBarrierAddress(void * address)`
`377`	`377`	`bool`
`378`	`378`	`RecyclerWriteBarrierManager::IsBarrierAddress(uintptr_t index)`
`379`	`379`	`{`
`380`		`- return cardTable[index] & WRITE_BARRIER_PAGE_BIT;`
	`380`	`+ return (cardTable[index] & WRITE_BARRIER_PAGE_BIT) == WRITE_BARRIER_PAGE_BIT;`
`381`	`381`	`}`
`382`	`382`
`383`		`-// TODO: SWB, looks we didn't initialize card table for heap allocation.`
`384`		`-// we didn't hit such issue because we are not allocating write barrier`
	`383`	`+// TODO: SWB, looks we didn't initialize card table for heap allocation.`
	`384`	`+// we didn't hit such issue because we are not allocating write barrier`
`385`	`385`	`// annotated struct with heap today.`
`386`	`386`	`// after SWB is widely enabled and if an annotated structure can be allocated`
`387`	`387`	`// with both Heap and Recycler/Arena we'll capture the issue`
`@@ -406,10 +406,10 @@ RecyclerWriteBarrierManager::VerifyIsBarrierAddress(void * address, size_t bytes`
`406`	`406`	`uintptr_t startIndex = GetCardTableIndex(address);`
`407`	`407`	`char * endAddress = (char )Math::Align<INT_PTR>((INT_PTR)((char )address + bytes), s_WriteBarrierPageSize);`
`408`	`408`	`uintptr_t endIndex = GetCardTableIndex(endAddress);`
`409`		`- do`
	`409`	`+ do`
`410`	`410`	`{`
`411`	`411`	`// no need to check if cardTable is commited or not, if it's not commited it'll AV instead of assertion`
`412`		`- if (!IsBarrierAddress(startIndex))`
	`412`	`+ if (!IsBarrierAddress(startIndex))`
`413`	`413`	`{`
`414`	`414`	`Js::Throw::FatalInternalError();`
`415`	`415`	`}`
`@@ -425,11 +425,11 @@ RecyclerWriteBarrierManager::VerifyIsNotBarrierAddress(void * address, size_t by`
`425`	`425`	`uintptr_t startIndex = GetCardTableIndex(address);`
`426`	`426`	`char * endAddress = (char )Math::Align<INT_PTR>((INT_PTR)((char )address + bytes), s_WriteBarrierPageSize);`
`427`	`427`	`uintptr_t endIndex = GetCardTableIndex(endAddress);`
`428`		`- do`
	`428`	`+ do`
`429`	`429`	`{`
`430`	`430`	`if(IsCardTableCommited(startIndex))`
`431`	`431`	`{`
`432`		`- if (IsBarrierAddress(startIndex))`
	`432`	`+ if (IsBarrierAddress(startIndex))`
`433`	`433`	`{`
`434`	`434`	`Js::Throw::FatalInternalError();`
`435`	`435`	`}`
`@@ -439,13 +439,13 @@ RecyclerWriteBarrierManager::VerifyIsNotBarrierAddress(void * address, size_t by`
`439`	`439`	`}`
`440`	`440`	`}`
`441`	`441`
`442`		`-bool`
	`442`	`+bool`
`443`	`443`	`RecyclerWriteBarrierManager::Initialize()`
`444`	`444`	`{`
`445`	`445`	`g_verifyIsNotBarrierAddress = RecyclerWriteBarrierManager::VerifyIsNotBarrierAddress;`
`446`	`446`	`return true;`
`447`	`447`	`}`
`448`		`-#endif`
	`448`	`+#endif`
`449`	`449`
`450`	`450`	`uintptr_t`
`451`	`451`	`RecyclerWriteBarrierManager::GetCardTableIndex(void *address)`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ class ServerContextManager`
`12`	`12`	`static void CleanUpForProcess(HANDLE hProcess);`
`13`	`13`
`14`	`14`	`static void RegisterScriptContext(ServerScriptContext* scriptContext);`
`15`		`- static void UnRegisterScriptContext(ServerScriptContext* scriptContext);`
	`15`	`+ static void UnRegisterScriptContext(ServerScriptContext* scriptContext);`
`16`	`16`
`17`	`17`	`static bool CheckLivenessAndAddref(ServerScriptContext* context);`
`18`	`18`	`static bool CheckLivenessAndAddref(ServerThreadContext* context);`
`@@ -44,19 +44,19 @@ class ServerContextManager`
`44`	`44`	`T* context;`
`45`	`45`	`union {`
`46`	`46`	`DWORD runtimeProcId;`
`47`		`- ServerThreadContext* threadCtx;`
	`47`	`+ ServerThreadContext* threadCtx;`
`48`	`48`	`};`
`49`	`49`	`StackBackTrace* stack;`
`50`	`50`	`};`
`51`	`51`
`52`	`52`	`static void RecordCloseContext(ServerThreadContext* context)`
`53`	`53`	`{`
`54`	`54`	`auto record = HeapNewNoThrow(ClosedContextEntry<ServerThreadContext>, context);`
`55`		`- if (record)`
	`55`	`+ if (record)`
`56`	`56`	`{`
`57`	`57`	`record->runtimeProcId = context->GetRuntimePid();`
`58`	`58`	`}`
`59`		`- ClosedThreadContextList.PrependNoThrow(&HeapAllocator::Instance, record);`
	`59`	`+ ClosedThreadContextList.PrependNoThrow(&NoThrowHeapAllocator::Instance, record);`
`60`	`60`	`}`
`61`	`61`	`static void RecordCloseContext(ServerScriptContext* context)`
`62`	`62`	`{`
`@@ -65,7 +65,7 @@ class ServerContextManager`
`65`	`65`	`{`
`66`	`66`	`record->threadCtx = context->GetThreadContext();`
`67`	`67`	`}`
`68`		`- ClosedScriptContextList.PrependNoThrow(&HeapAllocator::Instance, record);`
	`68`	`+ ClosedScriptContextList.PrependNoThrow(&NoThrowHeapAllocator::Instance, record);`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`static SList<ClosedContextEntry<ServerThreadContext>*, NoThrowHeapAllocator> ClosedThreadContextList;`
Original file line number	Diff line number	Diff line change
`@@ -4130,7 +4130,7 @@ void ThreadContext::RemoveExternalWeakReferenceCache(ExternalWeakReferenceCache`
`4130`	`4130`
`4131`	`4131`	`void ThreadContext::MarkExternalWeakReferencedObjects(bool inPartialCollect)`
`4132`	`4132`	`{`
`4133`		`- SListBase<ExternalWeakReferenceCache *>::Iterator iteratorWeakRefCache(&this->externalWeakReferenceCacheList);`
	`4133`	`+ SListBase<ExternalWeakReferenceCache *, HeapAllocator>::Iterator iteratorWeakRefCache(&this->externalWeakReferenceCacheList);`
`4134`	`4134`	`while (iteratorWeakRefCache.Next())`
`4135`	`4135`	`{`
`4136`	`4136`	`iteratorWeakRefCache.Data()->MarkNow(recycler, inPartialCollect);`
`@@ -4139,7 +4139,7 @@ void ThreadContext::MarkExternalWeakReferencedObjects(bool inPartialCollect)`
`4139`	`4139`
`4140`	`4140`	`void ThreadContext::ResolveExternalWeakReferencedObjects()`
`4141`	`4141`	`{`
`4142`		`- SListBase<ExternalWeakReferenceCache *>::Iterator iteratorWeakRefCache(&this->externalWeakReferenceCacheList);`
	`4142`	`+ SListBase<ExternalWeakReferenceCache *, HeapAllocator>::Iterator iteratorWeakRefCache(&this->externalWeakReferenceCacheList);`
`4143`	`4143`	`while (iteratorWeakRefCache.Next())`
`4144`	`4144`	`{`
`4145`	`4145`	`iteratorWeakRefCache.Data()->ResolveNow(recycler);`