Expand %p in X87_PROFILE and X87_SAMPLE to the attached process pid

In cooperative mode Wine re-executes every 32-bit process through the
sidecar, so one game launch is several sidecars: the wineboot helpers,
the process that starts the game, and the game itself, all inheriting
the same X87_PROFILE. The last sidecar to open the path wins, and since
the block profiler appends its counter section only after its target
exits, the game's profile was routinely truncated by a helper's before
it could be finalised. profile_analyze then rejected it as incomplete,
with no way to tell which process the surviving file belonged to.

Expand %p against the pid behind the task port the sidecar received,
for both X87_PROFILE and X87_SAMPLE, before any old output is unlinked
or a new file opened. Without %p the paths behave as before. If the
target pid cannot be resolved the profiler is disabled with a message
rather than writing under the wrong name.

Verified under wine-cx-26.3.0-1 on an M2 Max, macOS 26.5, with a
32-bit Direct3D game: one launch produced x87-block-<pid>.prof for each
of four cooperative sidecars, and the game's file carried a complete
counter section that profile_analyze accepted (2197 blocks).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: developer

README.md

@@ -201,7 +201,11 @@ achieved.
 | `X87_NO_UNWIND=1` | `--no-unwind` | off | leaf pcs only, about half the per-sample cost |
 
 The environment wins over the flags, so an app bundle can enable sampling
-without touching argv.
+without touching argv. `%p` in the `X87_SAMPLE` or `X87_PROFILE` path expands
+to the pid of the process the sidecar is attached to, not the sidecar's own.
+Wine starts one cooperative sidecar per i386 process and all of them inherit
+the same environment, so a fixed path would let the injector's sidecar
+truncate the game's profile, or the reverse.
 
 ### Block profiler: what the x87 code costs
 

rosetta_loader/src/sidecar.cpp

@@ -2902,14 +2902,48 @@ bool installPortInParent(mach_port_t parentTaskPort, mach_port_t* outServicePort
     return true;
 }
 
+// A launcher can start several independently wrapped processes with the same
+// profiler environment.  Expand against the process whose task port the
+// sidecar received, not the sidecar's own pid, so they cannot truncate one
+// another's output.
+static bool expandTargetPid(std::string& path, pid_t targetPid, const char* variable) {
+    if (path.find("%p") == std::string::npos) {
+        return true;
+    }
+    if (targetPid <= 0) {
+        fprintf(stdout,
+                "[rosettax87] %s: cannot expand %%p because the target pid is unavailable; "
+                "profiling disabled\n",
+                variable);
+        return false;
+    }
+
+    const std::string replacement = std::to_string(targetPid);
+    size_t offset = 0;
+    while ((offset = path.find("%p", offset)) != std::string::npos) {
+        path.replace(offset, 2, replacement);
+        offset += replacement.size();
+    }
+    return true;
+}
+
 bool spawnReceiveThread(mach_port_t servicePort, mach_port_t parentTaskPort) {
     if (g_rosetta_config != nullptr && !g_rosetta_config->profile_path.empty()) {
-        const char* path = g_rosetta_config->profile_path.c_str();
-        g_profile.file = std::fopen(path, "wb");
+        std::string path = g_rosetta_config->profile_path;
+        pid_t targetPid = 0;
+        pid_for_task(parentTaskPort, &targetPid);
+        if (!expandTargetPid(path, targetPid, "X87_PROFILE")) {
+            path.clear();
+        }
+        g_profile.file = path.empty() ? nullptr : std::fopen(path.c_str(), "wb");
         if (g_profile.file == nullptr) {
-            fprintf(stdout, "[rosettax87] X87_PROFILE: failed to open '%s' for writing\n", path);
+            if (!path.empty()) {
+                fprintf(stdout, "[rosettax87] X87_PROFILE: failed to open '%s' for writing\n",
+                        path.c_str());
+            }
         } else {
-            fprintf(stdout, "[rosettax87] X87_PROFILE: dumping IR streams to '%s'\n", path);
+            fprintf(stdout, "[rosettax87] X87_PROFILE: dumping IR streams to '%s'\n",
+                    path.c_str());
         }
         fflush(stdout);
     }
@@ -3026,6 +3060,13 @@ void startSampler(mach_port_t parentTaskPort, uint64_t runtimeBase, const Sample
     // Sweeping every thread faster than the sample rate is never what was
     // meant: the sweep is the expensive mode and the rate is the cheap one.
     cfg.sweep_interval_us = std::max(cfg.sweep_interval_us, cfg.interval_us);
+    // The target's pid is needed by both threads and pid_for_task only answers
+    // while it is alive, so read it before touching the output path.
+    pid_t targetPid = 0;
+    pid_for_task(parentTaskPort, &targetPid);
+    if (!expandTargetPid(cfg.path, targetPid, "X87_SAMPLE")) {
+        return;
+    }
     // Nothing from a previous run may survive into this one: a run that never
     // latches writes no profile, and the absence has to be the answer rather
     // than the last run's file still sitting there to be read as this one's.
@@ -3037,11 +3078,6 @@ void startSampler(mach_port_t parentTaskPort, uint64_t runtimeBase, const Sample
     unlink(cfg.path.c_str());
     unlink((cfg.path + ".windows").c_str());
     unlinkWindowSeries(cfg.path);
-    // The target's pid is needed by both threads and pid_for_task only answers
-    // while it is alive, so it is read here, once, before either starts.
-    pid_t targetPid = 0;
-    pid_for_task(parentTaskPort, &targetPid);
-
     pthread_attr_t attr;
     pthread_attr_init(&attr);
     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);