std::filesystem::path strip;

std::filesystem::path objcopy;

// Does this leg's format carry debug information inside the image?

// Ask `debug_info_is_in_band` rather than filling this by hand — see the

// header for the two formats where the answer is no, and for why the

// question is about the TARGET and not about the compiler.

bool inBandDebugInfo = true;

StripOutcome outcome = StripOutcome::NotApplicable;

std::filesystem::path debugFile; // written only when a debug dir was given

std::uintmax_t before = 0;

std::uintmax_t after = 0;

auto r = mcpp::platform::process::capture(cmd + " 2>&1");

if (r.exit_code != 0)

return std::unexpected(std::format(

" command: {}\n output : {}", cmd, r.output));

return {};

const std::vector<std::string>& args,

const std::filesystem::path& file)

{

std::string cmd = mcpp::platform::shell::quote(tool.string());

for (auto const& a : args) cmd += " " + mcpp::platform::shell::quote(a);

cmd += " " + mcpp::platform::shell::quote(file.string());

return cmd;

std::error_code ec;

auto n = std::filesystem::file_size(p, ec);

return ec ? 0 : n;

// `arch-os[-env]`. Splitting rather than substring-matching: an arch or a

// vendor segment could contain either of these words, and mcpp has been

// bitten before by a triple predicate that answered on a substring.

std::vector<std::string_view> seg;

for (std::size_t i = 0; i <= canonicalTriple.size(); ) {

auto j = canonicalTriple.find('-', i);

if (j == std::string_view::npos) { seg.push_back(canonicalTriple.substr(i)); break; }

seg.push_back(canonicalTriple.substr(i, j - i));

i = j + 1;

}

if (seg.size() >= 2 && seg[1] == "macos") return false; // debug map + .dSYM

if (seg.size() >= 3 && seg[2] == "msvc") return false; // separate .pdb

return true;

// dh_strip's own division. See the header for the measurement behind the

// archive row — it is the one that turns a package into an unlinkable one.

std::vector<std::string> args{ "--remove-section=.comment",

"--remove-section=.note" };

switch (shape) {

case ArtifactShape::Executable:

args.push_back("--strip-all");

break;

case ArtifactShape::SharedLibrary:

args.push_back("--strip-unneeded");

break;

case ArtifactShape::StaticArchive:

args.push_back("--strip-debug");

// Zero the member uid/gid/timestamps while we are rewriting the

// archive anyway: two identical packs should produce identical

// bytes, and this is the one place the packer touches them.

args.push_back("--enable-deterministic-archives");

break;

}

return args;

ArtifactShape shape,

const StripTools& tools,

const std::filesystem::path& debugDir)

{

StripResult out;

std::error_code ec;

if (!std::filesystem::is_regular_file(artifact, ec))

return std::unexpected(std::format("'{}' is not a file", artifact.string()));

if (!tools.inBandDebugInfo) {

// PE/MSVC: the `.pdb` is a separate file and was never inside this one.

out.outcome = StripOutcome::NotApplicable;

return out;

}

if (tools.strip.empty())

return std::unexpected(std::format(

"no `strip` was resolved for this target, so '{}' would ship with its "

"debug information and the publisher's absolute source paths.\n"

" Pass `--no-strip` to ship it as built, or install the binutils that "

"match this toolchain.",

artifact.filename().string()));

out.before = size_of(artifact);

// ── separate, when asked ──────────────────────────────────────────

//

// Not for archives: a `.a` is a container of relocatable objects and

// `--only-keep-debug` on one produces something no debugger consumes.

// dh_strip makes the same exclusion.

const bool separate = !debugDir.empty() && shape != ArtifactShape::StaticArchive;

if (separate) {

if (tools.objcopy.empty())

return std::unexpected(std::format(

"`--debug-symbols` was given but no `objcopy` was resolved for this "

"target, so the debug information for '{}' cannot be separated.",

artifact.filename().string()));

std::filesystem::create_directories(debugDir, ec);

if (ec) return std::unexpected(std::format(

"cannot create '{}': {}", debugDir.string(), ec.message()));

out.debugFile = debugDir / (artifact.filename().string() + ".debug");

auto cmd = std::format("{} --only-keep-debug {} {}",

mcpp::platform::shell::quote(tools.objcopy.string()),

mcpp::platform::shell::quote(artifact.string()),

mcpp::platform::shell::quote(out.debugFile.string()));

if (auto r = run_tool(cmd); !r) return std::unexpected(std::format(

"cannot separate debug information from '{}'.\n{}",

artifact.string(), r.error()));

}

// ── strip ─────────────────────────────────────────────────────────

if (auto r = run_tool(join_quoted(tools.strip, strip_args(shape), artifact)); !r)

return std::unexpected(std::format(

"cannot strip '{}'.\n{}", artifact.string(), r.error()));

// ── and point the stripped artifact back at its symbols ───────────

if (separate) {

auto cmd = std::format("{} --add-gnu-debuglink={} {}",

mcpp::platform::shell::quote(tools.objcopy.string()),

mcpp::platform::shell::quote(out.debugFile.string()),

mcpp::platform::shell::quote(artifact.string()));

if (auto r = run_tool(cmd); !r) return std::unexpected(std::format(

"cannot add the debug link to '{}'.\n{}", artifact.string(), r.error()));

}

out.after = size_of(artifact);

out.outcome = StripOutcome::Stripped;

return out;