Add --compress-debug-sections=zlib:N for configurable zlib compression level

Generalize the zstd:N syntax added in the previous commit so that the
zlib compression level can also be specified. zlib levels 0 through 9
are accepted, where 0 means no compression. Plain `zlib` remains
equivalent to `zlib:1` (the previous hardcoded default).

Also drop the objcopy/zstdcat round-trip from the zstd-level test in
favor of a simpler readelf check, matching the new zlib-level test, and
add error-message coverage for out-of-range levels.

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

Author: rui314

docs/mold.md

@@ -506,12 +506,14 @@ but as `-o magic`.
 * `--no-build-id`:
   Synonym for `--build-id=none`.
 
-* `--compress-debug-sections`=[ `zlib` | `zlib-gabi` | `zstd` | `zstd:`_N_ | `none` ]:
+* `--compress-debug-sections`=[ `zlib` | `zlib-gabi` | `zlib:`_N_ | `zstd` | `zstd:`_N_ | `none` ]:
   Compress DWARF debug info (`.debug_*` sections) using the zlib or zstd
-  compression algorithm. `zlib-gabi` is an alias for `zlib`. `zstd:`_N_
-  selects the zstd compression level, where _N_ is between 1 and 22.
-  Higher levels achieve better compression ratios but are slower.
-  `zstd` is equivalent to `zstd:3`.
+  compression algorithm. `zlib-gabi` is an alias for `zlib`. `zlib:`_N_
+  selects the zlib compression level, where _N_ is between 0 and 9 (0
+  means no compression), and `zstd:`_N_ selects the zstd compression
+  level, where _N_ is between 1 and 22. Higher levels achieve better
+  compression ratios but are slower. `zlib` is equivalent to `zlib:1`
+  and `zstd` is equivalent to `zstd:3`.
 
 * `--defsym`=_symbol_=_value_:
   Define _symbol_ as an alias for _value_.

lib/compress.cc

@@ -45,12 +45,11 @@ static std::vector<std::span<u8>> split(std::span<u8> input) {
   return vec;
 }
 
-static std::span<u8> zlib_compress(std::span<u8> input) {
+static std::span<u8> zlib_compress(std::span<u8> input, int level) {
   // Initialize zlib stream. Since debug info is generally compressed
-  // pretty well with lower compression levels, we chose compression
-  // level 1.
+  // pretty well with lower compression levels, the default level is 1.
   z_stream strm = {};
-  CHECK(deflateInit2(&strm, 1, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY));
+  CHECK(deflateInit2(&strm, level, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY));
 
   // Set an input buffer
   strm.avail_in = input.size();
@@ -94,7 +93,7 @@ static std::span<u8> zlib_compress(std::span<u8> input) {
   return {buf, (size_t)(bufsize - strm.avail_out)};
 }
 
-ZlibCompressor::ZlibCompressor(u8 *buf, i64 size) {
+ZlibCompressor::ZlibCompressor(u8 *buf, i64 size, i64 level) {
   std::vector<std::span<u8>> inputs = split(std::span(buf, size));
   std::vector<u32> adlers(inputs.size());
   shards.resize(inputs.size());
@@ -103,7 +102,7 @@ ZlibCompressor::ZlibCompressor(u8 *buf, i64 size) {
   tbb::parallel_for((i64)0, (i64)inputs.size(), [&](i64 i) {
     std::span<u8> in = inputs[i];
     adlers[i] = adler32(1, in.data(), in.size());
-    shards[i] = zlib_compress(in);
+    shards[i] = zlib_compress(in, level);
   });
 
   // Combine checksums

lib/lib.h

@@ -665,7 +665,7 @@ class Compressor {
 
 class ZlibCompressor : public Compressor {
 public:
-  ZlibCompressor(u8 *buf, i64 size);
+  ZlibCompressor(u8 *buf, i64 size, i64 level);
   void write_to(u8 *buf) override;
 
 private:
@@ -674,7 +674,7 @@ class ZlibCompressor : public Compressor {
 
 class ZstdCompressor : public Compressor {
 public:
-  ZstdCompressor(u8 *buf, i64 size, i64 level = 3);
+  ZstdCompressor(u8 *buf, i64 size, i64 level);
   void write_to(u8 *buf) override;
 };
 

src/cmdline.cc

@@ -89,7 +89,7 @@ static const char helpmsg[] = R"(
   --color-diagnostics=[auto,always,never]
                               Use colors in diagnostics
   --color-diagnostics         Alias for --color-diagnostics=always
-  --compress-debug-sections [none,zlib,zlib-gabi,zstd,zstd:1,...,zstd:22]
+  --compress-debug-sections=[none,zlib,zlib:0,...,zlib:9,zstd,zstd:1,...,zstd:22]
                               Compress .debug_* sections
   --dc                        Ignored
   --dependency-file=FILE      Write Makefile-style dependency rules to FILE
@@ -1041,12 +1041,21 @@ std::vector<std::string> parse_nonpositional_args(Context<E> &ctx) {
     } else if (read_arg("compress-debug-sections")) {
       if (arg == "zlib" || arg == "zlib-gabi") {
         ctx.arg.compress_debug_sections = ELFCOMPRESS_ZLIB;
+        ctx.arg.compress_debug_sections_level = 1;
+      } else if (arg.starts_with("zlib:")) {
+        ctx.arg.compress_debug_sections = ELFCOMPRESS_ZLIB;
+        i64 level = parse_number(ctx, "compress-debug-sections", arg.substr(5));
+        if (level < 0 || 9 < level)
+          Fatal(ctx) << "invalid --compress-debug-sections argument: " << arg
+                     << " (zlib level must be between 0 and 9)";
+        ctx.arg.compress_debug_sections_level = level;
       } else if (arg == "zstd") {
         ctx.arg.compress_debug_sections = ELFCOMPRESS_ZSTD;
+        ctx.arg.compress_debug_sections_level = 3;
       } else if (arg.starts_with("zstd:")) {
         ctx.arg.compress_debug_sections = ELFCOMPRESS_ZSTD;
         i64 level = parse_number(ctx, "compress-debug-sections", arg.substr(5));
-        if (level < 1 || level > 22)
+        if (level < 1 || 22 < level)
           Fatal(ctx) << "invalid --compress-debug-sections argument: " << arg
                      << " (zstd level must be between 1 and 22)";
         ctx.arg.compress_debug_sections_level = level;

src/mold.h

@@ -2420,7 +2420,7 @@ struct Context {
     bool z_text = false;
     bool zero_to_bss = false;
     i64 compress_debug_sections = ELFCOMPRESS_NONE;
-    i64 compress_debug_sections_level = 3;
+    i64 compress_debug_sections_level = 0;
     i64 filler = -1;
     i64 spare_dynamic_tags = 5;
     i64 spare_program_headers = 0;

src/output-chunks.cc

@@ -2861,7 +2861,8 @@ CompressedSection<E>::CompressedSection(Context<E> &ctx, Chunk<E> &chunk) {
   chunk.write_to(ctx, buf.get());
 
   if (ctx.arg.compress_debug_sections == ELFCOMPRESS_ZLIB)
-    compressor.reset(new ZlibCompressor(buf.get(), chunk.shdr.sh_size));
+    compressor.reset(new ZlibCompressor(buf.get(), chunk.shdr.sh_size,
+                                        ctx.arg.compress_debug_sections_level));
   else
     compressor.reset(new ZstdCompressor(buf.get(), chunk.shdr.sh_size,
                                         ctx.arg.compress_debug_sections_level));

test/compress-debug-sections-zlib-level.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+. $(dirname $0)/common.inc
+
+cat <<EOF | $CC -c -g -o $t/a.o -xc -
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main() { printf("Hello world\n"); }
+EOF
+
+# Level 0 stores data uncompressed; level 9 compresses hardest.
+# The level-0 executable must be larger than the level-9 one.
+$CC -B. -o $t/exe0 $t/a.o -Wl,--compress-debug-sections=zlib:0
+$CC -B. -o $t/exe9 $t/a.o -Wl,--compress-debug-sections=zlib:9
+readelf -WS $t/exe0 | grep -q '\.debug_info .* [Cx] '
+readelf -WS $t/exe9 | grep -q '\.debug_info .* [Cx] '
+[ $(wc -c < $t/exe0) -gt $(wc -c < $t/exe9) ]
+
+# Out-of-range level should fail with a descriptive error
+not $CC -B. -o $t/exe-1 $t/a.o -Wl,--compress-debug-sections=zlib:-1 |&
+  grep 'zlib level must be between 0 and 9'
+not $CC -B. -o $t/exe10 $t/a.o -Wl,--compress-debug-sections=zlib:10 |&
+  grep 'zlib level must be between 0 and 9'

test/compress-debug-sections-zstd-level.sh

@@ -1,29 +1,21 @@
 #!/bin/bash
 . $(dirname $0)/common.inc
 
-# arm-linux-gnueabihf-objcopy crashes on x86-64
-[[ $MACHINE = arm* ]] && skip
-[ $MACHINE = riscv32 ] && skip
-
-command -v zstdcat >& /dev/null || skip
-
 cat <<EOF | $CC -c -g -o $t/a.o -xc -
 #include <stdio.h>
-
-int main() {
-  printf("Hello world\n");
-  return 0;
-}
+int main() { printf("Hello world\n"); }
 EOF
 
 # Test zstd:1 (lowest level)
 $CC -B. -o $t/exe1 $t/a.o -Wl,--compress-debug-sections=zstd:1
-$OBJCOPY --dump-section .debug_info=$t/debug_info1 $t/exe1
-dd if=$t/debug_info1 of=$t/debug_info1.zstd bs=24 skip=1 status=none
-zstdcat $t/debug_info1.zstd > /dev/null
+readelf -WS $t/exe1 | grep -q '\.debug_info .* [Cx] '
+
+# Test zstd:22 (highest level)
+$CC -B. -o $t/exe22 $t/a.o -Wl,--compress-debug-sections=zstd:22
+readelf -WS $t/exe22 | grep -q '\.debug_info .* [Cx] '
 
-# Test zstd:19 (high level)
-$CC -B. -o $t/exe19 $t/a.o -Wl,--compress-debug-sections=zstd:19
-$OBJCOPY --dump-section .debug_info=$t/debug_info19 $t/exe19
-dd if=$t/debug_info19 of=$t/debug_info19.zstd bs=24 skip=1 status=none
-zstdcat $t/debug_info19.zstd > /dev/null
+# Out-of-range level should fail with a descriptive error
+not $CC -B. -o $t/exe0 $t/a.o -Wl,--compress-debug-sections=zstd:0 |&
+  grep 'zstd level must be between 1 and 22'
+not $CC -B. -o $t/exe23 $t/a.o -Wl,--compress-debug-sections=zstd:23 |&
+  grep 'zstd level must be between 1 and 22'