I suggest to replace with:

that way multiple reads will work, even if the structure is wrapped once over old style Structure and once over new style structure.

Whether it's "old" (0) or "new" (>0) is an OS-level condition that won't change during execution. But conceivably if someone wanted to re-use a structure and just change the native bits with useMemory() the value could change. But in this case, the proposed change would recreate the array (and reinitializing/recreating its internal Structure objects and the ULONG_PTR) on every read(). What we really want is to conditionally resize the array only if it's a new version and has changed.

Plus, in the vast majority of cases (systems with <= 64 processors = 1 processor group) the groupCount is 1 and the array is already the correct size.

So I'd propose:

if (groupCount > 0 && groupCount != groupMasks.length) {
    groupMasks = new GROUP_AFFINITY[groupCount];
}

Looking at this again, while I think it would be highly unusual for this value to change on re-read (requires both changing the number of processor groups while the program was operating (e.g., using a hypervisor and changing from under to over 64 logical processors) and re-using an existing structure rather than generating a new one) we do something similar to your proposal in the PROCESSOR_RELATIONSHIP structure, so it's a reasonable approach from the standpoint of consistency.

If you really want to optimize, you could do this (there needs to be at least one entry in the array (the original single value), reinitialization of the array is only needed if size changes:

        @Override
        public void read() {
            // resize array if needed
            readField("groupCount");
            int requiredArraySize = Math.max(1, groupCount);
            if (groupMasks == null || requiredArraySize != groupMasks.length) {
                groupMasks = new GROUP_AFFINITY[requiredArraySize];
            }
            // Now read the fields from field order
            super.read();
            // Finally copy first value from array to older version of structure
            groupMask = groupMasks[0];
        }

Whether that is more efficient, that simple rebuilding the array from scratch and letting the GC do the work is a different discussion. The GC might win here.

I don't think groupMasks == null will ever happen. We need a minimum array size of 1 and initialize it that way. Reading only needs to resize it if it needs to grow. (And maybe shrink on re-read.)

Other than the null check, what you have is essentially what I proposed (And could also do for PROCESSOR_RELATIONSHIP.)

OK, I'm done tweaking now.