Use SIZE_T type for size variables in NTDLL when appropriate, avoid not necessary casts. Take 2
Dmitry Timoshkov
dmitry at baikal.ru
Wed Jul 13 04:27:52 CDT 2005
Hello,
Alexandre thinks that using SIZE_T in the heap structures would require
more work to preserve alignment (i.e. make sure that there is no unaligned
accesses to structure fields).
This version of the patch leaves heap structures intact, but changes all
public and internal APIs to use SIZE_T for memory block variables.
===
Win32 heap and virtual memory APIs use SIZE_T type for the memory size
variables, presumably NTDLL APIs should do the same.
Changelog:
Dmitry Timoshkov <dmitry at codeweavers.com>
Use SIZE_T type for size variables in NTDLL when appropriate,
avoid not necessary casts.
diff -up cvs/hq/wine/dlls/ntdll/heap.c wine/dlls/ntdll/heap.c
--- cvs/hq/wine/dlls/ntdll/heap.c 2005-07-13 17:56:47.000000000 +0900
+++ wine/dlls/ntdll/heap.c 2005-07-13 18:11:17.000000000 +0900
@@ -48,6 +48,10 @@ WINE_DEFAULT_DEBUG_CHANNEL(heap);
* require it.
*/
+/* FIXME: use SIZE_T for 'size' structure members, but we need to make sure
+ * that there is no unaligned accesses to structure fields.
+ */
+
typedef struct tagARENA_INUSE
{
DWORD size; /* Block size; must be the first field */
@@ -129,7 +133,7 @@ static HEAP *firstHeap; /* head of s
static BOOL HEAP_IsRealArena( HEAP *heapPtr, DWORD flags, LPCVOID block, BOOL quiet );
/* mark a block of memory as free for debugging purposes */
-static inline void mark_block_free( void *ptr, size_t size )
+static inline void mark_block_free( void *ptr, SIZE_T size )
{
if (TRACE_ON(heap)) memset( ptr, ARENA_FREE_FILLER, size );
#ifdef VALGRIND_MAKE_NOACCESS
@@ -138,7 +142,7 @@ static inline void mark_block_free( void
}
/* mark a block of memory as initialized for debugging purposes */
-static inline void mark_block_initialized( void *ptr, size_t size )
+static inline void mark_block_initialized( void *ptr, SIZE_T size )
{
#ifdef VALGRIND_MAKE_READABLE
VALGRIND_DISCARD( VALGRIND_MAKE_READABLE( ptr, size ));
@@ -146,7 +150,7 @@ static inline void mark_block_initialize
}
/* mark a block of memory as uninitialized for debugging purposes */
-static inline void mark_block_uninitialized( void *ptr, size_t size )
+static inline void mark_block_uninitialized( void *ptr, SIZE_T size )
{
#ifdef VALGRIND_MAKE_WRITABLE
VALGRIND_DISCARD( VALGRIND_MAKE_WRITABLE( ptr, size ));
@@ -162,7 +166,7 @@ static inline void mark_block_uninitiali
}
/* clear contents of a block of memory */
-static inline void clear_block( void *ptr, size_t size )
+static inline void clear_block( void *ptr, SIZE_T size )
{
mark_block_initialized( ptr, size );
memset( ptr, 0, size );
@@ -177,29 +181,28 @@ static void HEAP_Dump( HEAP *heap )
SUBHEAP *subheap;
char *ptr;
- DPRINTF( "Heap: %08lx\n", (DWORD)heap );
- DPRINTF( "Next: %08lx Sub-heaps: %08lx",
- (DWORD)heap->next, (DWORD)&heap->subheap );
+ DPRINTF( "Heap: %p\n", heap );
+ DPRINTF( "Next: %p Sub-heaps: %p", heap->next, &heap->subheap );
subheap = &heap->subheap;
while (subheap->next)
{
- DPRINTF( " -> %08lx", (DWORD)subheap->next );
+ DPRINTF( " -> %p", subheap->next );
subheap = subheap->next;
}
DPRINTF( "\nFree lists:\n Block Stat Size Id\n" );
for (i = 0; i < HEAP_NB_FREE_LISTS; i++)
- DPRINTF( "%08lx free %08lx prev=%08lx next=%08lx\n",
- (DWORD)&heap->freeList[i].arena, heap->freeList[i].size,
- (DWORD)heap->freeList[i].arena.prev,
- (DWORD)heap->freeList[i].arena.next );
+ DPRINTF( "%p free %08lx prev=%p next=%p\n",
+ &heap->freeList[i].arena, heap->freeList[i].size,
+ heap->freeList[i].arena.prev,
+ heap->freeList[i].arena.next );
subheap = &heap->subheap;
while (subheap)
{
- DWORD freeSize = 0, usedSize = 0, arenaSize = subheap->headerSize;
- DPRINTF( "\n\nSub-heap %08lx: size=%08lx committed=%08lx\n",
- (DWORD)subheap, subheap->size, subheap->commitSize );
+ SIZE_T freeSize = 0, usedSize = 0, arenaSize = subheap->headerSize;
+ DPRINTF( "\n\nSub-heap %p: size=%08lx committed=%08lx\n",
+ subheap, subheap->size, subheap->commitSize );
DPRINTF( "\n Block Stat Size Id\n" );
ptr = (char*)subheap + subheap->headerSize;
@@ -208,9 +211,9 @@ static void HEAP_Dump( HEAP *heap )
if (*(DWORD *)ptr & ARENA_FLAG_FREE)
{
ARENA_FREE *pArena = (ARENA_FREE *)ptr;
- DPRINTF( "%08lx free %08lx prev=%08lx next=%08lx\n",
- (DWORD)pArena, pArena->size & ARENA_SIZE_MASK,
- (DWORD)pArena->prev, (DWORD)pArena->next);
+ DPRINTF( "%p free %08lx prev=%p next=%p\n",
+ pArena, pArena->size & ARENA_SIZE_MASK,
+ pArena->prev, pArena->next);
ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
arenaSize += sizeof(ARENA_FREE);
freeSize += pArena->size & ARENA_SIZE_MASK;
@@ -218,8 +221,8 @@ static void HEAP_Dump( HEAP *heap )
else if (*(DWORD *)ptr & ARENA_FLAG_PREV_FREE)
{
ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
- DPRINTF( "%08lx Used %08lx back=%08lx\n",
- (DWORD)pArena, pArena->size & ARENA_SIZE_MASK, *((DWORD *)pArena - 1) );
+ DPRINTF( "%p Used %08lx back=%08lx\n",
+ pArena, pArena->size & ARENA_SIZE_MASK, *((ULONG_PTR *)pArena - 1) );
ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
arenaSize += sizeof(ARENA_INUSE);
usedSize += pArena->size & ARENA_SIZE_MASK;
@@ -227,8 +230,8 @@ static void HEAP_Dump( HEAP *heap )
else
{
ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
- DPRINTF( "%08lx used %08lx\n",
- (DWORD)pArena, pArena->size & ARENA_SIZE_MASK );
+ DPRINTF( "%p used %08lx\n",
+ pArena, pArena->size & ARENA_SIZE_MASK );
ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
arenaSize += sizeof(ARENA_INUSE);
usedSize += pArena->size & ARENA_SIZE_MASK;
@@ -369,7 +372,7 @@ static SUBHEAP *HEAP_FindSubHeap(
*/
static inline BOOL HEAP_Commit( SUBHEAP *subheap, void *ptr )
{
- DWORD size = (DWORD)((char *)ptr - (char *)subheap);
+ SIZE_T size = (SIZE_T)((char *)ptr - (char *)subheap);
size = (size + COMMIT_MASK) & ~COMMIT_MASK;
if (size > subheap->size) size = subheap->size;
if (size <= subheap->commitSize) return TRUE;
@@ -395,9 +398,9 @@ static inline BOOL HEAP_Commit( SUBHEAP
static inline BOOL HEAP_Decommit( SUBHEAP *subheap, void *ptr )
{
void *addr;
- ULONG decommit_size;
+ SIZE_T decommit_size;
+ SIZE_T size = (SIZE_T)((char *)ptr - (char *)subheap);
- DWORD size = (DWORD)((char *)ptr - (char *)subheap);
/* round to next block and add one full block */
size = ((size + COMMIT_MASK) & ~COMMIT_MASK) + COMMIT_MASK + 1;
if (size >= subheap->commitSize) return TRUE;
@@ -421,7 +424,7 @@ static inline BOOL HEAP_Decommit( SUBHEA
* Create a free block at a specified address. 'size' is the size of the
* whole block, including the new arena.
*/
-static void HEAP_CreateFreeBlock( SUBHEAP *subheap, void *ptr, DWORD size )
+static void HEAP_CreateFreeBlock( SUBHEAP *subheap, void *ptr, SIZE_T size )
{
ARENA_FREE *pFree;
char *pEnd;
@@ -478,7 +481,7 @@ static void HEAP_CreateFreeBlock( SUBHEA
static void HEAP_MakeInUseBlockFree( SUBHEAP *subheap, ARENA_INUSE *pArena )
{
ARENA_FREE *pFree;
- DWORD size = (pArena->size & ARENA_SIZE_MASK) + sizeof(*pArena);
+ SIZE_T size = (pArena->size & ARENA_SIZE_MASK) + sizeof(*pArena);
/* Check if we can merge with previous block */
@@ -504,7 +507,7 @@ static void HEAP_MakeInUseBlockFree( SUB
if (((char *)pFree == (char *)subheap + subheap->headerSize) &&
(subheap != &subheap->heap->subheap))
{
- ULONG size = 0;
+ SIZE_T size = 0;
SUBHEAP *pPrev = &subheap->heap->subheap;
/* Remove the free block from the list */
pFree->next->prev = pFree->prev;
@@ -529,7 +532,7 @@ static void HEAP_MakeInUseBlockFree( SUB
*
* Shrink an in-use block.
*/
-static void HEAP_ShrinkBlock(SUBHEAP *subheap, ARENA_INUSE *pArena, DWORD size)
+static void HEAP_ShrinkBlock(SUBHEAP *subheap, ARENA_INUSE *pArena, SIZE_T size)
{
if ((pArena->size & ARENA_SIZE_MASK) >= size + HEAP_MIN_BLOCK_SIZE)
{
@@ -551,7 +554,7 @@ static void HEAP_ShrinkBlock(SUBHEAP *su
* HEAP_InitSubHeap
*/
static BOOL HEAP_InitSubHeap( HEAP *heap, LPVOID address, DWORD flags,
- DWORD commitSize, DWORD totalSize )
+ SIZE_T commitSize, SIZE_T totalSize )
{
SUBHEAP *subheap;
FREE_LIST_ENTRY *pEntry;
@@ -637,7 +640,7 @@ static BOOL HEAP_InitSubHeap( HEAP *heap
* If heap == NULL, creates a main heap.
*/
static SUBHEAP *HEAP_CreateSubHeap( HEAP *heap, void *base, DWORD flags,
- DWORD commitSize, DWORD totalSize )
+ SIZE_T commitSize, SIZE_T totalSize )
{
LPVOID address = base;
@@ -663,7 +666,7 @@ static SUBHEAP *HEAP_CreateSubHeap( HEAP
if (!HEAP_InitSubHeap( heap ? heap : (HEAP *)address,
address, flags, commitSize, totalSize ))
{
- ULONG size = 0;
+ SIZE_T size = 0;
if (!base) NtFreeVirtualMemory( NtCurrentProcess(), &address, &size, MEM_RELEASE );
return NULL;
}
@@ -678,7 +681,7 @@ static SUBHEAP *HEAP_CreateSubHeap( HEAP
* Find a free block at least as large as the requested size, and make sure
* the requested size is committed.
*/
-static ARENA_FREE *HEAP_FindFreeBlock( HEAP *heap, DWORD size,
+static ARENA_FREE *HEAP_FindFreeBlock( HEAP *heap, SIZE_T size,
SUBHEAP **ppSubHeap )
{
SUBHEAP *subheap;
@@ -691,7 +694,7 @@ static ARENA_FREE *HEAP_FindFreeBlock( H
pArena = pEntry->arena.next;
while (pArena != &heap->freeList[0].arena)
{
- DWORD arena_size = (pArena->size & ARENA_SIZE_MASK) +
+ SIZE_T arena_size = (pArena->size & ARENA_SIZE_MASK) +
sizeof(ARENA_FREE) - sizeof(ARENA_INUSE);
if (arena_size >= size)
{
@@ -709,8 +712,7 @@ static ARENA_FREE *HEAP_FindFreeBlock( H
if (!(heap->flags & HEAP_GROWABLE))
{
- WARN("Not enough space in heap %08lx for %08lx bytes\n",
- (DWORD)heap, size );
+ WARN("Not enough space in heap %p for %08lx bytes\n", heap, size );
return NULL;
}
/* make sure that we have a big enough size *committed* to fit another
@@ -723,8 +725,8 @@ static ARENA_FREE *HEAP_FindFreeBlock( H
max( HEAP_DEF_SIZE, size ) )))
return NULL;
- TRACE("created new sub-heap %08lx of %08lx bytes for heap %08lx\n",
- (DWORD)subheap, size, (DWORD)heap );
+ TRACE("created new sub-heap %p of %08lx bytes for heap %p\n",
+ subheap, size, heap );
*ppSubHeap = subheap;
return (ARENA_FREE *)(subheap + 1);
@@ -757,54 +759,52 @@ static BOOL HEAP_ValidateFreeArena( SUBH
char *heapEnd = (char *)subheap + subheap->size;
/* Check for unaligned pointers */
- if ( (long)pArena % ALIGNMENT != 0 )
+ if ( (ULONG_PTR)pArena % ALIGNMENT != 0 )
{
- ERR( "Heap %08lx: unaligned arena pointer %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ ERR("Heap %p: unaligned arena pointer %p\n", subheap->heap, pArena );
return FALSE;
}
/* Check magic number */
if (pArena->magic != ARENA_FREE_MAGIC)
{
- ERR("Heap %08lx: invalid free arena magic for %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ ERR("Heap %p: invalid free arena magic for %p\n", subheap->heap, pArena );
return FALSE;
}
/* Check size flags */
if (!(pArena->size & ARENA_FLAG_FREE) ||
(pArena->size & ARENA_FLAG_PREV_FREE))
{
- ERR("Heap %08lx: bad flags %lx for free arena %08lx\n",
- (DWORD)subheap->heap, pArena->size & ~ARENA_SIZE_MASK, (DWORD)pArena );
+ ERR("Heap %p: bad flags %08lx for free arena %p\n",
+ subheap->heap, pArena->size & ~ARENA_SIZE_MASK, pArena );
}
/* Check arena size */
if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
{
- ERR("Heap %08lx: bad size %08lx for free arena %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena->size & ARENA_SIZE_MASK, (DWORD)pArena );
+ ERR("Heap %p: bad size %08lx for free arena %p\n",
+ subheap->heap, pArena->size & ARENA_SIZE_MASK, pArena );
return FALSE;
}
/* Check that next pointer is valid */
if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->next ))
{
- ERR("Heap %08lx: bad next ptr %08lx for arena %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena->next, (DWORD)pArena );
+ ERR("Heap %p: bad next ptr %p for arena %p\n",
+ subheap->heap, pArena->next, pArena );
return FALSE;
}
/* Check that next arena is free */
if (!(pArena->next->size & ARENA_FLAG_FREE) ||
(pArena->next->magic != ARENA_FREE_MAGIC))
{
- ERR("Heap %08lx: next arena %08lx invalid for %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena->next, (DWORD)pArena );
+ ERR("Heap %p: next arena %p invalid for %p\n",
+ subheap->heap, pArena->next, pArena );
return FALSE;
}
/* Check that prev pointer is valid */
if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->prev ))
{
- ERR("Heap %08lx: bad prev ptr %08lx for arena %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena->prev, (DWORD)pArena );
+ ERR("Heap %p: bad prev ptr %p for arena %p\n",
+ subheap->heap, pArena->prev, pArena );
return FALSE;
}
/* Check that prev arena is free */
@@ -813,8 +813,8 @@ static BOOL HEAP_ValidateFreeArena( SUBH
{
/* this often means that the prev arena got overwritten
* by a memory write before that prev arena */
- ERR("Heap %08lx: prev arena %08lx invalid for %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena->prev, (DWORD)pArena );
+ ERR("Heap %p: prev arena %p invalid for %p\n",
+ subheap->heap, pArena->prev, pArena );
return FALSE;
}
/* Check that next block has PREV_FREE flag */
@@ -823,17 +823,17 @@ static BOOL HEAP_ValidateFreeArena( SUBH
if (!(*(DWORD *)((char *)(pArena + 1) +
(pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
{
- ERR("Heap %08lx: free arena %08lx next block has no PREV_FREE flag\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ ERR("Heap %p: free arena %p next block has no PREV_FREE flag\n",
+ subheap->heap, pArena );
return FALSE;
}
/* Check next block back pointer */
if (*((ARENA_FREE **)((char *)(pArena + 1) +
(pArena->size & ARENA_SIZE_MASK)) - 1) != pArena)
{
- ERR("Heap %08lx: arena %08lx has wrong back ptr %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena,
- *((DWORD *)((char *)(pArena+1)+ (pArena->size & ARENA_SIZE_MASK)) - 1));
+ ERR("Heap %p: arena %p has wrong back ptr %08lx\n",
+ subheap->heap, pArena,
+ *((ULONG_PTR *)((char *)(pArena+1) + (pArena->size & ARENA_SIZE_MASK)) - 1));
return FALSE;
}
}
@@ -849,19 +849,17 @@ static BOOL HEAP_ValidateInUseArena( con
const char *heapEnd = (const char *)subheap + subheap->size;
/* Check for unaligned pointers */
- if ( (long)pArena % ALIGNMENT != 0 )
+ if ( (ULONG_PTR)pArena % ALIGNMENT != 0 )
{
if ( quiet == NOISY )
{
- ERR( "Heap %08lx: unaligned arena pointer %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ ERR( "Heap %p: unaligned arena pointer %p\n", subheap->heap, pArena );
if ( TRACE_ON(heap) )
HEAP_Dump( subheap->heap );
}
else if ( WARN_ON(heap) )
{
- WARN( "Heap %08lx: unaligned arena pointer %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ WARN( "Heap %p: unaligned arena pointer %p\n", subheap->heap, pArena );
if ( TRACE_ON(heap) )
HEAP_Dump( subheap->heap );
}
@@ -872,13 +870,11 @@ static BOOL HEAP_ValidateInUseArena( con
if (pArena->magic != ARENA_INUSE_MAGIC)
{
if (quiet == NOISY) {
- ERR("Heap %08lx: invalid in-use arena magic for %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ ERR("Heap %p: invalid in-use arena magic for %p\n", subheap->heap, pArena );
if (TRACE_ON(heap))
HEAP_Dump( subheap->heap );
} else if (WARN_ON(heap)) {
- WARN("Heap %08lx: invalid in-use arena magic for %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ WARN("Heap %p: invalid in-use arena magic for %p\n", subheap->heap, pArena );
if (TRACE_ON(heap))
HEAP_Dump( subheap->heap );
}
@@ -887,23 +883,23 @@ static BOOL HEAP_ValidateInUseArena( con
/* Check size flags */
if (pArena->size & ARENA_FLAG_FREE)
{
- ERR("Heap %08lx: bad flags %lx for in-use arena %08lx\n",
- (DWORD)subheap->heap, pArena->size & ~ARENA_SIZE_MASK, (DWORD)pArena );
+ ERR("Heap %p: bad flags %08lx for in-use arena %p\n",
+ subheap->heap, pArena->size & ~ARENA_SIZE_MASK, pArena );
return FALSE;
}
/* Check arena size */
if ((const char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
{
- ERR("Heap %08lx: bad size %08lx for in-use arena %08lx\n",
- (DWORD)subheap->heap, (DWORD)pArena->size & ARENA_SIZE_MASK, (DWORD)pArena );
+ ERR("Heap %p: bad size %08lx for in-use arena %p\n",
+ subheap->heap, pArena->size & ARENA_SIZE_MASK, pArena );
return FALSE;
}
/* Check next arena PREV_FREE flag */
if (((const char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) < heapEnd) &&
(*(const DWORD *)((const char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
{
- ERR("Heap %08lx: in-use arena %08lx next block has PREV_FREE flag\n",
- (DWORD)subheap->heap, (DWORD)pArena );
+ ERR("Heap %p: in-use arena %p next block has PREV_FREE flag\n",
+ subheap->heap, pArena );
return FALSE;
}
/* Check prev free arena */
@@ -913,23 +909,23 @@ static BOOL HEAP_ValidateInUseArena( con
/* Check prev pointer */
if (!HEAP_IsValidArenaPtr( subheap->heap, pPrev ))
{
- ERR("Heap %08lx: bad back ptr %08lx for arena %08lx\n",
- (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
+ ERR("Heap %p: bad back ptr %p for arena %p\n",
+ subheap->heap, pPrev, pArena );
return FALSE;
}
/* Check that prev arena is free */
if (!(pPrev->size & ARENA_FLAG_FREE) ||
(pPrev->magic != ARENA_FREE_MAGIC))
{
- ERR("Heap %08lx: prev arena %08lx invalid for in-use %08lx\n",
- (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
+ ERR("Heap %p: prev arena %p invalid for in-use %p\n",
+ subheap->heap, pPrev, pArena );
return FALSE;
}
/* Check that prev arena is really the previous block */
if ((const char *)(pPrev + 1) + (pPrev->size & ARENA_SIZE_MASK) != (const char *)pArena)
{
- ERR("Heap %08lx: prev arena %08lx is not prev for in-use %08lx\n",
- (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
+ ERR("Heap %p: prev arena %p is not prev for in-use %p\n",
+ subheap->heap, pPrev, pArena );
return FALSE;
}
}
@@ -999,7 +995,7 @@ static BOOL HEAP_IsRealArena( HEAP *heap
ret = FALSE;
break;
}
- ptr += sizeof(ARENA_FREE) + (*(DWORD *)ptr & ARENA_SIZE_MASK);
+ ptr += sizeof(ARENA_FREE) + (*(SIZE_T *)ptr & ARENA_SIZE_MASK);
}
else
{
@@ -1007,7 +1003,7 @@ static BOOL HEAP_IsRealArena( HEAP *heap
ret = FALSE;
break;
}
- ptr += sizeof(ARENA_INUSE) + (*(DWORD *)ptr & ARENA_SIZE_MASK);
+ ptr += sizeof(ARENA_INUSE) + (*(SIZE_T *)ptr & ARENA_SIZE_MASK);
}
}
subheap = subheap->next;
@@ -1035,7 +1031,7 @@ static BOOL HEAP_IsRealArena( HEAP *heap
* Success: A HANDLE to the newly created heap.
* Failure: a NULL HANDLE.
*/
-HANDLE WINAPI RtlCreateHeap( ULONG flags, PVOID addr, ULONG totalSize, ULONG commitSize,
+HANDLE WINAPI RtlCreateHeap( ULONG flags, PVOID addr, SIZE_T totalSize, SIZE_T commitSize,
PVOID unknown, PRTL_HEAP_DEFINITION definition )
{
SUBHEAP *subheap;
@@ -1101,7 +1097,7 @@ HANDLE WINAPI RtlDestroyHeap( HANDLE hea
while (subheap)
{
SUBHEAP *next = subheap->next;
- ULONG size = 0;
+ SIZE_T size = 0;
void *addr = subheap;
NtFreeVirtualMemory( NtCurrentProcess(), &addr, &size, MEM_RELEASE );
subheap = next;
@@ -1127,13 +1123,13 @@ HANDLE WINAPI RtlDestroyHeap( HANDLE hea
* NOTES
* This call does not SetLastError().
*/
-PVOID WINAPI RtlAllocateHeap( HANDLE heap, ULONG flags, ULONG size )
+PVOID WINAPI RtlAllocateHeap( HANDLE heap, ULONG flags, SIZE_T size )
{
ARENA_FREE *pArena;
ARENA_INUSE *pInUse;
SUBHEAP *subheap;
HEAP *heapPtr = HEAP_GetPtr( heap );
- ULONG rounded_size;
+ SIZE_T rounded_size;
/* Validate the parameters */
@@ -1181,8 +1177,7 @@ PVOID WINAPI RtlAllocateHeap( HANDLE hea
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
- TRACE("(%p,%08lx,%08lx): returning %08lx\n",
- heap, flags, size, (DWORD)(pInUse + 1) );
+ TRACE("(%p,%08lx,%08lx): returning %p\n", heap, flags, size, pInUse + 1 );
return (LPVOID)(pInUse + 1);
}
@@ -1225,8 +1220,7 @@ BOOLEAN WINAPI RtlFreeHeap( HANDLE heap,
{
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_INVALID_PARAMETER );
- TRACE("(%p,%08lx,%08lx): returning FALSE\n",
- heap, flags, (DWORD)ptr );
+ TRACE("(%p,%08lx,%p): returning FALSE\n", heap, flags, ptr );
return FALSE;
}
@@ -1238,8 +1232,7 @@ BOOLEAN WINAPI RtlFreeHeap( HANDLE heap,
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
- TRACE("(%p,%08lx,%08lx): returning TRUE\n",
- heap, flags, (DWORD)ptr );
+ TRACE("(%p,%08lx,%p): returning TRUE\n", heap, flags, ptr );
return TRUE;
}
@@ -1259,13 +1252,12 @@ BOOLEAN WINAPI RtlFreeHeap( HANDLE heap,
* Success: A pointer to the resized block (which may be different).
* Failure: NULL.
*/
-PVOID WINAPI RtlReAllocateHeap( HANDLE heap, ULONG flags, PVOID ptr, ULONG size )
+PVOID WINAPI RtlReAllocateHeap( HANDLE heap, ULONG flags, PVOID ptr, SIZE_T size )
{
ARENA_INUSE *pArena;
- DWORD oldSize;
HEAP *heapPtr;
SUBHEAP *subheap;
- ULONG rounded_size;
+ SIZE_T oldSize, rounded_size;
if (!ptr) return NULL;
if (!(heapPtr = HEAP_GetPtr( heap )))
@@ -1287,8 +1279,7 @@ PVOID WINAPI RtlReAllocateHeap( HANDLE h
{
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_INVALID_PARAMETER );
- TRACE("(%p,%08lx,%08lx,%08lx): returning NULL\n",
- heap, flags, (DWORD)ptr, size );
+ TRACE("(%p,%08lx,%p,%08lx): returning NULL\n", heap, flags, ptr, size );
return NULL;
}
@@ -1302,7 +1293,7 @@ PVOID WINAPI RtlReAllocateHeap( HANDLE h
char *pNext = (char *)(pArena + 1) + oldSize;
if ((pNext < (char *)subheap + subheap->size) &&
(*(DWORD *)pNext & ARENA_FLAG_FREE) &&
- (oldSize + (*(DWORD *)pNext & ARENA_SIZE_MASK) + sizeof(ARENA_FREE) >= rounded_size))
+ (oldSize + (*(SIZE_T *)pNext & ARENA_SIZE_MASK) + sizeof(ARENA_FREE) >= rounded_size))
{
/* The next block is free and large enough */
ARENA_FREE *pFree = (ARENA_FREE *)pNext;
@@ -1373,8 +1364,7 @@ PVOID WINAPI RtlReAllocateHeap( HANDLE h
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
- TRACE("(%p,%08lx,%08lx,%08lx): returning %08lx\n",
- heap, flags, (DWORD)ptr, size, (DWORD)(pArena + 1) );
+ TRACE("(%p,%08lx,%p,%08lx): returning %p\n", heap, flags, ptr, size, pArena + 1 );
return (LPVOID)(pArena + 1);
}
@@ -1460,15 +1450,15 @@ BOOLEAN WINAPI RtlUnlockHeap( HANDLE hea
* NOTES
* The size may be bigger than what was passed to RtlAllocateHeap().
*/
-ULONG WINAPI RtlSizeHeap( HANDLE heap, ULONG flags, PVOID ptr )
+SIZE_T WINAPI RtlSizeHeap( HANDLE heap, ULONG flags, PVOID ptr )
{
- DWORD ret;
+ SIZE_T ret;
HEAP *heapPtr = HEAP_GetPtr( heap );
if (!heapPtr)
{
RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_INVALID_HANDLE );
- return (ULONG)-1;
+ return (SIZE_T)-1;
}
flags &= HEAP_NO_SERIALIZE;
flags |= heapPtr->flags;
@@ -1476,7 +1466,7 @@ ULONG WINAPI RtlSizeHeap( HANDLE heap, U
if (!HEAP_IsRealArena( heapPtr, HEAP_NO_SERIALIZE, ptr, QUIET ))
{
RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_INVALID_PARAMETER );
- ret = (ULONG)-1;
+ ret = (SIZE_T)-1;
}
else
{
@@ -1485,8 +1475,7 @@ ULONG WINAPI RtlSizeHeap( HANDLE heap, U
}
if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
- TRACE("(%p,%08lx,%08lx): returning %08lx\n",
- heap, flags, (DWORD)ptr, ret );
+ TRACE("(%p,%08lx,%p): returning %08lx\n", heap, flags, ptr, ret );
return ret;
}
@@ -1640,7 +1629,7 @@ HW_end:
*/
ULONG WINAPI RtlGetProcessHeaps( ULONG count, HANDLE *heaps )
{
- DWORD total;
+ ULONG total;
HEAP *ptr;
if (!processHeap) return 0; /* should never happen */
diff -up cvs/hq/wine/dlls/ntdll/ntdll_misc.h wine/dlls/ntdll/ntdll_misc.h
--- cvs/hq/wine/dlls/ntdll/ntdll_misc.h 2005-06-27 12:29:37.000000000 +0900
+++ wine/dlls/ntdll/ntdll_misc.h 2005-07-13 17:59:01.000000000 +0900
@@ -87,7 +87,7 @@ extern NTSTATUS FILE_GetNtStatus(void);
extern BOOL DIR_is_hidden_file( const UNICODE_STRING *name );
/* virtual memory */
-extern DWORD VIRTUAL_HandleFault(LPCVOID addr);
+extern NTSTATUS VIRTUAL_HandleFault(LPCVOID addr);
extern BOOL VIRTUAL_HasMapping( LPCVOID addr );
extern void VIRTUAL_UseLargeAddressSpace(void);
diff -up cvs/hq/wine/dlls/ntdll/virtual.c wine/dlls/ntdll/virtual.c
--- cvs/hq/wine/dlls/ntdll/virtual.c 2005-07-07 18:13:17.000000000 +0900
+++ wine/dlls/ntdll/virtual.c 2005-07-13 17:59:01.000000000 +0900
@@ -67,7 +67,7 @@ typedef struct file_view
{
struct list entry; /* Entry in global view list */
void *base; /* Base address */
- UINT size; /* Size in bytes */
+ size_t size; /* Size in bytes */
HANDLE mapping; /* Handle to the file mapping */
BYTE flags; /* Allocation flags (VFLAG_*) */
BYTE protect; /* Protection for all pages at allocation time */
@@ -532,7 +532,7 @@ static BYTE VIRTUAL_GetProt( DWORD prote
*/
static BOOL VIRTUAL_SetProt( FILE_VIEW *view, /* [in] Pointer to view */
void *base, /* [in] Starting address */
- UINT size, /* [in] Size in bytes */
+ size_t size, /* [in] Size in bytes */
BYTE vprot ) /* [in] Protections to use */
{
TRACE("%p-%p %s\n",
@@ -611,9 +611,9 @@ static NTSTATUS map_view( struct file_vi
/* Release the extra memory while keeping the range
* starting on the granularity boundary. */
- if ((unsigned int)ptr & granularity_mask)
+ if ((ULONG_PTR)ptr & granularity_mask)
{
- unsigned int extra = granularity_mask + 1 - ((unsigned int)ptr & granularity_mask);
+ size_t extra = granularity_mask + 1 - ((ULONG_PTR)ptr & granularity_mask);
munmap( ptr, extra );
ptr = (char *)ptr + extra;
view_size -= extra;
@@ -753,7 +753,7 @@ static NTSTATUS decommit_pages( struct f
* Apply the relocations to a mapped PE image
*/
static int do_relocations( char *base, const IMAGE_DATA_DIRECTORY *dir,
- int delta, DWORD total_size )
+ int delta, SIZE_T total_size )
{
IMAGE_BASE_RELOCATION *rel;
@@ -816,8 +816,8 @@ static int do_relocations( char *base, c
*
* Map an executable (PE format) image into memory.
*/
-static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, DWORD total_size,
- DWORD header_size, int shared_fd, BOOL removable, PVOID *addr_ptr )
+static NTSTATUS map_image( HANDLE hmapping, int fd, char *base, SIZE_T total_size,
+ SIZE_T header_size, int shared_fd, BOOL removable, PVOID *addr_ptr )
{
IMAGE_DOS_HEADER *dos;
IMAGE_NT_HEADERS *nt;
@@ -920,7 +920,7 @@ static NTSTATUS map_image( HANDLE hmappi
for (i = pos = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
{
- DWORD size;
+ SIZE_T size;
/* a few sanity checks */
size = sec->VirtualAddress + ROUND_SIZE( sec->VirtualAddress, sec->Misc.VirtualSize );
@@ -1031,7 +1031,7 @@ static NTSTATUS map_image( HANDLE hmappi
sec = (IMAGE_SECTION_HEADER*)((char *)&nt->OptionalHeader+nt->FileHeader.SizeOfOptionalHeader);
for (i = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
{
- DWORD size = ROUND_SIZE( sec->VirtualAddress, sec->Misc.VirtualSize );
+ SIZE_T size = ROUND_SIZE( sec->VirtualAddress, sec->Misc.VirtualSize );
BYTE vprot = VPROT_COMMITTED;
if (sec->Characteristics & IMAGE_SCN_MEM_READ) vprot |= VPROT_READ;
if (sec->Characteristics & IMAGE_SCN_MEM_WRITE) vprot |= VPROT_READ|VPROT_WRITECOPY;
@@ -1097,10 +1097,10 @@ void virtual_init(void)
/***********************************************************************
* VIRTUAL_HandleFault
*/
-DWORD VIRTUAL_HandleFault( LPCVOID addr )
+NTSTATUS VIRTUAL_HandleFault( LPCVOID addr )
{
FILE_VIEW *view;
- DWORD ret = EXCEPTION_ACCESS_VIOLATION;
+ NTSTATUS ret = EXCEPTION_ACCESS_VIOLATION;
RtlEnterCriticalSection( &csVirtual );
if ((view = VIRTUAL_FindView( addr )))
@@ -1158,11 +1158,11 @@ void VIRTUAL_UseLargeAddressSpace(void)
* ZwAllocateVirtualMemory (NTDLL.@)
*/
NTSTATUS WINAPI NtAllocateVirtualMemory( HANDLE process, PVOID *ret, ULONG zero_bits,
- ULONG *size_ptr, ULONG type, ULONG protect )
+ SIZE_T *size_ptr, ULONG type, ULONG protect )
{
void *base;
BYTE vprot;
- DWORD size = *size_ptr;
+ SIZE_T size = *size_ptr;
NTSTATUS status = STATUS_SUCCESS;
struct file_view *view;
@@ -1267,13 +1267,13 @@ NTSTATUS WINAPI NtAllocateVirtualMemory(
* NtFreeVirtualMemory (NTDLL.@)
* ZwFreeVirtualMemory (NTDLL.@)
*/
-NTSTATUS WINAPI NtFreeVirtualMemory( HANDLE process, PVOID *addr_ptr, ULONG *size_ptr, ULONG type )
+NTSTATUS WINAPI NtFreeVirtualMemory( HANDLE process, PVOID *addr_ptr, SIZE_T *size_ptr, ULONG type )
{
FILE_VIEW *view;
char *base;
NTSTATUS status = STATUS_SUCCESS;
LPVOID addr = *addr_ptr;
- DWORD size = *size_ptr;
+ SIZE_T size = *size_ptr;
TRACE("%p %p %08lx %lx\n", process, addr, size, type );
@@ -1340,7 +1340,7 @@ NTSTATUS WINAPI NtFreeVirtualMemory( HAN
* NtProtectVirtualMemory (NTDLL.@)
* ZwProtectVirtualMemory (NTDLL.@)
*/
-NTSTATUS WINAPI NtProtectVirtualMemory( HANDLE process, PVOID *addr_ptr, ULONG *size_ptr,
+NTSTATUS WINAPI NtProtectVirtualMemory( HANDLE process, PVOID *addr_ptr, SIZE_T *size_ptr,
ULONG new_prot, ULONG *old_prot )
{
FILE_VIEW *view;
@@ -1348,7 +1348,8 @@ NTSTATUS WINAPI NtProtectVirtualMemory(
char *base;
UINT i;
BYTE vprot, *p;
- DWORD prot, size = *size_ptr;
+ ULONG prot;
+ SIZE_T size = *size_ptr;
LPVOID addr = *addr_ptr;
TRACE("%p %p %08lx %08lx\n", process, addr, size, new_prot );
@@ -1417,7 +1418,7 @@ NTSTATUS WINAPI NtQueryVirtualMemory( HA
FILE_VIEW *view;
char *base, *alloc_base = 0;
struct list *ptr;
- UINT size = 0;
+ SIZE_T size = 0;
MEMORY_BASIC_INFORMATION *info = buffer;
if (info_class != MemoryBasicInformation)
@@ -1519,7 +1520,7 @@ NTSTATUS WINAPI NtQueryVirtualMemory( HA
* NtLockVirtualMemory (NTDLL.@)
* ZwLockVirtualMemory (NTDLL.@)
*/
-NTSTATUS WINAPI NtLockVirtualMemory( HANDLE process, PVOID *addr, ULONG *size, ULONG unknown )
+NTSTATUS WINAPI NtLockVirtualMemory( HANDLE process, PVOID *addr, SIZE_T *size, ULONG unknown )
{
if (!is_current_process( process ))
{
@@ -1534,7 +1535,7 @@ NTSTATUS WINAPI NtLockVirtualMemory( HAN
* NtUnlockVirtualMemory (NTDLL.@)
* ZwUnlockVirtualMemory (NTDLL.@)
*/
-NTSTATUS WINAPI NtUnlockVirtualMemory( HANDLE process, PVOID *addr, ULONG *size, ULONG unknown )
+NTSTATUS WINAPI NtUnlockVirtualMemory( HANDLE process, PVOID *addr, SIZE_T *size, ULONG unknown )
{
if (!is_current_process( process ))
{
@@ -1617,25 +1618,25 @@ NTSTATUS WINAPI NtOpenSection( HANDLE *h
* ZwMapViewOfSection (NTDLL.@)
*/
NTSTATUS WINAPI NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_ptr, ULONG zero_bits,
- ULONG commit_size, const LARGE_INTEGER *offset_ptr, ULONG *size_ptr,
+ SIZE_T commit_size, const LARGE_INTEGER *offset_ptr, SIZE_T *size_ptr,
SECTION_INHERIT inherit, ULONG alloc_type, ULONG protect )
{
IO_STATUS_BLOCK io;
FILE_FS_DEVICE_INFORMATION device_info;
NTSTATUS res;
- UINT size = 0;
+ SIZE_T size = 0;
int unix_handle = -1;
int prot;
void *base;
struct file_view *view;
- DWORD size_low, size_high, header_size, shared_size;
+ SIZE_T size_low, size_high, header_size, shared_size;
HANDLE shared_file;
BOOL removable = FALSE;
LARGE_INTEGER offset;
offset.QuadPart = offset_ptr ? offset_ptr->QuadPart : 0;
- TRACE("handle=%p process=%p addr=%p off=%lx%08lx size=%x access=%lx\n",
+ TRACE("handle=%p process=%p addr=%p off=%lx%08lx size=%lx access=%lx\n",
handle, process, *addr_ptr, offset.u.HighPart, offset.u.LowPart, size, protect );
if (!is_current_process( process ))
@@ -1752,7 +1753,7 @@ NTSTATUS WINAPI NtMapViewOfSection( HAND
/* Map the file */
- TRACE("handle=%p size=%x offset=%lx%08lx\n",
+ TRACE("handle=%p size=%lx offset=%lx%08lx\n",
handle, size, offset.u.HighPart, offset.u.LowPart );
res = map_file_into_view( view, unix_handle, 0, size, offset.QuadPart, prot, removable );
@@ -1768,7 +1769,7 @@ NTSTATUS WINAPI NtMapViewOfSection( HAND
}
else
{
- ERR( "map_file_into_view %p %x %lx%08lx failed\n",
+ ERR( "map_file_into_view %p %lx %lx%08lx failed\n",
view->base, size, offset.u.HighPart, offset.u.LowPart );
delete_view( view );
}
@@ -1812,7 +1813,7 @@ NTSTATUS WINAPI NtUnmapViewOfSection( HA
* ZwFlushVirtualMemory (NTDLL.@)
*/
NTSTATUS WINAPI NtFlushVirtualMemory( HANDLE process, LPCVOID *addr_ptr,
- ULONG *size_ptr, ULONG unknown )
+ SIZE_T *size_ptr, ULONG unknown )
{
FILE_VIEW *view;
NTSTATUS status = STATUS_SUCCESS;
@@ -1866,14 +1867,14 @@ NTSTATUS WINAPI NtWriteVirtualMemory( HA
SIZE_T size, SIZE_T *bytes_written )
{
static const unsigned int zero;
- unsigned int first_offset, last_offset, first_mask, last_mask;
+ SIZE_T first_offset, last_offset, first_mask, last_mask;
NTSTATUS status;
if (!size) return STATUS_INVALID_PARAMETER;
/* compute the mask for the first int */
first_mask = ~0;
- first_offset = (unsigned int)addr % sizeof(int);
+ first_offset = (ULONG_PTR)addr % sizeof(int);
memset( &first_mask, 0, first_offset );
/* compute the mask for the last int */
diff -up cvs/hq/wine/include/winternl.h wine/include/winternl.h
--- cvs/hq/wine/include/winternl.h 2005-07-13 17:56:50.000000000 +0900
+++ wine/include/winternl.h 2005-07-13 17:59:01.000000000 +0900
@@ -1689,7 +1689,7 @@ NTSTATUS WINAPI NtAlertResumeThread(HAN
NTSTATUS WINAPI NtAlertThread(HANDLE ThreadHandle);
NTSTATUS WINAPI NtAllocateLocallyUniqueId(PLUID lpLuid);
NTSTATUS WINAPI NtAllocateUuids(PULARGE_INTEGER,PULONG,PULONG);
-NTSTATUS WINAPI NtAllocateVirtualMemory(HANDLE,PVOID*,ULONG,ULONG*,ULONG,ULONG);
+NTSTATUS WINAPI NtAllocateVirtualMemory(HANDLE,PVOID*,ULONG,SIZE_T*,ULONG,ULONG);
NTSTATUS WINAPI NtCallbackReturn(PVOID,ULONG,NTSTATUS);
NTSTATUS WINAPI NtCancelIoFile(HANDLE,PIO_STATUS_BLOCK);
NTSTATUS WINAPI NtCancelTimer(HANDLE, BOOLEAN*);
@@ -1734,9 +1734,9 @@ NTSTATUS WINAPI NtFindAtom(const WCHAR*
NTSTATUS WINAPI NtFlushBuffersFile(HANDLE,IO_STATUS_BLOCK*);
NTSTATUS WINAPI NtFlushInstructionCache(HANDLE,LPCVOID,ULONG);
NTSTATUS WINAPI NtFlushKey(HANDLE);
-NTSTATUS WINAPI NtFlushVirtualMemory(HANDLE,LPCVOID*,ULONG*,ULONG);
+NTSTATUS WINAPI NtFlushVirtualMemory(HANDLE,LPCVOID*,SIZE_T*,ULONG);
NTSTATUS WINAPI NtFlushWriteBuffer(VOID);
-NTSTATUS WINAPI NtFreeVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
+NTSTATUS WINAPI NtFreeVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
NTSTATUS WINAPI NtFsControlFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,PVOID,ULONG,PVOID,ULONG);
NTSTATUS WINAPI NtGetContextThread(HANDLE,CONTEXT*);
NTSTATUS WINAPI NtGetPlugPlayEvent(ULONG,ULONG,PVOID,ULONG);
@@ -1750,9 +1750,9 @@ NTSTATUS WINAPI NtListenPort(HANDLE,PLP
NTSTATUS WINAPI NtLoadDriver(const UNICODE_STRING *);
NTSTATUS WINAPI NtLoadKey(const OBJECT_ATTRIBUTES *,OBJECT_ATTRIBUTES *);
NTSTATUS WINAPI NtLockFile(HANDLE,HANDLE,PIO_APC_ROUTINE,void*,PIO_STATUS_BLOCK,PLARGE_INTEGER,PLARGE_INTEGER,ULONG*,BOOLEAN,BOOLEAN);
-NTSTATUS WINAPI NtLockVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
+NTSTATUS WINAPI NtLockVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
NTSTATUS WINAPI NtMakeTemporaryObject(HANDLE);
-NTSTATUS WINAPI NtMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,ULONG,const LARGE_INTEGER*,ULONG*,SECTION_INHERIT,ULONG,ULONG);
+NTSTATUS WINAPI NtMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,SIZE_T,const LARGE_INTEGER*,SIZE_T*,SECTION_INHERIT,ULONG,ULONG);
NTSTATUS WINAPI NtNotifyChangeDirectoryFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,ULONG,BOOLEAN);
NTSTATUS WINAPI NtNotifyChangeKey(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,BOOLEAN,PVOID,ULONG,BOOLEAN);
NTSTATUS WINAPI NtOpenDirectoryObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
@@ -1775,7 +1775,7 @@ NTSTATUS WINAPI NtPowerInformation(POWE
NTSTATUS WINAPI NtPrivilegeCheck(HANDLE,PPRIVILEGE_SET,PBOOLEAN);
NTSTATUS WINAPI NtPrivilegeObjectAuditAlarm(PUNICODE_STRING,HANDLE,HANDLE,ULONG,PPRIVILEGE_SET,BOOLEAN);
NTSTATUS WINAPI NtPrivilegedServiceAuditAlarm(PUNICODE_STRING,PUNICODE_STRING,HANDLE,PPRIVILEGE_SET,BOOLEAN);
-NTSTATUS WINAPI NtProtectVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG,ULONG*);
+NTSTATUS WINAPI NtProtectVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG,ULONG*);
NTSTATUS WINAPI NtPulseEvent(HANDLE,PULONG);
NTSTATUS WINAPI NtQueueApcThread(HANDLE,PNTAPCFUNC,ULONG_PTR,ULONG_PTR,ULONG_PTR);
NTSTATUS WINAPI NtQueryAttributesFile(const OBJECT_ATTRIBUTES*,FILE_BASIC_INFORMATION*);
@@ -1878,7 +1878,7 @@ NTSTATUS WINAPI NtUnloadDriver(const UN
NTSTATUS WINAPI NtUnloadKey(HANDLE);
NTSTATUS WINAPI NtUnloadKeyEx(POBJECT_ATTRIBUTES,HANDLE);
NTSTATUS WINAPI NtUnlockFile(HANDLE,PIO_STATUS_BLOCK,PLARGE_INTEGER,PLARGE_INTEGER,PULONG);
-NTSTATUS WINAPI NtUnlockVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
+NTSTATUS WINAPI NtUnlockVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
NTSTATUS WINAPI NtUnmapViewOfSection(HANDLE,PVOID);
NTSTATUS WINAPI NtVdmControl(ULONG,PVOID);
NTSTATUS WINAPI NtWaitForSingleObject(HANDLE,BOOLEAN,const LARGE_INTEGER*);
@@ -1905,7 +1905,7 @@ PVOID WINAPI RtlAddVectoredException
NTSTATUS WINAPI RtlAdjustPrivilege(ULONG,BOOLEAN,BOOLEAN,PBOOLEAN);
NTSTATUS WINAPI RtlAllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,PSID *);
RTL_HANDLE * WINAPI RtlAllocateHandle(RTL_HANDLE_TABLE *,ULONG *);
-PVOID WINAPI RtlAllocateHeap(HANDLE,ULONG,ULONG);
+PVOID WINAPI RtlAllocateHeap(HANDLE,ULONG,SIZE_T);
WCHAR WINAPI RtlAnsiCharToUnicodeChar(LPSTR *);
DWORD WINAPI RtlAnsiStringToUnicodeSize(const STRING *);
NTSTATUS WINAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING,PCANSI_STRING,BOOLEAN);
@@ -1939,7 +1939,7 @@ void WINAPI RtlCopyUnicodeString(UN
NTSTATUS WINAPI RtlCreateAcl(PACL,DWORD,DWORD);
NTSTATUS WINAPI RtlCreateAtomTable(ULONG,RTL_ATOM_TABLE*);
NTSTATUS WINAPI RtlCreateEnvironment(BOOLEAN, PWSTR*);
-HANDLE WINAPI RtlCreateHeap(ULONG,PVOID,ULONG,ULONG,PVOID,PRTL_HEAP_DEFINITION);
+HANDLE WINAPI RtlCreateHeap(ULONG,PVOID,SIZE_T,SIZE_T,PVOID,PRTL_HEAP_DEFINITION);
NTSTATUS WINAPI RtlCreateProcessParameters(RTL_USER_PROCESS_PARAMETERS**,const UNICODE_STRING*,
const UNICODE_STRING*,const UNICODE_STRING*,
const UNICODE_STRING*,PWSTR,const UNICODE_STRING*,
@@ -2104,7 +2104,7 @@ NTSTATUS WINAPI RtlQueryTimeZoneInforma
void WINAPI RtlRaiseException(PEXCEPTION_RECORD);
void WINAPI RtlRaiseStatus(NTSTATUS);
ULONG WINAPI RtlRandom(PULONG);
-PVOID WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,ULONG);
+PVOID WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,SIZE_T);
void WINAPI RtlReleasePebLock(void);
void WINAPI RtlReleaseResource(LPRTL_RWLOCK);
ULONG WINAPI RtlRemoveVectoredExceptionHandler(PVOID);
@@ -2127,7 +2127,7 @@ void WINAPI RtlSetLastWin32Error(DW
void WINAPI RtlSetLastWin32ErrorAndNtStatusFromNtStatus(NTSTATUS);
NTSTATUS WINAPI RtlSetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
NTSTATUS WINAPI RtlSetTimeZoneInformation(const RTL_TIME_ZONE_INFORMATION*);
-ULONG WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
+SIZE_T WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
NTSTATUS WINAPI RtlStringFromGUID(REFGUID,PUNICODE_STRING);
LPDWORD WINAPI RtlSubAuthoritySid(PSID,DWORD);
LPBYTE WINAPI RtlSubAuthorityCountSid(PSID);
More information about the wine-patches
mailing list