ADDITIONAL SYSTEM INFORMATION :
Windows 11 Pro 22H2 (build 22624.1470)
Java(TM) SE Runtime Environment (build 20+36-2344)
Preview functionality enabled (Foreign Function & Memory API)

A DESCRIPTION OF THE PROBLEM :
After creating an upcall stub with Linker#upcallStub on a static method and providing it as a parameter to an invocation of a MethodHandle bound to a foreign Win32 function and subsequently calling the GetLastError function provided by Windows, it will return 0x7F or "ERROR_PROC_NOT_FOUND". This appears to happen if both the stub creation and an invocation using that stub are called within close proximity of time.

It also happens when using System PrintStream#printf versus using System PrintStream#println in the upcall stub method. It oddly does not require the synthetic delay when using System PrintStream#println (demonstrated in the source code comments). There have been instances when invoking another foreign function MethodHandle will also create the error. An empty method body for the upcall stub in Java also does not seem to yield the error.

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
1. Obtain a MethodHandle to a native Win32 function (e.g. EnumWindows) which accepts a function pointer as an argument with Linker#downcallHandle
2. Obtain another MethodHandle to the native GetLastError Win32 function
3. Create an upcall stub utilizing Linker#upcallStub to a static method which uses System PrintStream#printf on its parameters.
4. Invoke the native Win32 function (e.g. EnumWindows) MethodHandle with the created upcall stub
5. Invoke the GetLastError native Win32 MethodHandle
6. Receive the error: 0x7F (ERROR_PROC_NOT_FOUND)

EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
Invoking the "GetLastError" native Win32 MethodHandle should return 0 (ZERO) indicating the operation was successful.
ACTUAL -
Invoking the "GetLastError" native Win32 MethodHandle returns 0x7F (ERROR_PROC_NOT_FOUND).

---------- BEGIN SOURCE ----------
import java.lang.foreign.*;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import static java.lang.foreign.ValueLayout.*;

public class Main {

    public static void main(String[] arguments) throws Throwable {

        var linker = Linker.nativeLinker();
        var scope = SegmentScope.auto();
        var lookup = MethodHandles.lookup();

        var kernelLibrary = SymbolLookup.libraryLookup("Kernel32", scope);
        var userLibrary = SymbolLookup.libraryLookup("User32", scope);

        var enumWindowsSymbol = userLibrary.find("EnumWindows").orElseThrow();
        var enumWindowsDescriptor = FunctionDescriptor.of(JAVA_BOOLEAN, ADDRESS, ADDRESS);
        var enumWindowsHandle = linker.downcallHandle(enumWindowsSymbol, enumWindowsDescriptor);

        var getLastErrorSymbol = kernelLibrary.find("GetLastError").orElseThrow();
        var getLastErrorDescriptor = FunctionDescriptor.of(JAVA_INT);
        var getLastErrorHandle = linker.downcallHandle(getLastErrorSymbol, getLastErrorDescriptor);

        var procedureMethodType = MethodType.methodType(boolean.class, MemorySegment.class, MemorySegment.class);
        var procedureHandle = lookup.findStatic(Main.class, "procedure", procedureMethodType);
        var procedureDescriptor = FunctionDescriptor.of(JAVA_BOOLEAN, ADDRESS, ADDRESS);
        var procedureStub = linker.upcallStub(procedureHandle, procedureDescriptor, scope);

        // TO RESOLVE:
        // Thread.sleep(1500);

        var result = (boolean) enumWindowsHandle.invoke(procedureStub, MemorySegment.NULL);
        var lastError = (int) getLastErrorHandle.invoke();

        System.out.println("EnumWindows result: " + result);
        System.out.println("Last Error: " + lastError);

    }

    public static boolean procedure(MemorySegment windowHandle, MemorySegment parameter) {
        // CREATES ERROR (UNLESS THERE IS A SYNTHETIC DELAY):
        System.out.printf("windowHandle: %d\n", windowHandle.address());
        System.out.printf("parameter: %d\n", parameter.address());

        // ALTERNATIVELY DOES NOT CREATE ERROR (NO SYNTHETIC DELAY REQUIRED):
        // System.out.println("windowHandle: " + windowHandle.address());
        // System.out.println("parameter: " + parameter.address());
        return false;
    }
}
---------- END SOURCE ----------

CUSTOMER SUBMITTED WORKAROUND :
1. Introduction of a synthetic delay (e.g. Thread#sleep) of approximately 1,500 milliseconds or more between the stub's creation and an invocation using it will prevent an error from returning.
2. Utilizing System PrintStream#println rather than PrintStream#printf
3. An empty method body

Examples have been commented out in the source code demonstration.

FREQUENCY : always