Rename PCMI->pLast and other cleanup of virtual memory code.

Author: adityamandaleeka

src/pal/src/include/pal/virtual.h

@@ -28,10 +28,10 @@ extern "C"
 typedef struct _CMI {
 
     struct _CMI * pNext;        /* Link to the next entry. */
-    struct _CMI * pLast;        /* Link to the previous entry. */
+    struct _CMI * pPrevious;    /* Link to the previous entry. */
 
-    UINT_PTR   startBoundary;   /* Starting location of the region. */
-    SIZE_T   memSize;         /* Size of the entire region.. */
+    UINT_PTR startBoundary;     /* Starting location of the region. */
+    SIZE_T   memSize;           /* Size of the entire region.. */
 
     DWORD  accessProtection;    /* Initial allocation access protection. */
     DWORD  allocationType;      /* Initial allocation type. */

src/pal/src/map/virtual.cpp

@@ -8,7 +8,7 @@
 
 Module Name:
 
-    virtual.c
+    virtual.cpp
 
 Abstract:
 
@@ -70,7 +70,7 @@ static LPVOID ReserveVirtualMemory(
 
 
 // A memory allocator that allocates memory from a pre-reserved region
-// of virtual memory that is located near the coreclr library.
+// of virtual memory that is located near the CoreCLR library.
 static ExecutableMemoryAllocator g_executableMemoryAllocator;
 
 /*++
@@ -226,7 +226,7 @@ static INT VIRTUALGetAllocationType( SIZE_T Index, CONST PCMI pInformation )
  *  IN BYTE* pBitArray - A pointer the array to be manipulated.
  *
  *  Returns TRUE on success, FALSE otherwise.
- *  Turn on/off memory staus bits.
+ *  Turn on/off memory status bits.
  *         
  */
 static BOOL VIRTUALSetPageBits ( UINT nStatus, SIZE_T nStartingBit, 
@@ -445,20 +445,20 @@ static BOOL VIRTUALReleaseMemory( PCMI pMemoryToBeReleased )
         pVirtualMemory = pMemoryToBeReleased->pNext;
         if ( pMemoryToBeReleased->pNext )
         {
-            pMemoryToBeReleased->pNext->pLast = NULL;
+            pMemoryToBeReleased->pNext->pPrevious = NULL;
         }
     }
     else /* Could be anywhere in the list. */
     {
         /* Delete the entry from the linked list. */
-        if ( pMemoryToBeReleased->pLast )
+        if ( pMemoryToBeReleased->pPrevious )
         {
-            pMemoryToBeReleased->pLast->pNext = pMemoryToBeReleased->pNext;
+            pMemoryToBeReleased->pPrevious->pNext = pMemoryToBeReleased->pNext;
         }
 
         if ( pMemoryToBeReleased->pNext )
         {
-            pMemoryToBeReleased->pNext->pLast = pMemoryToBeReleased->pLast;
+            pMemoryToBeReleased->pNext->pPrevious = pMemoryToBeReleased->pPrevious;
         }
     }
 
@@ -594,7 +594,7 @@ static void VIRTUALDisplayList( void  )
         DBGOUT( "\t accessProtection %d \n", p->accessProtection );
         DBGOUT( "\t allocationType %d \n", p->allocationType );
         DBGOUT( "\t pNext %p \n", p->pNext );
-        DBGOUT( "\t pLast %p \n", p->pLast );
+        DBGOUT( "\t pLast %p \n", p->pPrevious );
 
         count++;
         p = p->pNext;
@@ -611,107 +611,101 @@ static void VIRTUALDisplayList( void  )
  *      NOTE: The caller must own the critical section.
  */
 static BOOL VIRTUALStoreAllocationInfo( 
-            IN UINT_PTR startBoundary,      /* Start of the region. */
-            IN SIZE_T memSize,            /* Size of the region. */
+            IN UINT_PTR startBoundary,  /* Start of the region. */
+            IN SIZE_T memSize,          /* Size of the region. */
             IN DWORD flAllocationType,  /* Allocation Types. */
             IN DWORD flProtection )     /* Protections flags on the memory. */
 {
-    PCMI pNewEntry       = NULL;
-    PCMI pMemInfo        = NULL;
-    BOOL bRetVal         = TRUE;
+    PCMI pNewEntry       = nullptr;
+    PCMI pMemInfo        = nullptr;
     SIZE_T nBufferSize   = 0;
 
-    if ( ( memSize & VIRTUAL_PAGE_MASK ) != 0 )
+    if ((memSize & VIRTUAL_PAGE_MASK) != 0)
     {
-        ERROR( "The memory size was not in multiples of the page size. \n" );
-        bRetVal =  FALSE;
-        goto done;
+        ERROR("The memory size was not a multiple of the page size. \n");
+        return FALSE;
     }
-    
-    if ( !(pNewEntry = ( PCMI )InternalMalloc( sizeof( *pNewEntry )) ) )
+
+    if (!(pNewEntry = (PCMI)InternalMalloc(sizeof(*pNewEntry))))
     {
         ERROR( "Unable to allocate memory for the structure.\n");
-        bRetVal =  FALSE;
-        goto done;
+        return FALSE;
     }
-    
+
     pNewEntry->startBoundary    = startBoundary;
     pNewEntry->memSize          = memSize;
     pNewEntry->allocationType   = flAllocationType;
     pNewEntry->accessProtection = flProtection;
-    
+
     nBufferSize = memSize / VIRTUAL_PAGE_SIZE / CHAR_BIT;
-    if ( ( memSize / VIRTUAL_PAGE_SIZE ) % CHAR_BIT != 0 )
+    if ((memSize / VIRTUAL_PAGE_SIZE) % CHAR_BIT != 0)
     {
         nBufferSize++;
     }
-    
-    pNewEntry->pAllocState      = (BYTE*)InternalMalloc( nBufferSize  );
-    pNewEntry->pProtectionState = (BYTE*)InternalMalloc( (memSize / VIRTUAL_PAGE_SIZE)  );
+
+    pNewEntry->pAllocState      = (BYTE*)InternalMalloc(nBufferSize);
+    pNewEntry->pProtectionState = (BYTE*)InternalMalloc((memSize / VIRTUAL_PAGE_SIZE));
 
     if (pNewEntry->pAllocState && pNewEntry->pProtectionState)
     {
         /* Set the intial allocation state, and initial allocation protection. */
-        VIRTUALSetAllocState( MEM_RESERVE, 0, nBufferSize * CHAR_BIT, pNewEntry );
-        memset( pNewEntry->pProtectionState,
-            VIRTUALConvertWinFlags( flProtection ),
-            memSize / VIRTUAL_PAGE_SIZE );
+        VIRTUALSetAllocState(MEM_RESERVE, 0, nBufferSize * CHAR_BIT, pNewEntry);
+        memset(pNewEntry->pProtectionState,
+               VIRTUALConvertWinFlags(flProtection),
+               memSize / VIRTUAL_PAGE_SIZE);
     }
     else
     {
         ERROR( "Unable to allocate memory for the structure.\n");
-        bRetVal =  FALSE;
 
-        if (pNewEntry->pProtectionState) InternalFree( pNewEntry->pProtectionState );
-        pNewEntry->pProtectionState = NULL;
+        if (pNewEntry->pProtectionState) InternalFree(pNewEntry->pProtectionState);
+        pNewEntry->pProtectionState = nullptr;
 
-        if (pNewEntry->pAllocState) InternalFree( pNewEntry->pAllocState );
-        pNewEntry->pAllocState = NULL;
+        if (pNewEntry->pAllocState) InternalFree(pNewEntry->pAllocState);
+        pNewEntry->pAllocState = nullptr;
 
-        InternalFree( pNewEntry );
-        pNewEntry = NULL;
-        
-        goto done;
+        InternalFree(pNewEntry);
+        pNewEntry = nullptr;
+
+        return FALSE;
     }
 
     pMemInfo = pVirtualMemory;
 
-    if ( pMemInfo && pMemInfo->startBoundary < startBoundary )
+    if (pMemInfo && pMemInfo->startBoundary < startBoundary)
     {
         /* Look for the correct insert point */
-        TRACE( "Looking for the correct insert location.\n");
-        while ( pMemInfo->pNext && ( pMemInfo->pNext->startBoundary < startBoundary ) ) 
+        TRACE("Looking for the correct insert location.\n");
+        while (pMemInfo->pNext && (pMemInfo->pNext->startBoundary < startBoundary))
         {
             pMemInfo = pMemInfo->pNext;
         }
-        
+
         pNewEntry->pNext = pMemInfo->pNext;
-        pNewEntry->pLast = pMemInfo;
-        
-        if ( pNewEntry->pNext ) 
+        pNewEntry->pPrevious = pMemInfo;
+
+        if (pNewEntry->pNext)
         {
-            pNewEntry->pNext->pLast = pNewEntry;
+            pNewEntry->pNext->pPrevious = pNewEntry;
         }
-        
+
         pMemInfo->pNext = pNewEntry;
     }
     else
     {
-        TRACE( "Inserting a new element into the linked list\n" );
         /* This is the first entry in the list. */
         pNewEntry->pNext = pMemInfo;
-        pNewEntry->pLast = NULL;
-        
-        if ( pNewEntry->pNext ) 
+        pNewEntry->pPrevious = nullptr;
+
+        if (pNewEntry->pNext)
         {
-            pNewEntry->pNext->pLast = pNewEntry;
+            pNewEntry->pNext->pPrevious = pNewEntry;
         }
 
         pVirtualMemory = pNewEntry ;
     }
-done:
-    TRACE( "Exiting StoreAllocationInformation. \n" );
-    return bRetVal;
+
+    return TRUE;
 }
 
 /******