Replace CoreCLR SList with NativeAOT-style design

docs/design/datacontracts/SyncBlock.md

@@ -24,7 +24,7 @@ Data descriptors used:
 | `SyncTableEntry` | `SyncBlock` | Pointer to the sync block for a sync table entry |
 | `SyncTableEntry` | `Object` | Pointer to the object associated with a sync table entry |
 | `SyncBlockCache` | `FreeSyncTableIndex` | One past the highest sync table entry index allocated |
-| `SyncBlockCache` | `CleanupBlockList` | Head of the `SLink` cleanup list (points into `SyncBlock.m_Link`) |
+| `SyncBlockCache` | `CleanupBlockList` | Head of the cleanup list (points to the first `SyncBlock` in the chain) |
 | `SyncBlock` | `Lock` | Optional pointer to a `System.Threading.Lock` object payload |
 | `SyncBlock` | `ThinLock` | Thin-lock state bits |
 | `SyncBlock` | `LinkNext` | Head pointer for cleanup list link |
@@ -149,7 +149,7 @@ TargetPointer GetSyncBlockFromCleanupList()
     TargetPointer cleanupBlockList = target.ReadPointer(syncBlockCache + /* SyncBlockCache::CleanupBlockList offset */);
     if (cleanupBlockList == TargetPointer.Null)
         return TargetPointer.Null;
-    return cleanupBlockList - /* SyncBlock::LinkNext offset */;
+    return cleanupBlockList;
 }
 
 // Returns the next sync block in the cleanup list after syncBlock, or TargetPointer.Null if there is none.
@@ -158,7 +158,7 @@ TargetPointer GetNextSyncBlock(TargetPointer syncBlock)
     TargetPointer linkNext = target.ReadPointer(syncBlock + /* SyncBlock::LinkNext offset */);
     if (linkNext == TargetPointer.Null)
         return TargetPointer.Null;
-    return linkNext - /* SyncBlock::LinkNext offset */;
+    return linkNext;
 }
 
 // Gets the built-in COM interop data directly from a sync block.

src/coreclr/debug/daccess/request.cpp

@@ -3822,9 +3822,9 @@ ClrDataAccess::GetSyncBlockData(unsigned int SBNumber, struct DacpSyncBlockData
                 // TODO: Microsoft, implement the wait list
                 pSyncBlockData->AdditionalThreadCount = 0;
 
-                if (pBlock->m_Link.m_pNext != NULL)
+                if (pBlock->m_pNext != NULL)
                 {
-                    PTR_SLink pLink = pBlock->m_Link.m_pNext;
+                    PTR_SyncBlock pLink = pBlock->m_pNext;
                     do
                     {
                         pSyncBlockData->AdditionalThreadCount++;
@@ -3855,7 +3855,7 @@ ClrDataAccess::GetSyncBlockCleanupData(CLRDATA_ADDRESS syncBlock, struct DacpSyn
     if (syncBlock == (CLRDATA_ADDRESS)NULL && SyncBlockCache::s_pSyncBlockCache->m_pCleanupBlockList)
     {
         pBlock = (SyncBlock *) PTR_SyncBlock(
-            PTR_HOST_TO_TADDR(SyncBlockCache::s_pSyncBlockCache->m_pCleanupBlockList) - offsetof(SyncBlock, m_Link));
+            PTR_HOST_TO_TADDR(SyncBlockCache::s_pSyncBlockCache->m_pCleanupBlockList));
     }
     else
     {
@@ -3865,10 +3865,10 @@ ClrDataAccess::GetSyncBlockCleanupData(CLRDATA_ADDRESS syncBlock, struct DacpSyn
     if (pBlock)
     {
         syncBlockCData->SyncBlockPointer = HOST_CDADDR(pBlock);
-        if (pBlock->m_Link.m_pNext)
+        if (pBlock->m_pNext)
         {
             syncBlockCData->nextSyncBlock = (CLRDATA_ADDRESS)
-                (PTR_HOST_TO_TADDR(pBlock->m_Link.m_pNext) - offsetof(SyncBlock, m_Link));
+                PTR_HOST_TO_TADDR(pBlock->m_pNext);
         }
 
 #ifdef FEATURE_COMINTEROP

src/coreclr/inc/daccess.h

@@ -238,20 +238,10 @@
 // instance pointers should be held across a Flush().
 //
 // Accessing into an object can lead to some unusual behavior.  For
-// example, the SList class relies on objects to contain an SLink
-// instance that it uses for list maintenance.  This SLink can be
-// embedded anywhere in the larger object.  The SList access is always
-// purely to an SLink, so when using the access layer it will only
-// retrieve an SLink's worth of data.  The SList template will then
-// do some address arithmetic to determine the start of the real
-// object and cast the resulting pointer to the final object type.
-// When using the access layer this results in a new ?PTR being
-// created and used, so a new instance will result.  The internal
-// SLink instance will have no relation to the new object instance
-// even though in target address terms one is embedded in the other.
-// The assumption of data stability means that this won't cause
-// a problem, but care must be taken with the address arithmetic,
-// as laid out in rules #2 and #3.
+// example, the SList class uses an intrusive m_pNext pointer
+// embedded in each object for list maintenance.  The SList access is
+// always to the object itself, so when using the access layer it will
+// retrieve the full object's data.
 //
 // 4.  Global address references cannot be used.  Any reference to a
 //     global piece of code or data, such as a function address, global

src/coreclr/inc/profilepriv.h

@@ -158,10 +158,11 @@ struct StoredProfilerNode
 {
     CLSID guid;
     SString path;
-    SLink m_Link;
+    // Next pointer for SList linkage.
+    DPTR(StoredProfilerNode) m_pNext;
 };
 
-typedef SList<StoredProfilerNode, true> STOREDPROFILERLIST;
+typedef SList<StoredProfilerNode> STOREDPROFILERLIST;
 // ---------------------------------------------------------------------------------------
 // Global struct that lets the EE see the load status of the profiler, and provides a
 // pointer (pProfInterface) through which profiler calls can be made