[PATCH 09/12] kernelbase: Handle LMEM_DISCARDABLE flag specifically in LocalReAlloc.

[Rémi Bernon]

From: Rémi Bernon

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=53474
---
 dlls/kernel32/tests/heap.c | 93 +++++++++++++++++---------------------
 dlls/kernelbase/memory.c   |  2 +
 2 files changed, 44 insertions(+), 51 deletions(-)

diff --git a/dlls/kernel32/tests/heap.c b/dlls/kernel32/tests/heap.c
index 9f65a7c6fc9..c048faa7d12 100644
--- a/dlls/kernel32/tests/heap.c
+++ b/dlls/kernel32/tests/heap.c
@@ -1724,7 +1724,7 @@ static void test_GlobalAlloc(void)
         {
             ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
             if (flags == GMEM_MODIFY) ok( tmp_mem == mem, "GlobalReAlloc returned %p\n", tmp_mem );
-            else if (flags != GMEM_MOVEABLE) todo_wine_if(flags) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
+            else if (flags != GMEM_MOVEABLE) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
             else ok( tmp_mem != mem, "GlobalReAlloc returned %p\n", tmp_mem );
         }
         else
@@ -1739,11 +1739,7 @@ static void test_GlobalAlloc(void)

size = GlobalSize( mem );
         if (flags == GMEM_MOVEABLE) ok( size == 512, "GlobalSize returned %Iu\n", size );
-        else
-        {
-            todo_wine_if((flags & GMEM_DISCARDABLE) && !(flags & GMEM_MODIFY))
-            ok( size == 10, "GlobalSize returned %Iu\n", size );
-        }
+        else ok( size == 10, "GlobalSize returned %Iu\n", size );

mem = GlobalFree( mem );
         ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
@@ -1758,7 +1754,7 @@ static void test_GlobalAlloc(void)
         {
             ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
             if (flags == GMEM_MODIFY) ok( tmp_mem == mem, "GlobalReAlloc returned %p\n", tmp_mem );
-            else if (flags != GMEM_MOVEABLE) todo_wine_if(flags) ok( !tmp_mem || broken( tmp_mem == mem ) /* w8 */, "GlobalReAlloc succeeded\n" );
+            else if (flags != GMEM_MOVEABLE) ok( !tmp_mem || broken( tmp_mem == mem ) /* w8 */, "GlobalReAlloc succeeded\n" );
             else todo_wine ok( tmp_mem != mem, "GlobalReAlloc returned %p\n", tmp_mem );
         }
         else
@@ -1773,11 +1769,7 @@ static void test_GlobalAlloc(void)

size = GlobalSize( mem );
         if (flags == GMEM_MOVEABLE) ok( size == 10, "GlobalSize returned %Iu\n", size );
-        else if (flags)
-        {
-            todo_wine_if((flags & GMEM_DISCARDABLE) && (flags & (GMEM_MODIFY | GMEM_MOVEABLE | GMEM_DISCARDABLE)) != (GMEM_MODIFY | GMEM_MOVEABLE | GMEM_DISCARDABLE))
-            ok( size == 12, "GlobalSize returned %Iu\n", size );
-        }
+        else if (flags) ok( size == 12, "GlobalSize returned %Iu\n", size );
         else ok( size == 12 || broken( size == 10 ) /* w8 */, "GlobalSize returned %Iu\n", size );

mem = GlobalFree( mem );
@@ -1793,7 +1785,7 @@ static void test_GlobalAlloc(void)
         {
             ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
             if (flags == GMEM_MODIFY) ok( tmp_mem == mem, "GlobalReAlloc returned %p\n", tmp_mem );
-            else if (flags != GMEM_MOVEABLE) todo_wine_if(flags) ok( !tmp_mem || broken( tmp_mem == mem ) /* w8 */, "GlobalReAlloc succeeded\n" );
+            else if (flags != GMEM_MOVEABLE) ok( !tmp_mem || broken( tmp_mem == mem ) /* w8 */, "GlobalReAlloc succeeded\n" );
             else todo_wine ok( tmp_mem != mem, "GlobalReAlloc returned %p\n", tmp_mem );
         }
         else
@@ -1808,11 +1800,7 @@ static void test_GlobalAlloc(void)

size = GlobalSize( mem );
         if (flags == GMEM_MOVEABLE) ok( size == 0 || broken( size == 1 ) /* w7 */, "GlobalSize returned %Iu\n", size );
-        else if (flags)
-        {
-            todo_wine_if((flags & GMEM_MOVEABLE) && !(flags & GMEM_MODIFY))
-            ok( size == 12, "GlobalSize returned %Iu\n", size );
-        }
+        else if (flags) ok( size == 12, "GlobalSize returned %Iu\n", size );
         else ok( size == 12 || broken( size == 0 ) /* w8 */, "GlobalSize returned %Iu\n", size );

mem = GlobalFree( mem );
@@ -1916,19 +1904,19 @@ static void test_GlobalAlloc(void)

tmp_mem = GlobalReAlloc( mem, 512, flags );
         if (!(flags & GMEM_MODIFY) && (flags & GMEM_DISCARDABLE))
-            todo_wine ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
+            ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
         else
             ok( tmp_mem == mem, "GlobalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
         entry = *mem_entry_from_HANDLE( mem );
         if ((flags & GMEM_DISCARDABLE) && (flags & GMEM_MODIFY)) expect_entry.flags |= 4;
         if ((flags & GMEM_DISCARDABLE) || (flags & GMEM_MODIFY))
-            todo_wine_if(!(flags & GMEM_MODIFY)) ok( entry.ptr == expect_entry.ptr, "got ptr %p\n", entry.ptr );
+            ok( entry.ptr == expect_entry.ptr, "got ptr %p\n", entry.ptr );
         else
             ok( entry.ptr != expect_entry.ptr, "got unexpected ptr %p\n", entry.ptr );
         ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
         size = GlobalSize( mem );
         if ((flags & GMEM_DISCARDABLE) || (flags & GMEM_MODIFY))
-            todo_wine_if(!(flags & GMEM_MODIFY)) ok( size == 10, "GlobalSize returned %Iu\n", size );
+            ok( size == 10, "GlobalSize returned %Iu\n", size );
         else
             ok( size == 512, "GlobalSize returned %Iu\n", size );

@@ -1943,7 +1931,7 @@ static void test_GlobalAlloc(void)

tmp_mem = GlobalReAlloc( mem, 10, flags );
         if (!(flags & GMEM_MODIFY) && (flags & GMEM_DISCARDABLE))
-            todo_wine ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
+            ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
         else
             ok( tmp_mem == mem, "GlobalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
         entry = *mem_entry_from_HANDLE( mem );
@@ -1952,7 +1940,7 @@ static void test_GlobalAlloc(void)
         ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
         size = GlobalSize( mem );
         if ((flags & GMEM_DISCARDABLE) || (flags & GMEM_MODIFY))
-            todo_wine_if(!(flags & GMEM_MODIFY)) ok( size == 12, "GlobalSize returned %Iu\n", size );
+            ok( size == 12, "GlobalSize returned %Iu\n", size );
         else
             ok( size == 10, "GlobalSize returned %Iu\n", size );

@@ -1969,7 +1957,7 @@ static void test_GlobalAlloc(void)
         if (flags == GMEM_FIXED)
             todo_wine ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
         else if (!(flags & GMEM_MODIFY) && (flags & GMEM_DISCARDABLE))
-            todo_wine ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
+            ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
         else
             ok( tmp_mem == mem, "GlobalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
         entry = *mem_entry_from_HANDLE( mem );
@@ -1979,13 +1967,13 @@ static void test_GlobalAlloc(void)
             expect_entry.ptr = NULL;
         }
         else if ((flags & GMEM_DISCARDABLE) && (flags & GMEM_MODIFY)) expect_entry.flags |= 4;
-        todo_wine_if(!(flags & GMEM_MODIFY) && (flags != GMEM_MOVEABLE))
+        todo_wine_if(!flags)
         ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
-        todo_wine_if(!(flags & GMEM_MODIFY) && (flags != GMEM_MOVEABLE))
+        todo_wine_if(!flags)
         ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
         size = GlobalSize( mem );
         if (flags == GMEM_MOVEABLE) ok( size == 0, "GlobalSize returned %Iu\n", size );
-        else todo_wine_if(!(flags & GMEM_MODIFY)) ok( size == 12, "GlobalSize returned %Iu\n", size );
+        else todo_wine_if(!flags) ok( size == 12, "GlobalSize returned %Iu\n", size );

mem = GlobalFree( mem );
         ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
@@ -2401,13 +2389,13 @@ static void test_LocalAlloc(void)
         tmp_mem = LocalReAlloc( mem, 512, flags );
         ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
         if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
-        else if (flags != LMEM_MOVEABLE) todo_wine_if(flags) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
+        else if (flags != LMEM_MOVEABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
         else ok( tmp_mem != mem, "LocalReAlloc returned %p\n", tmp_mem );
         if (tmp_mem) mem = tmp_mem;

size = LocalSize( mem );
         if (flags == LMEM_MOVEABLE) ok( size == 512, "LocalSize returned %Iu\n", size );
-        else todo_wine_if(flags && !(flags & LMEM_MODIFY)) ok( size == 10, "LocalSize returned %Iu\n", size );
+        else ok( size == 10, "LocalSize returned %Iu\n", size );

mem = LocalFree( mem );
         ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
@@ -2420,13 +2408,13 @@ static void test_LocalAlloc(void)
         tmp_mem = LocalReAlloc( mem, 10, flags );
         ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
         if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
-        else if (flags != LMEM_MOVEABLE) todo_wine_if(flags) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
+        else if (flags != LMEM_MOVEABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
         else todo_wine ok( tmp_mem != mem, "LocalReAlloc returned %p\n", tmp_mem );
         if (tmp_mem) mem = tmp_mem;

size = LocalSize( mem );
         if (flags == LMEM_MOVEABLE) ok( size == 10, "LocalSize returned %Iu\n", size );
-        else if (flags) todo_wine_if(!(flags & LMEM_MODIFY)) ok( size == 12, "LocalSize returned %Iu\n", size );
+        else if (flags) ok( size == 12, "LocalSize returned %Iu\n", size );
         else ok( size == 12, "LocalSize returned %Iu\n", size );

mem = LocalFree( mem );
@@ -2440,13 +2428,13 @@ static void test_LocalAlloc(void)
         tmp_mem = LocalReAlloc( mem, 0, flags );
         ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
         if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
-        else if (flags != LMEM_MOVEABLE) todo_wine_if(flags) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
+        else if (flags != LMEM_MOVEABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
         else todo_wine ok( tmp_mem != mem, "LocalReAlloc returned %p\n", tmp_mem );
         if (tmp_mem) mem = tmp_mem;

size = LocalSize( mem );
         if (flags == LMEM_MOVEABLE) ok( size == 0 || broken( size == 1 ) /* w7 */, "LocalSize returned %Iu\n", size );
-        else if (flags) todo_wine_if(!(flags & LMEM_MODIFY)) ok( size == 12, "LocalSize returned %Iu\n", size );
+        else if (flags) ok( size == 12, "LocalSize returned %Iu\n", size );
         else ok( size == 12, "LocalSize returned %Iu\n", size );

mem = LocalFree( mem );
@@ -2462,17 +2450,17 @@ static void test_LocalAlloc(void)

tmp_mem = LocalReAlloc( mem, 512, flags );
         if (!(flags & LMEM_MODIFY) && ((flags & LMEM_DISCARDABLE) || !(flags & LMEM_MOVEABLE)))
-            todo_wine ok( !tmp_mem, "LocalReAlloc succeeded\n" );
+            todo_wine_if(flags == LMEM_FIXED) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
         else
             ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
         entry = *mem_entry_from_HANDLE( mem );
         if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
         if (flags == LMEM_MOVEABLE) ok( entry.ptr != expect_entry.ptr, "got unexpected ptr %p\n", entry.ptr );
-        else todo_wine_if(!(flags & LMEM_MODIFY)) ok( entry.ptr == expect_entry.ptr, "got ptr %p\n", entry.ptr );
+        else todo_wine_if(flags == LMEM_FIXED) ok( entry.ptr == expect_entry.ptr, "got ptr %p\n", entry.ptr );
         ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
         size = LocalSize( mem );
         if (flags == LMEM_MOVEABLE) ok( size == 512, "LocalSize returned %Iu\n", size );
-        else todo_wine_if(!(flags & LMEM_MODIFY)) ok( size == 10, "LocalSize returned %Iu\n", size );
+        else todo_wine_if(flags == LMEM_FIXED) ok( size == 10, "LocalSize returned %Iu\n", size );

ret = LocalUnlock( mem );
         ok( !ret, "LocalUnlock succeeded\n" );
@@ -2489,7 +2477,7 @@ static void test_LocalAlloc(void)

tmp_mem = LocalReAlloc( mem, 10, flags );
         if (!(flags & LMEM_MODIFY) && (flags & LMEM_DISCARDABLE))
-            todo_wine ok( !tmp_mem, "LocalReAlloc succeeded\n" );
+            ok( !tmp_mem, "LocalReAlloc succeeded\n" );
         else
             ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
         entry = *mem_entry_from_HANDLE( mem );
@@ -2498,7 +2486,7 @@ static void test_LocalAlloc(void)
         ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
         size = LocalSize( mem );
         if ((flags & LMEM_DISCARDABLE) || (flags & LMEM_MODIFY))
-            todo_wine_if(!(flags & LMEM_MODIFY)) ok( size == 12, "LocalSize returned %Iu\n", size );
+            ok( size == 12, "LocalSize returned %Iu\n", size );
         else
             ok( size == 10, "LocalSize returned %Iu\n", size );

@@ -2519,15 +2507,18 @@ static void test_LocalAlloc(void)
         if (flags & LMEM_MODIFY)
             ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
         else
-            todo_wine ok( !tmp_mem, "LocalReAlloc succeeded\n" );
+        {
+            todo_wine_if(flags == LMEM_FIXED || flags == LMEM_MOVEABLE)
+            ok( !tmp_mem, "LocalReAlloc succeeded\n" );
+        }
         entry = *mem_entry_from_HANDLE( mem );
         if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
-        todo_wine_if(!(flags & LMEM_MODIFY))
+        todo_wine_if(flags == LMEM_FIXED || flags == LMEM_MOVEABLE)
         ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
-        todo_wine_if(!(flags & LMEM_MODIFY))
+        todo_wine_if(flags == LMEM_FIXED || flags == LMEM_MOVEABLE)
         ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
         size = LocalSize( mem );
-        todo_wine_if(!(flags & LMEM_MODIFY))
+        todo_wine_if(flags == LMEM_FIXED || flags == LMEM_MOVEABLE)
         ok( size == 12, "LocalSize returned %Iu\n", size );

ret = LocalUnlock( mem );
@@ -2543,19 +2534,19 @@ static void test_LocalAlloc(void)

tmp_mem = LocalReAlloc( mem, 512, flags );
         if (!(flags & LMEM_MODIFY) && (flags & LMEM_DISCARDABLE))
-            todo_wine ok( !tmp_mem, "LocalReAlloc succeeded\n" );
+            ok( !tmp_mem, "LocalReAlloc succeeded\n" );
         else
             ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
         entry = *mem_entry_from_HANDLE( mem );
         if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
         if ((flags & LMEM_DISCARDABLE) || (flags & LMEM_MODIFY))
-            todo_wine_if(!(flags & LMEM_MODIFY)) ok( entry.ptr == expect_entry.ptr, "got ptr %p\n", entry.ptr );
+            ok( entry.ptr == expect_entry.ptr, "got ptr %p\n", entry.ptr );
         else
             ok( entry.ptr != expect_entry.ptr, "got unexpected ptr %p\n", entry.ptr );
         ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
         size = LocalSize( mem );
         if ((flags & LMEM_DISCARDABLE) || (flags & LMEM_MODIFY))
-            todo_wine_if(!(flags & LMEM_MODIFY)) ok( size == 10, "LocalSize returned %Iu\n", size );
+            ok( size == 10, "LocalSize returned %Iu\n", size );
         else
             ok( size == 512, "LocalSize returned %Iu\n", size );

@@ -2570,7 +2561,7 @@ static void test_LocalAlloc(void)

tmp_mem = LocalReAlloc( mem, 10, flags );
         if (!(flags & LMEM_MODIFY) && (flags & LMEM_DISCARDABLE))
-            todo_wine ok( !tmp_mem, "LocalReAlloc succeeded\n" );
+            ok( !tmp_mem, "LocalReAlloc succeeded\n" );
         else
             ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
         entry = *mem_entry_from_HANDLE( mem );
@@ -2579,7 +2570,7 @@ static void test_LocalAlloc(void)
         ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
         size = LocalSize( mem );
         if ((flags & LMEM_DISCARDABLE) || (flags & LMEM_MODIFY))
-            todo_wine_if(!(flags & LMEM_MODIFY)) ok( size == 12, "LocalSize returned %Iu\n", size );
+            ok( size == 12, "LocalSize returned %Iu\n", size );
         else
             ok( size == 10, "LocalSize returned %Iu\n", size );

@@ -2596,7 +2587,7 @@ static void test_LocalAlloc(void)
         if (flags == LMEM_FIXED)
             todo_wine ok( !tmp_mem, "LocalReAlloc succeeded\n" );
         else if (!(flags & LMEM_MODIFY) && (flags & LMEM_DISCARDABLE))
-            todo_wine ok( !tmp_mem, "LocalReAlloc succeeded\n" );
+            ok( !tmp_mem, "LocalReAlloc succeeded\n" );
         else
             ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
         entry = *mem_entry_from_HANDLE( mem );
@@ -2606,13 +2597,13 @@ static void test_LocalAlloc(void)
             expect_entry.ptr = NULL;
         }
         else if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
-        todo_wine_if(!(flags & LMEM_MODIFY) && (flags != LMEM_MOVEABLE))
+        todo_wine_if(!flags)
         ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
-        todo_wine_if(!(flags & LMEM_MODIFY) && (flags != LMEM_MOVEABLE))
+        todo_wine_if(!flags)
         ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
         size = LocalSize( mem );
         if (flags == LMEM_MOVEABLE) ok( size == 0, "LocalSize returned %Iu\n", size );
-        else todo_wine_if(!(flags & LMEM_MODIFY)) ok( size == 12, "LocalSize returned %Iu\n", size );
+        else todo_wine_if(!(flags & (LMEM_MODIFY | LMEM_DISCARDABLE))) ok( size == 12, "LocalSize returned %Iu\n", size );

mem = LocalFree( mem );
         ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
diff --git a/dlls/kernelbase/memory.c b/dlls/kernelbase/memory.c
index 324caf4b5b6..98f5eabc316 100644
--- a/dlls/kernelbase/memory.c
+++ b/dlls/kernelbase/memory.c
@@ -990,6 +990,7 @@ HLOCAL WINAPI DECLSPEC_HOTPATCH LocalReAlloc( HLOCAL handle, SIZE_T size, UINT f
         HeapValidate( heap, HEAP_NO_SERIALIZE, ptr ))
     {
         if (flags & LMEM_MODIFY) ret = handle;
+        else if (flags & LMEM_DISCARDABLE) SetLastError( ERROR_INVALID_PARAMETER );
         else if (flags & LMEM_MOVEABLE)
         {
             ret = HeapReAlloc( heap, heap_flags, ptr, size );
@@ -1005,6 +1006,7 @@ HLOCAL WINAPI DECLSPEC_HOTPATCH LocalReAlloc( HLOCAL handle, SIZE_T size, UINT f
             if (flags & LMEM_DISCARDABLE) mem->flags |= MEM_FLAG_DISCARDABLE;
             ret = handle;
         }
+        else if (flags & LMEM_DISCARDABLE) SetLastError( ERROR_INVALID_PARAMETER );
         else
         {
             if (size)