summaryrefslogtreecommitdiff
path: root/tools/shared_libs_check.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
committerGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
commit6d8da8721141284cf33bb901168b26135893eb86 (patch)
tree791d63401d4e85fbca1d597a8ce0326e70efd545 /tools/shared_libs_check.zig
parentefd43a3a2cf03bb741366331158b368abf9ac583 (diff)
parentbf6810a8f9d6cc82050e7d9c0cfb06358301b574 (diff)
downloadpardes-6d8da8721141284cf33bb901168b26135893eb86.tar.gz
pardes-6d8da8721141284cf33bb901168b26135893eb86.zip
Merge latest upstream into the macOS branch for Zig 0.17
Retain the macOS branch history and local Acme selection color while adopting upstream's current core and platform changes. Pin Zig and ZLS to 0.17.0, and fetch the existing zstbi compatibility commit through upstream after its original fork was removed.
Diffstat (limited to 'tools/shared_libs_check.zig')
-rw-r--r--tools/shared_libs_check.zig127
1 files changed, 127 insertions, 0 deletions
diff --git a/tools/shared_libs_check.zig b/tools/shared_libs_check.zig
new file mode 100644
index 00000000..d18c6850
--- /dev/null
+++ b/tools/shared_libs_check.zig
@@ -0,0 +1,127 @@
+//! One copy of each codec in a pardes binary (docs/shared-libs.md).
+//!
+//! zig build shared-libs-check -Dplatform=tty|gui
+//!
+//! Reads the linked executable's ELF symbol table and fails when a family of
+//! symbols the build has chosen against is in it: a second PNG, JPEG or
+//! inflate implementation beside the one docs/shared-libs.md names for the
+//! job. The families are named by functions each copy defines (static ones
+//! too: the symbol table keeps locals), so a dependency that brings its own
+//! copy back shows here, whatever its symbols are called in the end.
+const std = @import("std");
+
+const Family = struct {
+ /// What the family is, and what the build uses instead.
+ what: []const u8,
+ /// Functions only that copy defines; an optimized build inlines some
+ /// of them, so a copy counts as linked when any is there, as many
+ /// times as the most of them are.
+ symbols: []const []const u8,
+ /// How many copies may be linked (0: none).
+ most: usize = 0,
+};
+
+const stb_png = [_][]const u8{ "stbi__png_load", "stbi__parse_png_file", "stbi__create_png_image_raw" };
+const stb_jpeg = [_][]const u8{ "stbi__jpeg_load", "stbi__decode_jpeg_header", "stbi__jpeg_decode_block" };
+const stb_inflate = [_][]const u8{ "stbi__parse_zlib", "stbi__do_zlib", "stbi__zbuild_huffman", "stbi__zhuffman_decode" };
+const stb_deflate = [_][]const u8{ "stbi_zlib_compress", "stbiw__zlib_bitrev", "stbi_write_png_to_mem" };
+
+/// Banned in every binary that links ghostty-vt (wuffs decodes PNG and
+/// JPEG; zlib and wuffs are the two inflates, see docs/shared-libs.md).
+const with_wuffs = [_]Family{
+ .{ .what = "stb_image's PNG decoder (wuffs decodes PNG: STBI_NO_PNG)", .symbols = &stb_png },
+ .{ .what = "stb_image's JPEG decoder (wuffs decodes JPEG: STBI_NO_JPEG)", .symbols = &stb_jpeg },
+ .{ .what = "stb_image's own inflate (zlib and wuffs inflate)", .symbols = &stb_inflate },
+};
+
+/// Banned everywhere.
+const always = [_]Family{
+ // SDL's SDL_stb.c (SDL_LoadPNG, camera MJPEG) is off: SDL_DISABLE_STB.
+ .{ .what = "a second stb_image PNG decoder (SDL_stb.c)", .symbols = &stb_png, .most = 1 },
+ .{ .what = "a second stb_image JPEG decoder (SDL_stb.c)", .symbols = &stb_jpeg, .most = 1 },
+ // zstbi's stb_image_write, patched out: its own deflate beside zlib's.
+ .{ .what = "stb_image_write and its deflate (zlib deflates)", .symbols = &stb_deflate },
+ // One zlib: FreeType's, which MuPDF links (mupdf.zig).
+ .{ .what = "a second zlib", .symbols = &.{ "inflate_table", "inflate_fast", "deflate_slow" }, .most = 1 },
+ // One FreeType: the build's, which MuPDF is compiled against.
+ .{ .what = "a second FreeType", .symbols = &.{ "FT_Init_FreeType", "FT_New_Library" }, .most = 1 },
+};
+
+pub fn main(init: std.process.Init) !void {
+ var arena_state: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
+ defer arena_state.deinit();
+ const arena = arena_state.allocator();
+ const args = try init.minimal.args.toSlice(arena);
+ if (args.len != 2) return error.BadArgs;
+ const bytes = try readFile(arena, try arena.dupeSentinel(u8, args[1], 0));
+
+ var counts = std.StringHashMap(usize).init(arena);
+ try symbols(bytes, &counts);
+ if (counts.count() == 0) {
+ std.debug.print("shared-libs-check: {s} has no symbol table (stripped?): nothing to check\n", .{args[1]});
+ return;
+ }
+ const wuffs = counts.get("wuffs_zlib__decoder__transform_io") != null or
+ counts.get("wuffs_base__pixel_swizzler__prepare") != null;
+ var failed = false;
+ for ([2][]const Family{ &always, if (wuffs) &with_wuffs else &.{} }) |set| for (set) |family| {
+ var n: usize = 0;
+ var seen: []const u8 = family.symbols[0];
+ for (family.symbols) |symbol| {
+ const here = counts.get(symbol) orelse 0;
+ if (here > n) {
+ n = here;
+ seen = symbol;
+ }
+ }
+ if (n > family.most) {
+ failed = true;
+ std.debug.print("shared-libs-check: {s}: `{s}` is linked {d} times (at most {d})\n", .{ family.what, seen, n, family.most });
+ }
+ };
+ if (failed) return error.DuplicateLibrary;
+ std.debug.print("shared-libs-check: one copy of each ({d} symbols{s})\n", .{ counts.count(), if (wuffs) ", wuffs present" else "" });
+}
+
+/// Counts every name in the ELF64 little-endian symbol tables of `bytes`.
+fn symbols(bytes: []const u8, counts: *std.StringHashMap(usize)) !void {
+ if (bytes.len < @sizeOf(std.elf.Elf64_Ehdr) or !std.mem.eql(u8, bytes[0..4], "\x7fELF")) return error.NotElf;
+ if (bytes[std.elf.EI.CLASS] != std.elf.ELFCLASS64 or bytes[std.elf.EI.DATA] != std.elf.ELFDATA2LSB) return error.UnsupportedElf;
+ const eh = std.mem.bytesAsValue(std.elf.Elf64_Ehdr, bytes[0..@sizeOf(std.elf.Elf64_Ehdr)]);
+ const shoff: usize = @intCast(eh.e_shoff);
+ const shnum: usize = eh.e_shnum;
+ const shsize: usize = eh.e_shentsize;
+ if (shsize != @sizeOf(std.elf.Elf64_Shdr) or shoff + shnum * shsize > bytes.len) return error.BadSections;
+ const sections = std.mem.bytesAsSlice(std.elf.Elf64_Shdr, @as([]align(1) const u8, bytes[shoff..][0 .. shnum * shsize]));
+ for (sections) |section| {
+ if (section.sh_type != std.elf.SHT_SYMTAB) continue;
+ const strtab = sections[section.sh_link];
+ const strings = bytes[@intCast(strtab.sh_offset)..][0..@intCast(strtab.sh_size)];
+ const table = bytes[@intCast(section.sh_offset)..][0..@intCast(section.sh_size)];
+ const syms = std.mem.bytesAsSlice(std.elf.Elf64_Sym, @as([]align(1) const u8, table));
+ for (syms) |sym| {
+ // Functions only: a family is the code it brings.
+ if (sym.st_type() != std.elf.STT_FUNC or sym.st_shndx == 0) continue;
+ const name = std.mem.sliceTo(strings[sym.st_name..], 0);
+ const gop = try counts.getOrPut(name);
+ gop.value_ptr.* = if (gop.found_existing) gop.value_ptr.* + 1 else 1;
+ }
+ }
+}
+
+fn readFile(arena: std.mem.Allocator, path: [:0]const u8) ![]u8 {
+ const c = std.c;
+ const fd = c.open(path, .{ .ACCMODE = .RDONLY }, @as(c.mode_t, 0));
+ if (fd < 0) return error.OpenFailed;
+ defer _ = c.close(fd);
+ const end = c.lseek(fd, 0, c.SEEK.END);
+ if (end < 0 or c.lseek(fd, 0, c.SEEK.SET) < 0) return error.ReadFailed;
+ const out = try arena.alloc(u8, @intCast(end));
+ var filled: usize = 0;
+ while (filled < out.len) {
+ const n = c.read(fd, out[filled..].ptr, out.len - filled);
+ if (n <= 0) return error.ReadFailed;
+ filled += @intCast(n);
+ }
+ return out;
+}