gfx/x11: NULL-check keysym rlut calloc to avoid OOM segfault

x11_init_keyboard_lut rebuilds the reverse keysym lookup table:

    if (x11_keysym_rlut)
       free(x11_keysym_rlut);

    x11_keysym_rlut = (unsigned*)calloc(++x11_keysym_rlut_size, sizeof(unsigned));

    for (map = map_start; map->rk != RETROK_UNKNOWN; map++)
       x11_keysym_rlut[map->sym] = (enum retro_key)map->rk;

If the calloc returns NULL, the populate loop dereferences NULL on
its first iteration.  The size allocated here is driven by the
maximum X11 keysym value observed while building x11_keysym_lut (a
few hundred unsigneds, so ~kB), small enough that OOM is unlikely
in normal operation but still possible under extreme memory
pressure.

The lookup-side reader already handles the disabled-rlut case:

    if (x11_keysym_rlut && sym < x11_keysym_rlut_size)
       return (enum retro_key)x11_keysym_rlut[sym];

so the correct failure behaviour is to leave x11_keysym_rlut as NULL
and set x11_keysym_rlut_size = 0.  The reader's NULL + bounds
guard then falls through cleanly and the caller transparently gets
whatever fallback path follows.  The existing 'x11_keysym_rlut_size
>= 65536' branch at the bottom of this same function already uses
size = 0 as the 'rlut disabled' sentinel, so this matches the
existing convention.

Thread-safety: unchanged.  Called once during X11 context
initialisation; x11_keysym_rlut is a file-scope static touched only
on the main thread.

Reachability: X11 input context init.  Runs once per X11 window
bring-up.

Author: LibretroAdmin

gfx/common/x11_common.c

@@ -426,10 +426,17 @@ static void x11_init_keyboard_lut(void)
       if (x11_keysym_rlut)
          free(x11_keysym_rlut);
 
-      x11_keysym_rlut = (unsigned*)calloc(++x11_keysym_rlut_size, sizeof(unsigned));
-
-      for (map = map_start; map->rk != RETROK_UNKNOWN; map++)
-         x11_keysym_rlut[map->sym] = (enum retro_key)map->rk;
+      /* NULL-check the calloc: the populate loop below dereferences
+       * x11_keysym_rlut[map->sym] unconditionally, so an OOM here
+       * would segfault.  The reader (x11_keysym_lookup, line ~493)
+       * guards with 'if (x11_keysym_rlut && sym < size)', so leaving
+       * the pointer NULL on failure cleanly disables the rlut path
+       * without further damage. */
+      if (!(x11_keysym_rlut = (unsigned*)calloc(++x11_keysym_rlut_size, sizeof(unsigned))))
+         x11_keysym_rlut_size = 0;
+      else
+         for (map = map_start; map->rk != RETROK_UNKNOWN; map++)
+            x11_keysym_rlut[map->sym] = (enum retro_key)map->rk;
    }
    else
       x11_keysym_rlut_size = 0;