[PATCH v2 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 fb6e4aa56f8..941d1f6e182 100644
--- a/dlls/kernel32/tests/heap.c
+++ b/dlls/kernel32/tests/heap.c
@@ -1726,7 +1726,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
@@ -1741,11 +1741,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() );
@@ -1760,7 +1756,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
@@ -1775,11 +1771,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 );
@@ -1795,7 +1787,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
@@ -1810,11 +1802,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 );
@@ -1918,19 +1906,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 );

@@ -1945,7 +1933,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 );
@@ -1954,7 +1942,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 );

@@ -1971,7 +1959,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 );
@@ -1981,13 +1969,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() );
@@ -2405,13 +2393,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() );
@@ -2424,13 +2412,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 );
@@ -2444,13 +2432,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 );
@@ -2466,17 +2454,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" );
@@ -2493,7 +2481,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 );
@@ -2502,7 +2490,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 );

@@ -2523,15 +2511,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 );
@@ -2547,19 +2538,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 );

@@ -2574,7 +2565,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 );
@@ -2583,7 +2574,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 );

@@ -2600,7 +2591,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 );
@@ -2610,13 +2601,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)