Commit graph

8 commits

Author SHA1 Message Date
LibretroAdmin
2cbcefcff6 common/vulkan, core: pre-bake screen-quad VS, no glslang at runtime
This is the probe patch in a series that eliminates dep/glslang from the
libretro core build. It establishes the infrastructure - the GLSL source
tree, the embedded-SPIR-V loader, the regeneration tool, and the build
wiring - by converting exactly one call site so the pattern can be
smoke-tested in isolation before the rest of Bucket A and then Bucket B
follow in subsequent patches. glslang stays in the tree until the final
patch in the series, which removes dep/glslang and the surrounding
shader_compiler.cpp.

What this patch does:

- Adds data/shaders/vulkan/screen_quad.vert.glsl - the GLSL source for
  the screen-quad VS, kept in the tree for human readability. The build
  does NOT see this file; it is consumed only by the offline regen tool.

- Adds src/common/vulkan/embedded_spirv/screen_quad_vs.inc - the
  pre-compiled SPIR-V blob as a 'const uint32_t[]' (367 words, 1.4 KiB),
  generated offline from the .glsl by glslangValidator targeting
  vulkan1.0. The .inc is checked in and #include'd by embedded_shaders.cpp
  inside namespace Vulkan::EmbeddedShaders. spirv-val confirms the blob
  is valid Vulkan 1.0 SPIR-V (magic 0x07230203, version 1.0).

- Adds src/common/vulkan/embedded_shaders.{h,cpp}. The header exposes a
  pair of extern declarations per blob and a single
  CreateShaderModule(const uint32_t*, size_t) loader. The loader
  intentionally bypasses Vulkan::ShaderCache - pre-baked SPIR-V is
  already final, so there is nothing to compile and nothing worth
  caching on disk. Just a sized-and-checked vkCreateShaderModule call.

- Adds tools/regen_vulkan_spirv.py - the offline workflow for
  contributors who edit shader .glsl sources. It invokes
  glslangValidator on each .glsl under data/shaders/vulkan/ and rewrites
  the matching .inc. CRITICAL: this tool is NEVER invoked by Make or
  CMake. The build sees only .h/.cpp/.inc files and has no shader-
  compiler dependency. Contributors run the script manually after
  editing .glsl, commit both files together.

- Adds data/shaders/vulkan/README.md documenting the workflow and the
  invariant that the build must never invoke an external shader
  compiler.

- Switches GPU_HW_Vulkan::GetFullscreenQuadVertexShader() (in
  src/core/gpu_hw_vulkan.cpp) from
      g_vulkan_shader_cache->GetVertexShader(m_shadergen->Generate...)
  to
      Vulkan::EmbeddedShaders::CreateShaderModule(k_screen_quad_vs, ...).
  The m_shadergen null-check is removed since the embedded path has no
  such ordering dependency. The function's contract (lazy creation,
  stored in m_fullscreen_quad_vertex_shader, returned to multiple
  pipeline builders) is unchanged.

- Registers src/common/vulkan/embedded_shaders.cpp in both
  Makefile.libretro (alphabetical order in the vulkan/ SOURCES_CXX
  block) and src/common/CMakeLists.txt (alphabetical order in the
  common target's source list). Neither change adds any build-tool
  dependency; the new .cpp compiles like any other.

What this patch does NOT do:

- It does not remove dep/glslang or the SOURCES_CXX entries that pull
  in its 99 translation units. glslang is still needed for every shader
  generator that has not yet been converted - in particular all of
  GPU_HW_ShaderGen, plus the remaining utility shaders (UV quad VS,
  VRAM read/copy/write/fill/update-depth FS, display FS, adaptive
  downsample mip/blur/composite FS, box-sample downsample FS).
  Subsequent patches in this series convert those one bucket at a time.
  The final patch removes dep/glslang, src/common/vulkan/shader_compiler.{h,cpp},
  the glslang link line in CMake, and the Makefile entries.

- It does not touch the disk-backed Vulkan::ShaderCache. That cache
  still serves the runtime-glslang path for remaining shaders.

Smoke tests performed in isolation:

- glslangValidator --target-env vulkan1.0 succeeds on the .glsl source,
  producing 367 32-bit words of SPIR-V.
- spirv-val --target-env vulkan1.0 reports VALID on the blob.
- spirv-dis confirms the entry point, VertexData block, and Position/
  VertexIndex built-ins are correctly emitted.
- A standalone harness including the .inc inside the
  Vulkan::EmbeddedShaders namespace and calling CreateShaderModule
  through a stubbed vkCreateShaderModule reads back the correct magic
  word and size.
- g++ -fsyntax-only on embedded_shaders.cpp against the real headers
  in the tree (excluding only the platform-specific X11 surface define
  not used by this TU) is clean.

Smoke tests that require the user's setup:

- Real build on Windows (RTX 5090) and macOS.
- Vulkan core boots, RetroArch's pipeline cache populates, and at
  least one game renders past the first frame using the screen-quad
  pipeline (VRAM ops, display, downsample - all of which call
  GetFullscreenQuadVertexShader internally).
2026-05-17 20:09:57 +02:00
LibretroAdmin
283b08f7bb Makefile.libretro: compile D3D12 backend by default on Windows
The previous wire-up commit (cf05cad) gated the D3D12 sources behind
USE_D3D12=1 on the make command line. That gate had the side effect
of leaving D3D12 entirely out of the default Windows build:

  - The seven common/d3d12 TUs were not compiled in
  - gpu_hw_d3d12.cpp was not compiled in
  - -ld3d12 was not on the link line
  - -DUSE_D3D12=1 was not in CXXFLAGS, so every #ifdef USE_D3D12
    block in libretro_host_interface.cpp / libretro_core_options.h
    / gpu_hw_d3d12.h / gpu_hw_d3d12.cpp / system.cpp was inactive

The user-visible consequence with a default Windows build: when
RetroArch is set to the d3d12 video driver and the user starts the
swanstation core, the auto-renderer path lands in
RetroHwContextToRenderer() with retro_hw_context_type=
RETRO_HW_CONTEXT_D3D12 (= 9), but the corresponding case label is
#ifdef USE_D3D12'd out of the switch. The default branch returns
std::nullopt, and RequestHardwareRendererContext falls back to
DEFAULT_GPU_RENDERER which is HardwareD3D11. RetroArch's driver
auto-switch logic then sees that the core requested a D3D11 context
and silently switches its video driver from d3d12 to d3d11.

The opt-in gate served no real purpose - d3d12.dll has shipped with
every Windows 10 build and the mingw-w64 toolchain has had
<d3d12.h> for years. The libretro frontend doesn't need to expose
retro_hw_render_interface_d3d12 either; that determination happens
at SET_HW_RENDER time and the existing m_hw_render_callback_valid
=false fallback path handles a refusing frontend the same way it
does for any other unsupported HW context type.

Inline the D3D12 block into the existing IS_WINDOWS=1 guard so
D3D12 compiles unconditionally on Windows alongside D3D11. The
-DUSE_D3D12=1 define is still set the same way - so all of the
#ifdef USE_D3D12 source-side gates keep working - but it no longer
requires USE_D3D12=1 on the make command line.

Both the common-section (src/common/d3d12/*.cpp) and the core-
section (src/core/gpu_hw_d3d12.cpp) opt-in branches removed.

== Build verification ==

  make platform=win (no extra flags) now emits -DUSE_D3D12=1, links
  -ld3d12, and includes all eight d3d12 TUs.

  make platform=unix: clean, .so unchanged at 7,905,720 bytes,
  25 retro_ exports preserved (IS_WINDOWS=0 skips the whole
  Windows block including the new always-on D3D12 lines).

1 file changed, 7 insertions(+), 14 deletions(-).
2026-05-15 01:13:18 +02:00
LibretroAdmin
cf05cadb4d core, libretro, common: wire up D3D12 renderer for libretro
Wires the existing D3D12 hardware renderer (src/core/gpu_hw_d3d12.cpp,
src/common/d3d12/*) into the libretro frontend, behind a USE_D3D12=1
gate. The opt-in is because:

  1. retro_hw_render_interface_d3d12 is supported by recent RetroArch
     builds but not all of them - the SET_HW_RENDER environment call
     will fail at runtime where unsupported.
  2. Not every Windows target ships d3d12.lib in its toolchain; the
     gate keeps the existing default Windows build path working.

When USE_D3D12=1 is set on the make command line, the libretro
Makefile pulls in the seven common/d3d12 TUs, gpu_hw_d3d12.cpp, the
new LibretroD3D12HostDisplay class, links against d3d12.lib, and
exposes "D3D12" in the renderer dropdown next to D3D11.

== src/common/d3d12 ==

  D3D12::Context grew a CreateForLibretro(device, command_queue)
  static factory next to its existing Create(dxgi_factory, ...). The
  libretro path adopts the frontend's device + command queue (the
  frontend retains ownership; we just AddRef them via ComPtr) and
  then creates only the resources we own: fence, descriptor heaps,
  command lists, texture upload stream buffer. Feature level is
  pinned at FL11_0; the gpu_hw_d3d12 shader/PSO setup targets that
  baseline. CreateForLibretro still loads d3d12.dll because
  PFN_D3D12_SERIALIZE_ROOT_SIGNATURE is needed by
  Context::SerializeRootSignature, which gpu_hw_d3d12.cpp uses on
  initial root-signature creation.

  Destroy() is unchanged; the borrowed device/queue ComPtrs simply
  release their AddRef in the Context destructor and the frontend
  keeps the underlying objects alive.

== src/core/gpu_hw_d3d12.h, .cpp ==

  Added LibretroD3D12HostDisplay (declaration in the header above
  GPU_HW_D3D12, implementation appended ahead of GPU_HW_D3D12's
  constructor body in the .cpp). The class mirrors
  LibretroD3D11HostDisplay's surface and behaves identically on
  the libretro-API side, with two differences driven by the D3D12
  libretro interface contract:

  1. There is no analogue to ID3D11DeviceContext in D3D12 - work
     is recorded on command lists owned by D3D12::Context. The
     class therefore does not store m_device / m_context members;
     callers that need the device go through
     g_d3d12_context->GetDevice() as the rest of gpu_hw_d3d12.cpp
     already does. GetRenderDevice() returns
     g_d3d12_context->GetDevice() for HostDisplay-API callers;
     GetRenderContext() returns nullptr.

  2. Present is the retro_hw_render_interface_d3d12::set_texture
     callback rather than a swapchain blit. LibretroD3D12HostDisplay
     ::Render() transitions the GPU_HW_D3D12-produced display
     texture into the frontend's required_state, flushes our
     pending command list via ExecuteCommandList(false), calls
     set_texture(frontend_handle, ID3D12Resource*, format), then
     signals the frontend a HW frame is ready via
     g_retro_video_refresh_callback(RETRO_HW_FRAME_BUFFER_VALID,
     width, height, 0). The frame-dupe (NULL) path for runahead /
     fast-forward video skip is identical to the D3D11 and SW
     renderer paths.

  The CreateTexture / BeginSetDisplayPixels / EndSetDisplayPixels
  paths return nullptr / false the same way LibretroHostDisplay
  does. They are not exercised on the libretro D3D12 path - GPU_HW
  _D3D12 owns its own D3D12::Texture instances directly, and the
  SW renderer (which is the only path that would BeginSetDisplay
  Pixels) uses LibretroHostDisplay rather than going through D3D12.

  An m_framebuffer member is reserved on the class for future
  software-cursor / lightgun-crosshair overlay work (which would
  composite over the display texture in an owned RTV before
  set_texture, the way gpu_hw_d3d11.cpp does it). For the initial
  wire-up the present path forwards the GPU_HW_D3D12 display
  texture directly.

  HAVE_D3D12 is #define'd before the libretro_d3d.h include to
  pull in the retro_hw_render_interface_d3d12 struct definition,
  matching the equivalent pattern in gpu_hw_d3d11.cpp.

== src/libretro/libretro_host_interface.cpp ==

  Four switch cases extended, all under #ifdef WIN32 + #ifdef USE
  _D3D12:

  - RetroHwContextToRenderer: maps RETRO_HW_CONTEXT_D3D12 = 9 to
    GPURenderer::HardwareD3D12 so the Auto-renderer path picks D3D12
    when the frontend advertises it via GET_PREFERRED_HW_RENDER.

  - RenderAPIToRenderer: maps HostDisplay::RenderAPI::D3D12 to
    GPURenderer::HardwareD3D12 so reusing an existing hardware
    display across SwitchToHardwareRenderer rebinds correctly.

  - RequestHardwareRendererContext: calls
    LibretroD3D12HostDisplay::RequestHardwareRendererContext
    (sets context_type=RETRO_HW_CONTEXT_D3D12, version_major=12,
    version_minor=0).

  - SwitchToHardwareRenderer: instantiates LibretroD3D12HostDisplay
    when m_hw_render_callback.context_type indicates D3D12.

  Include line added for gpu_hw_d3d12.h alongside the existing
  gpu_hw_d3d11.h include.

== src/libretro/libretro_core_options.h ==

  Renderer dropdown gains {"D3D12", "Hardware (D3D12)"} entry,
  gated USE_D3D12 inside the existing WIN32 block. Settings
  ::ParseRendererName already had D3D12 in its s_gpu_renderer
  _names array (pre-existing), and Settings::GetRendererName
  reads from the same array, so the dropdown selection round-trips
  to/from GPURenderer::HardwareD3D12 correctly.

== Makefile.libretro ==

  Under the existing IS_WINDOWS guard, added a USE_D3D12=1 branch
  that:

  - Adds -DUSE_D3D12=1 to CXXFLAGS so the wiring under #ifdef USE
    _D3D12 in libretro_host_interface.cpp, libretro_core_options.h,
    gpu_hw_d3d12.cpp, and gpu_hw_d3d12.h gets compiled in.

  - Adds -ld3d12 to LDFLAGS so PFN_D3D12_SERIALIZE_ROOT_SIGNATURE
    resolves at link time (Context::SerializeRootSignature uses it).

  - Adds the seven common/d3d12 TUs (context, descriptor_heap_
    manager, shader_cache, staging_texture, stream_buffer, texture,
    util) to SOURCES_CXX.

  - Adds src/core/gpu_hw_d3d12.cpp to SOURCES_CXX in the core
    section.

  Default (no USE_D3D12=1) keeps the existing Windows build
  unchanged. system.cpp's renderer dispatch already had the case
  GPURenderer::HardwareD3D12 case behind #ifdef USE_D3D12 and the
  forward declaration of GPU::CreateHardwareD3D12Renderer() was
  already in gpu.h, so no changes were needed there.

== Build verification ==

Linux libretro build: clean, .so unchanged at 7,905,720 bytes (all
new D3D12 code is gated under WIN32 + USE_D3D12 - no compiled-in
effect on non-Windows targets), 25 retro_ exports preserved.

Windows build with USE_D3D12=1 has not been verified in this
environment - mingw cross-compile tools and the d3d12 SDK headers
aren't available on the build host. Manual test on Windows
required before pushing.

7 files changed, 414 insertions(+).
2026-05-15 01:07:00 +02:00
Lib
1c836c10ca audio: devirtualize AudioStream, fold NullAudioStream into LibretroAudioStream
The audio path used to be:

  - common/audio_stream.h declared an abstract AudioStream base with
    one pure virtual (FramesAvailable) and shared non-virtual
    BeginWrite/EndWrite/Reconfigure/Shutdown.
  - libretro/libretro_audio_stream.{h,cpp} overrode FramesAvailable
    with the real libretro frontend drain.
  - common/null_audio_stream.{h,cpp} overrode FramesAvailable to
    discard, and was constructed only to feed the SPU during
    internal-runahead replay so audio from those frames never reached
    the frontend. The SPU pointer-swapped between the host stream and
    the null stream around DoRunahead's replay loop.

The base class buys nothing here. There is exactly one runtime audio
stream in swanstation - LibretroAudioStream - and the second subclass
exists only to express 'discard everything' behaviour, which is
trivially representable as a flag on the real one. EndWrite ran a
virtual call to FramesAvailable on every SPU update (~150-300 times
per frame), the indirection resolving to the same place every time.

Drop the base class and the null subclass:

  - Delete common/audio_stream.{h,cpp} and common/null_audio_stream.{h,cpp}.
  - LibretroAudioStream becomes a plain class with no inheritance,
    absorbing the BeginWrite/EndWrite/Reconfigure/Shutdown bodies and
    the SampleType/MaxSamples/etc. constants from the old base.
  - FramesAvailable's contents are inlined into EndWrite (it was the
    only caller), with an early-return for fast-hook mode that
    matches the previous behaviour exactly.
  - The 'discard' role of NullAudioStream becomes a m_silent_mode flag
    and a SetSilentMode() setter on LibretroAudioStream. EndWrite
    drains the FIFO immediately when silent, so the SPU keeps ticking
    state-machines (envelope counters, ADPCM phase, etc.) for
    correctness, the FIFO does not build up backpressure across the
    runahead window, and nothing reaches the frontend.

  - System::DoRunahead replaces the SPU pointer-swap with a
    SetSilentMode(true)/SetSilentMode(false) toggle on the host's
    existing LibretroAudioStream. s_runahead_audio_stream
    (std::unique_ptr<AudioStream>) and the matching reset() in
    System::Shutdown go away entirely.

  - HostInterface drops the virtual CreateAudioStream() factory
    method; its single override in LibretroHostInterface returned
    std::make_unique<LibretroAudioStream>() which is now inlined at
    the only call site (HostInterface::BootSystem).

  - HostInterface::m_audio_stream and HostInterface::GetAudioStream
    become typed as LibretroAudioStream (forward-declared in
    host_interface.h, the libretro header included from the cpp).
    SPU::SetAudioStream and SPU::m_audio_stream similarly get the
    concrete type. The static_cast in retro_run_frame's
    UploadToFrontend call goes away.

  - Makefile.libretro and src/common/CMakeLists.txt drop the deleted
    source files from their lists.

Linux x64 build still warning-clean. .so size drops from 8047800 to
8046184 bytes (-1616) - the AudioStream and NullAudioStream
vtables/typeinfo, the virtual destructor and FramesAvailable, the
indirect-call sites in EndWrite, and the second runahead audio
stream instance and its construction code are all gone. 25 retro_*
exports unchanged. Behaviour is identical: the SetSilentMode toggle
produces exactly the same observable result as the
swap-to-NullAudioStream pattern (the SPU's frame output is
discarded during the replay window in both cases).
2026-05-08 15:07:36 +02:00
Lib
53b57851e4 build: add vixl PRIVATE include paths for aarch64 / aarch32 builds
Apple Silicon (and any other aarch64/aarch32 host) currently fails the
static Makefile build with:

  dep/vixl/src/code-buffer-vixl.cc:33:10:
    fatal error: 'code-buffer-vixl.h' file not found

vixl uses a CMake idiom that splits its include directories: it
exposes ${SRC}/include as PUBLIC for consumers and ${SRC}/include/vixl
plus the per-target subdir as PRIVATE for vixl's own translation units.
Concretely:

  - Consumers in src/core/ write   #include "vixl/aarch64/foo.h"
    and need only -I.../vixl/include.
  - vixl's own .cc files write     #include "code-buffer-vixl.h"
    and need -I.../vixl/include/vixl.
  - vixl's aarch64 .cc files write #include "assembler-aarch64.h"
    and need -I.../vixl/include/vixl/aarch64.
  - vixl's aarch64 .cc files also write #include "../globals-vixl.h"
    which resolves through the same -I via the parent path.

Makefile.libretro was only adding the consumer (PUBLIC) include for
both aarch architectures, which is enough for src/core to compile but
not enough for vixl's own translation units. x64 builds were
unaffected because they use xbyak instead of vixl.

Add the missing PRIVATE includes for both aarch architectures, gated
by CPU_ARCH so we don't drag in both aarch32 and aarch64 internal
headers at once. The vixl bare-name headers
(code-buffer-vixl.h, cpu-features.h, globals-vixl.h, ...) do not
collide with anything else in the tree - verified by searching for
each of the 25 bare names across src/ and dep/, with no matches
outside dep/vixl/.

Verified by cross-compiling each vixl source file with
aarch64-linux-gnu-g++ -DVIXL_INCLUDE_TARGET_A64 and the new -I set:
22/22 base+aarch64 sources compile cleanly. Same check with
-DVIXL_INCLUDE_TARGET_A32 and the aarch32 -I set: 11/11 base+aarch32
sources compile cleanly. Linux x64 build is unchanged (vixl block
doesn't fire) - .so still 8048480 bytes, 25 retro_* exports.
2026-05-08 05:52:50 +02:00
Lib
945e042d73 build: silence two long-standing build warnings
The libretro build emitted two warnings on every compile:

  dep/xxhash/src/xxhash.c:40: warning: "XXH_STATIC_LINKING_ONLY" redefined
  src/common/log.cpp:233:35: warning: ignoring return value of
    'ssize_t write(int, const void*, size_t)'
    declared with attribute 'warn_unused_result' [-Wunused-result]

Both are real, fixable, and unrelated to the rest of the audit, but
nice to clear out so a future regression actually shows up against a
clean baseline.

xxhash.c starts with its own '#define XXH_STATIC_LINKING_ONLY' to
unlock the advanced API for instantiation. Makefile.libretro was
already passing -DXXH_STATIC_LINKING_ONLY on the command line, so the
.c file's #define triggered a redefinition warning every time
xxhash.c was built. The flag in CFLAGS was unnecessary in the first
place: consumer code in this tree uses XXH64_state_t* opaquely and
calls only the public API (XXH64_createState, XXH64_reset,
XXH64_update, XXH64_digest), none of which require the advanced
declarations. Drop the -D from CFLAGS.

log.cpp's console-output path writes the formatted log line with a
bare write() and discards the return value. glibc declares write()
with the __wur (warn_unused_result) attribute, and a plain '(void)'
cast does NOT silence -Wunused-result on glibc - the compiler still
flags it (verified locally). The portable workaround that does
silence it is to capture into a named variable and then cast that to
void:

    const ssize_t written = write(outputFd, message, message_len);
    (void)written;

This is the right behaviour anyway: there is genuinely nowhere
meaningful to surface a write() failure from the log callback,
since the log callback IS the failure-reporting path. Add a comment
explaining why the assignment-then-discard form is used so a future
maintainer does not 'simplify' it back to a (void) cast.

Build is now warning-clean. .so size unchanged at 8048480 bytes,
25 retro_* exports unchanged.
2026-05-08 04:34:47 +02:00
Lib
46b57e3486 build: add MSB_FIRST opt-in flag for big-endian hosts
All currently-supported swanstation targets - x86, x64, AArch32 LE,
AArch64 LE - are little-endian, and there is no plan to ship a
big-endian build today. To make endian-conditional code possible
without paying a runtime cost on the LE targets, add a single
opt-in compile flag rather than autodetecting at configure time:

- src/common/types.h is a universally-included header. It now
  documents the convention and reserves the macro name. There is
  deliberately no LSB_FIRST counterpart - little-endian is the
  unmarked default. Code that needs byte-order-conditional behaviour
  branches on  only, so the LE path is the
  unconditional default.

- Makefile.libretro forwards MSB_FIRST=1 from the make command line
  to -DMSB_FIRST=1 on the compiler.

- CMakeLists.txt exposes a CMake option(MSB_FIRST OFF) that does
  the same via add_definitions(-DMSB_FIRST=1).

No source files use the macro yet; this commit only puts the gate
in place. Existing endian-dependent code (e.g. CDImageCHD's audio
sector byte-swap) can be converted in follow-up patches once the
flag is available.

Verified: builds clean both with and without MSB_FIRST=1; .so
size, exports unchanged on the default LE path.
2026-05-08 00:32:03 +02:00
Lib
b37eec04cc libretro: add static Makefile.libretro build
Add a self-contained static Makefile (Makefile.libretro) that builds
the libretro core without CMake, modeled on the Beetle PSX libretro
Makefile.

The CMake build is unaffected and continues to work; the new file is
strictly additive.

Usage:
  make -f Makefile.libretro                 # native build
  make -f Makefile.libretro platform=unix
  make -f Makefile.libretro platform=osx
  make -f Makefile.libretro platform=win
  make -f Makefile.libretro DEBUG=1
  make -f Makefile.libretro SILENT=1

Supports Linux, macOS, and Windows (MinGW / MSYS2). CPU_ARCH is
detected automatically; recompiler back-ends are gated per arch
(x64 -> xbyak, aarch64/aarch32 -> vixl).

Always assumes libretro defines (LIBRETRO=1, __LIBRETRO__) are on.
Source list and include paths are transcribed from the corresponding
CMakeLists.txt files in src/ and dep/.

Generates two headers at build time that CMake normally produces via
configure_file():

 - src/config.h           (HAVE_MKSTEMP / HAVE_ALLOCA_H / HAVE_MALLOC_H)
 - src/libretro/version.h (GIT_VERSION / GIT_HASH / BUILD_DATE)

Both are .gitignore'd by the existing rules.

Symbol exports are filtered to retro_* via:
 - link.T              (Linux / MinGW version script)
 - libretro.osx.def    (Mach-O exported_symbols_list)

Verified: clean Linux/x64 build produces an 8 MB
swanstation_libretro.so with exactly 25 exported retro_* symbols and
no other dynamic dependencies beyond libc/libm.
2026-05-07 21:32:02 +02:00