1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
//! 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 },
// One zstd: the build's, a far replica's stream (src/replica.zig).
.{ .what = "a second zstd", .symbols = &.{ "ZSTD_compressStream2", "ZSTD_decompressStream", "ZSTD_createCCtx_advanced" }, .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;
}
|