[offloader] Fan a single DXIL library across an RT pipeline's Shaders[]

RayTracing pipelines compile every entry point — raygen, miss,
closest-hit, any-hit, intersection, callable — into a single DXIL
library via `dxc -T lib_6_x` / `clang-dxc -T lib_6_x`. That's the
shape every real DXR app ships: D3D12's CreateStateObject requires a
DXIL-library subobject anyway, and the driver fuses entry points
across the whole library at link time, so writing one .hlsl file and
compiling it once is both idiomatic and the path the framework's
`%dxc_target_lib` substitution emits.

Compute and raster pipelines stay one-to-one (the existing position-
based mapping handles VS+PS, AS+MS+PS, etc.). RT pipelines today need
N positional args even though one library blob holds every entry —
which the foundational `raygen-roundtrip.test` runs straight into:
3 Shaders[] entries vs 1 input file fails the count check before any
GPU work happens.

Detect the RT-pipeline-with-one-input shape and copy the library blob
into every `Shaders[].Shader` slot via `MemoryBuffer::getMemBufferCopy`.
Each entry owns its own buffer copy (DXIL libraries are KBs, no real
memory pressure) keeping the existing `unique_ptr<MemoryBuffer>`
ownership model intact. Non-RT pipelines still go through the
positional path and still enforce the count check.

Verified by re-running `raygen-roundtrip.test`'s pipeline.yaml + the
DXIL library via Wine + vkd3d-proton with a single .o argument — same
0xBEEF result the prior three-arg invocation produced.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 2 people

tools/offloader/offloader.cpp

@@ -113,26 +113,35 @@ static int run() {
   YIn >> PipelineDesc;
   ExitOnErr(llvm::errorCodeToError(YIn.error()));
 
-  // Read in the shaders. Ray tracing PSOs compile every entry point into a
-  // single library blob, so one input file backs all Shaders[] entries; the
-  // backend reads the blob from Shaders.front() and uses the rest only for
-  // their (Stage, Entry) metadata. Other pipelines expect one object file per
-  // stage.
-  if (PipelineDesc.isRayTracing()) {
-    if (InputShader.size() != 1)
-      ExitOnErr(createStringError(
-          std::errc::invalid_argument,
-          "RayTracing pipeline expects a single shader library, %d provided",
-          InputShader.size()));
-    PipelineDesc.Shaders.front().Shader = readFile(InputShader[0]);
+  // Read in the shaders.
+  //
+  // RayTracing pipelines compile every entry point — raygen, miss,
+  // closest-hit, any-hit, intersection, callable — into a single DXIL
+  // library via `dxc -T lib_6_x` / `clang-dxc -T lib_6_x`. That's the
+  // shape every real DXR app ships: D3D12's CreateStateObject requires a
+  // DXIL-library subobject anyway, and the driver fuses entry points
+  // across the whole library at link time. So when an RT pipeline is
+  // paired with a single input file, fan that one blob across every
+  // Shaders[] entry rather than asking the test author to duplicate the
+  // path N times on the offloader command line.
+  if (PipelineDesc.isRayTracing() && InputShader.size() == 1 &&
+      PipelineDesc.Shaders.size() > 1) {
+    std::unique_ptr<MemoryBuffer> Lib = readFile(InputShader[0]);
+    const StringRef LibBytes = Lib->getBuffer();
+    const StringRef LibName = Lib->getBufferIdentifier();
+    for (size_t I = 0; I < PipelineDesc.Shaders.size(); ++I)
+      PipelineDesc.Shaders[I].Shader =
+          MemoryBuffer::getMemBufferCopy(LibBytes, LibName);
   } else {
+    for (size_t I = 0; I < InputShader.size(); ++I) {
+      PipelineDesc.Shaders[I].Shader = readFile(InputShader[I]);
+    }
+
     if (InputShader.size() != PipelineDesc.Shaders.size())
       ExitOnErr(createStringError(
           std::errc::invalid_argument,
           "Pipeline description expects %d shader(s) %d provided",
           PipelineDesc.Shaders.size(), InputShader.size()));
-    for (size_t I = 0; I < InputShader.size(); ++I)
-      PipelineDesc.Shaders[I].Shader = readFile(InputShader[I]);
   }
 
   // Try to guess the API by reading the shader binary.