| ... | @@ -1,343 +0,0 @@ |
| 1 | const std = @import("std"); |
| 2 | const fs = std.fs; |
| 3 | const fmt = std.fmt; |
| 4 | const assert = std.debug.assert; |
| 5 | |
| 6 | // Example abilist path: |
| 7 | // ./sysdeps/unix/sysv/linux/aarch64/libc.abilist |
| 8 | const AbiList = struct { |
| 9 | targets: []const ZigTarget, |
| 10 | path: []const u8, |
| 11 | }; |
| 12 | const ZigTarget = struct { |
| 13 | arch: std.Target.Cpu.Arch, |
| 14 | abi: std.Target.Abi, |
| 15 | }; |
| 16 | |
| 17 | const lib_names = [_][]const u8{ |
| 18 | "c", |
| 19 | "dl", |
| 20 | "m", |
| 21 | "pthread", |
| 22 | "rt", |
| 23 | "ld", |
| 24 | "util", |
| 25 | }; |
| 26 | |
| 27 | // fpu/nofpu are hardcoded elsewhere, based on .gnueabi/.gnueabihf with an exception for .arm |
| 28 | // n64/n32 are hardcoded elsewhere, based on .gnuabi64/.gnuabin32 |
| 29 | const abi_lists = [_]AbiList{ |
| 30 | AbiList{ |
| 31 | .targets = &[_]ZigTarget{ |
| 32 | ZigTarget{ .arch = .aarch64, .abi = .gnu }, |
| 33 | ZigTarget{ .arch = .aarch64_be, .abi = .gnu }, |
| 34 | }, |
| 35 | .path = "aarch64", |
| 36 | }, |
| 37 | AbiList{ |
| 38 | .targets = &[_]ZigTarget{ZigTarget{ .arch = .s390x, .abi = .gnu }}, |
| 39 | .path = "s390/s390-64", |
| 40 | }, |
| 41 | AbiList{ |
| 42 | .targets = &[_]ZigTarget{ |
| 43 | ZigTarget{ .arch = .arm, .abi = .gnueabi }, |
| 44 | ZigTarget{ .arch = .armeb, .abi = .gnueabi }, |
| 45 | ZigTarget{ .arch = .arm, .abi = .gnueabihf }, |
| 46 | ZigTarget{ .arch = .armeb, .abi = .gnueabihf }, |
| 47 | }, |
| 48 | .path = "arm", |
| 49 | }, |
| 50 | AbiList{ |
| 51 | .targets = &[_]ZigTarget{ |
| 52 | ZigTarget{ .arch = .sparc, .abi = .gnu }, |
| 53 | ZigTarget{ .arch = .sparcel, .abi = .gnu }, |
| 54 | }, |
| 55 | .path = "sparc/sparc32", |
| 56 | }, |
| 57 | AbiList{ |
| 58 | .targets = &[_]ZigTarget{ZigTarget{ .arch = .sparcv9, .abi = .gnu }}, |
| 59 | .path = "sparc/sparc64", |
| 60 | }, |
| 61 | AbiList{ |
| 62 | .targets = &[_]ZigTarget{ |
| 63 | ZigTarget{ .arch = .mips64el, .abi = .gnuabi64 }, |
| 64 | ZigTarget{ .arch = .mips64, .abi = .gnuabi64 }, |
| 65 | }, |
| 66 | .path = "mips/mips64", |
| 67 | }, |
| 68 | AbiList{ |
| 69 | .targets = &[_]ZigTarget{ |
| 70 | ZigTarget{ .arch = .mips64el, .abi = .gnuabin32 }, |
| 71 | ZigTarget{ .arch = .mips64, .abi = .gnuabin32 }, |
| 72 | }, |
| 73 | .path = "mips/mips64", |
| 74 | }, |
| 75 | AbiList{ |
| 76 | .targets = &[_]ZigTarget{ |
| 77 | ZigTarget{ .arch = .mipsel, .abi = .gnueabihf }, |
| 78 | ZigTarget{ .arch = .mips, .abi = .gnueabihf }, |
| 79 | }, |
| 80 | .path = "mips/mips32", |
| 81 | }, |
| 82 | AbiList{ |
| 83 | .targets = &[_]ZigTarget{ |
| 84 | ZigTarget{ .arch = .mipsel, .abi = .gnueabi }, |
| 85 | ZigTarget{ .arch = .mips, .abi = .gnueabi }, |
| 86 | }, |
| 87 | .path = "mips/mips32", |
| 88 | }, |
| 89 | AbiList{ |
| 90 | .targets = &[_]ZigTarget{ZigTarget{ .arch = .x86_64, .abi = .gnu }}, |
| 91 | .path = "x86_64/64", |
| 92 | }, |
| 93 | AbiList{ |
| 94 | .targets = &[_]ZigTarget{ZigTarget{ .arch = .x86_64, .abi = .gnux32 }}, |
| 95 | .path = "x86_64/x32", |
| 96 | }, |
| 97 | AbiList{ |
| 98 | .targets = &[_]ZigTarget{ZigTarget{ .arch = .i386, .abi = .gnu }}, |
| 99 | .path = "i386", |
| 100 | }, |
| 101 | AbiList{ |
| 102 | .targets = &[_]ZigTarget{ZigTarget{ .arch = .powerpc64le, .abi = .gnu }}, |
| 103 | .path = "powerpc/powerpc64/le", |
| 104 | }, |
| 105 | AbiList{ |
| 106 | .targets = &[_]ZigTarget{ZigTarget{ .arch = .powerpc64, .abi = .gnu }}, |
| 107 | .path = "powerpc/powerpc64/be", |
| 108 | }, |
| 109 | AbiList{ |
| 110 | .targets = &[_]ZigTarget{ |
| 111 | ZigTarget{ .arch = .powerpc, .abi = .gnueabi }, |
| 112 | ZigTarget{ .arch = .powerpc, .abi = .gnueabihf }, |
| 113 | }, |
| 114 | .path = "powerpc/powerpc32", |
| 115 | }, |
| 116 | }; |
| 117 | |
| 118 | const FunctionSet = struct { |
| 119 | list: std.ArrayList(VersionedFn), |
| 120 | fn_vers_list: FnVersionList, |
| 121 | }; |
| 122 | const FnVersionList = std.StringHashMap(std.ArrayList(usize)); |
| 123 | |
| 124 | const VersionedFn = struct { |
| 125 | ver: []const u8, // example: "GLIBC_2.15" |
| 126 | name: []const u8, // example: "puts" |
| 127 | }; |
| 128 | const Function = struct { |
| 129 | name: []const u8, // example: "puts" |
| 130 | lib: []const u8, // example: "c" |
| 131 | index: usize, |
| 132 | }; |
| 133 | |
| 134 | pub fn main() !void { |
| 135 | var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); |
| 136 | const allocator = arena.allocator(); |
| 137 | const args = try std.process.argsAlloc(allocator); |
| 138 | const in_glibc_dir = args[1]; // path to the unzipped tarball of glibc, e.g. ~/downloads/glibc-2.25 |
| 139 | const zig_src_dir = args[2]; // path to the source checkout of zig, lib dir, e.g. ~/zig-src/lib |
| 140 | |
| 141 | const prefix = try fs.path.join(allocator, &[_][]const u8{ in_glibc_dir, "sysdeps", "unix", "sysv", "linux" }); |
| 142 | const glibc_out_dir = try fs.path.join(allocator, &[_][]const u8{ zig_src_dir, "libc", "glibc" }); |
| 143 | |
| 144 | var global_fn_set = std.StringHashMap(Function).init(allocator); |
| 145 | var global_ver_set = std.StringHashMap(usize).init(allocator); |
| 146 | var target_functions = std.AutoHashMap(usize, FunctionSet).init(allocator); |
| 147 | |
| 148 | for (abi_lists) |*abi_list| { |
| 149 | const target_funcs_gop = try target_functions.getOrPut(@ptrToInt(abi_list)); |
| 150 | if (!target_funcs_gop.found_existing) { |
| 151 | target_funcs_gop.value_ptr.* = FunctionSet{ |
| 152 | .list = std.ArrayList(VersionedFn).init(allocator), |
| 153 | .fn_vers_list = FnVersionList.init(allocator), |
| 154 | }; |
| 155 | } |
| 156 | const fn_set = &target_funcs_gop.value_ptr.list; |
| 157 | |
| 158 | for (lib_names) |lib_name| { |
| 159 | const lib_prefix = if (std.mem.eql(u8, lib_name, "ld")) "" else "lib"; |
| 160 | const basename = try fmt.allocPrint(allocator, "{s}{s}.abilist", .{ lib_prefix, lib_name }); |
| 161 | const abi_list_filename = blk: { |
| 162 | const is_c = std.mem.eql(u8, lib_name, "c"); |
| 163 | const is_m = std.mem.eql(u8, lib_name, "m"); |
| 164 | const is_ld = std.mem.eql(u8, lib_name, "ld"); |
| 165 | if (abi_list.targets[0].abi == .gnuabi64 and (is_c or is_ld)) { |
| 166 | break :blk try fs.path.join(allocator, &[_][]const u8{ prefix, abi_list.path, "n64", basename }); |
| 167 | } else if (abi_list.targets[0].abi == .gnuabin32 and (is_c or is_ld)) { |
| 168 | break :blk try fs.path.join(allocator, &[_][]const u8{ prefix, abi_list.path, "n32", basename }); |
| 169 | } else if (abi_list.targets[0].arch != .arm and |
| 170 | abi_list.targets[0].abi == .gnueabihf and |
| 171 | (is_c or (is_m and abi_list.targets[0].arch == .powerpc))) |
| 172 | { |
| 173 | break :blk try fs.path.join(allocator, &[_][]const u8{ prefix, abi_list.path, "fpu", basename }); |
| 174 | } else if (abi_list.targets[0].arch != .arm and |
| 175 | abi_list.targets[0].abi == .gnueabi and |
| 176 | (is_c or (is_m and abi_list.targets[0].arch == .powerpc))) |
| 177 | { |
| 178 | break :blk try fs.path.join(allocator, &[_][]const u8{ prefix, abi_list.path, "nofpu", basename }); |
| 179 | } else if (abi_list.targets[0].arch == .arm) { |
| 180 | break :blk try fs.path.join(allocator, &[_][]const u8{ prefix, abi_list.path, "le", basename }); |
| 181 | } else if (abi_list.targets[0].arch == .armeb) { |
| 182 | break :blk try fs.path.join(allocator, &[_][]const u8{ prefix, abi_list.path, "be", basename }); |
| 183 | } |
| 184 | break :blk try fs.path.join(allocator, &[_][]const u8{ prefix, abi_list.path, basename }); |
| 185 | }; |
| 186 | const max_bytes = 10 * 1024 * 1024; |
| 187 | const contents = std.fs.cwd().readFileAlloc(allocator, abi_list_filename, max_bytes) catch |err| { |
| 188 | std.debug.print("unable to open {s}: {}\n", .{ abi_list_filename, err }); |
| 189 | std.process.exit(1); |
| 190 | }; |
| 191 | var lines_it = std.mem.tokenize(u8, contents, "\n"); |
| 192 | while (lines_it.next()) |line| { |
| 193 | var tok_it = std.mem.tokenize(u8, line, " "); |
| 194 | const ver = tok_it.next().?; |
| 195 | const name = tok_it.next().?; |
| 196 | const category = tok_it.next().?; |
| 197 | if (!std.mem.eql(u8, category, "F") and |
| 198 | !std.mem.eql(u8, category, "D")) |
| 199 | { |
| 200 | continue; |
| 201 | } |
| 202 | if (std.mem.startsWith(u8, ver, "GCC_")) continue; |
| 203 | try global_ver_set.put(ver, undefined); |
| 204 | const gop = try global_fn_set.getOrPut(name); |
| 205 | if (gop.found_existing) { |
| 206 | if (!std.mem.eql(u8, gop.value_ptr.lib, "c")) { |
| 207 | gop.value_ptr.lib = lib_name; |
| 208 | } |
| 209 | } else { |
| 210 | gop.value_ptr.* = Function{ |
| 211 | .name = name, |
| 212 | .lib = lib_name, |
| 213 | .index = undefined, |
| 214 | }; |
| 215 | } |
| 216 | try fn_set.append(VersionedFn{ |
| 217 | .ver = ver, |
| 218 | .name = name, |
| 219 | }); |
| 220 | } |
| 221 | } |
| 222 | } |
| 223 | |
| 224 | const global_fn_list = blk: { |
| 225 | var list = std.ArrayList([]const u8).init(allocator); |
| 226 | var it = global_fn_set.keyIterator(); |
| 227 | while (it.next()) |key| try list.append(key.*); |
| 228 | std.sort.sort([]const u8, list.items, {}, strCmpLessThan); |
| 229 | break :blk list.items; |
| 230 | }; |
| 231 | const global_ver_list = blk: { |
| 232 | var list = std.ArrayList([]const u8).init(allocator); |
| 233 | var it = global_ver_set.keyIterator(); |
| 234 | while (it.next()) |key| try list.append(key.*); |
| 235 | std.sort.sort([]const u8, list.items, {}, versionLessThan); |
| 236 | break :blk list.items; |
| 237 | }; |
| 238 | { |
| 239 | const vers_txt_path = try fs.path.join(allocator, &[_][]const u8{ glibc_out_dir, "vers.txt" }); |
| 240 | const vers_txt_file = try fs.cwd().createFile(vers_txt_path, .{}); |
| 241 | defer vers_txt_file.close(); |
| 242 | var buffered = std.io.bufferedWriter(vers_txt_file.writer()); |
| 243 | const vers_txt = buffered.writer(); |
| 244 | for (global_ver_list) |name, i| { |
| 245 | global_ver_set.put(name, i) catch unreachable; |
| 246 | try vers_txt.print("{s}\n", .{name}); |
| 247 | } |
| 248 | try buffered.flush(); |
| 249 | } |
| 250 | { |
| 251 | const fns_txt_path = try fs.path.join(allocator, &[_][]const u8{ glibc_out_dir, "fns.txt" }); |
| 252 | const fns_txt_file = try fs.cwd().createFile(fns_txt_path, .{}); |
| 253 | defer fns_txt_file.close(); |
| 254 | var buffered = std.io.bufferedWriter(fns_txt_file.writer()); |
| 255 | const fns_txt = buffered.writer(); |
| 256 | for (global_fn_list) |name, i| { |
| 257 | const value = global_fn_set.getPtr(name).?; |
| 258 | value.index = i; |
| 259 | try fns_txt.print("{s} {s}\n", .{ name, value.lib }); |
| 260 | } |
| 261 | try buffered.flush(); |
| 262 | } |
| 263 | |
| 264 | // Now the mapping of version and function to integer index is complete. |
| 265 | // Here we create a mapping of function name to list of versions. |
| 266 | for (abi_lists) |*abi_list| { |
| 267 | const value = target_functions.getPtr(@ptrToInt(abi_list)).?; |
| 268 | const fn_vers_list = &value.fn_vers_list; |
| 269 | for (value.list.items) |*ver_fn| { |
| 270 | const gop = try fn_vers_list.getOrPut(ver_fn.name); |
| 271 | if (!gop.found_existing) { |
| 272 | gop.value_ptr.* = std.ArrayList(usize).init(allocator); |
| 273 | } |
| 274 | const ver_index = global_ver_set.get(ver_fn.ver).?; |
| 275 | if (std.mem.indexOfScalar(usize, gop.value_ptr.items, ver_index) == null) { |
| 276 | try gop.value_ptr.append(ver_index); |
| 277 | } |
| 278 | } |
| 279 | } |
| 280 | |
| 281 | { |
| 282 | const abilist_txt_path = try fs.path.join(allocator, &[_][]const u8{ glibc_out_dir, "abi.txt" }); |
| 283 | const abilist_txt_file = try fs.cwd().createFile(abilist_txt_path, .{}); |
| 284 | defer abilist_txt_file.close(); |
| 285 | var buffered = std.io.bufferedWriter(abilist_txt_file.writer()); |
| 286 | const abilist_txt = buffered.writer(); |
| 287 | |
| 288 | // first iterate over the abi lists |
| 289 | for (abi_lists) |*abi_list| { |
| 290 | const fn_vers_list = &target_functions.getPtr(@ptrToInt(abi_list)).?.fn_vers_list; |
| 291 | for (abi_list.targets) |target, it_i| { |
| 292 | if (it_i != 0) try abilist_txt.writeByte(' '); |
| 293 | try abilist_txt.print("{s}-linux-{s}", .{ @tagName(target.arch), @tagName(target.abi) }); |
| 294 | } |
| 295 | try abilist_txt.writeByte('\n'); |
| 296 | // next, each line implicitly corresponds to a function |
| 297 | for (global_fn_list) |name| { |
| 298 | const value = fn_vers_list.getPtr(name) orelse { |
| 299 | try abilist_txt.writeByte('\n'); |
| 300 | continue; |
| 301 | }; |
| 302 | for (value.items) |ver_index, it_i| { |
| 303 | if (it_i != 0) try abilist_txt.writeByte(' '); |
| 304 | try abilist_txt.print("{d}", .{ver_index}); |
| 305 | } |
| 306 | try abilist_txt.writeByte('\n'); |
| 307 | } |
| 308 | } |
| 309 | |
| 310 | try buffered.flush(); |
| 311 | } |
| 312 | } |
| 313 | |
| 314 | pub fn strCmpLessThan(context: void, a: []const u8, b: []const u8) bool { |
| 315 | _ = context; |
| 316 | return std.mem.order(u8, a, b) == .lt; |
| 317 | } |
| 318 | |
| 319 | pub fn versionLessThan(context: void, a: []const u8, b: []const u8) bool { |
| 320 | _ = context; |
| 321 | const sep_chars = "GLIBC_."; |
| 322 | var a_tokens = std.mem.tokenize(u8, a, sep_chars); |
| 323 | var b_tokens = std.mem.tokenize(u8, b, sep_chars); |
| 324 | |
| 325 | while (true) { |
| 326 | const a_next = a_tokens.next(); |
| 327 | const b_next = b_tokens.next(); |
| 328 | if (a_next == null and b_next == null) { |
| 329 | return false; // equal means not less than |
| 330 | } else if (a_next == null) { |
| 331 | return true; |
| 332 | } else if (b_next == null) { |
| 333 | return false; |
| 334 | } |
| 335 | const a_int = fmt.parseInt(u64, a_next.?, 10) catch unreachable; |
| 336 | const b_int = fmt.parseInt(u64, b_next.?, 10) catch unreachable; |
| 337 | if (a_int < b_int) { |
| 338 | return true; |
| 339 | } else if (a_int > b_int) { |
| 340 | return false; |
| 341 | } |
| 342 | } |
| 343 | } |
Andrew Kelley <andrew@ziglang.org> 2021-12-14 21:44:44-07:00
tools