From 96bd268c8c07b8aae0372317bfea60ef2fb3f257 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Tue, 10 Feb 2026 13:06:18 -0800 Subject: [PATCH] zig libc: simplify implementation - use symbol export helper - move all declarations from common.zig into c.zig - correct documentation - delete dead code --- lib/c.zig | 63 +++++++++++++-------- lib/c/common.zig | 29 ---------- lib/c/ctype.zig | 92 +++++++++++++++--------------- lib/c/inttypes.zig | 10 ++-- lib/c/math.zig | 74 ++++++++++++------------ lib/c/stdlib.zig | 54 +++++++++--------- lib/c/stdlib/drand48.zig | 24 ++++---- lib/c/stdlib/rand.zig | 10 ++-- lib/c/string.zig | 84 +++++++++++++-------------- lib/c/strings.zig | 30 +++++----- lib/c/sys.zig | 7 --- lib/c/sys/capability.zig | 15 +++-- lib/c/sys/file.zig | 11 ++-- lib/c/sys/mman.zig | 41 +++++++------- lib/c/sys/reboot.zig | 11 ++-- lib/c/sys/utsname.zig | 13 +++-- lib/c/unistd.zig | 119 ++++++++++++++++++++------------------- lib/c/wchar.zig | 66 +++++++++++----------- 18 files changed, 382 insertions(+), 371 deletions(-) delete mode 100644 lib/c/common.zig delete mode 100644 lib/c/sys.zig diff --git a/lib/c.zig b/lib/c.zig index 681a6f73a5..c25293b84d 100644 --- a/lib/c.zig +++ b/lib/c.zig @@ -1,7 +1,9 @@ -//! This is Zig's multi-target implementation of libc. +//! Multi-target implementation of libc, providing ABI compatibility with +//! bundled libcs. //! -//! When `builtin.link_libc` is true, we need to export all the functions and -//! provide a libc API compatible with the target (e.g. musl, wasi-libc, ...). +//! mingw-w64 libc is not fully statically linked, so some symbols don't need +//! to be exported. However, a future enhancement could be eliminating Zig's +//! dependency on msvcrt dll even when linking libc and targeting Windows. const builtin = @import("builtin"); const std = @import("std"); @@ -13,8 +15,36 @@ pub const panic = if (builtin.is_test) else std.debug.no_panic; -// NOTE: `libzigc` aims to be a standalone libc and provide ABI compatibility with its bundled libc's. -// Some of them like `mingw` are not fully statically linked so some symbols don't need to be exported. +/// It is incorrect to make this conditional on `builtin.is_test`, because it is possible that +/// libzigc is being linked into a different test compilation, as opposed to being tested itself. +pub const linkage: std.builtin.GlobalLinkage = .strong; + +/// Determines the symbol's visibility to other objects. +/// For WebAssembly this allows the symbol to be resolved to other modules, but will not +/// export it to the host runtime. +pub const visibility: std.builtin.SymbolVisibility = .hidden; + +pub inline fn symbol(comptime func: *const anyopaque, comptime name: []const u8) void { + @export(func, .{ .name = name, .linkage = linkage, .visibility = visibility }); +} + +/// Given a low-level syscall return value, sets errno and returns `-1`, or on +/// success returns the result. +pub fn errno(syscall_return_value: usize) c_int { + return switch (builtin.os.tag) { + .linux => { + const signed: isize = @bitCast(syscall_return_value); + const casted: c_int = @intCast(signed); + if (casted < 0) { + @branchHint(.unlikely); + std.c._errno().* = -casted; + return -1; + } + return casted; + }, + else => comptime unreachable, + }; +} comptime { _ = @import("c/inttypes.zig"); @@ -25,22 +55,11 @@ comptime { _ = @import("c/strings.zig"); _ = @import("c/wchar.zig"); - _ = @import("c/sys.zig"); + _ = @import("c/sys/mman.zig"); + _ = @import("c/sys/file.zig"); + _ = @import("c/sys/reboot.zig"); + _ = @import("c/sys/capability.zig"); + _ = @import("c/sys/utsname.zig"); + _ = @import("c/unistd.zig"); - - if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) { - // Files specific to musl and wasi-libc. - } - - if (builtin.target.isMuslLibC()) { - // Files specific to musl. - } - - if (builtin.target.isWasiLibC()) { - // Files specific to wasi-libc. - } - - if (builtin.target.isMinGW()) { - // Files specific to MinGW-w64. - } } diff --git a/lib/c/common.zig b/lib/c/common.zig deleted file mode 100644 index 5cd94cf0ce..0000000000 --- a/lib/c/common.zig +++ /dev/null @@ -1,29 +0,0 @@ -const builtin = @import("builtin"); -const std = @import("std"); - -/// It is incorrect to make this conditional on `builtin.is_test`, because it is possible that -/// libzigc is being linked into a different test compilation, as opposed to being tested itself. -pub const linkage: std.builtin.GlobalLinkage = .strong; - -/// Determines the symbol's visibility to other objects. -/// For WebAssembly this allows the symbol to be resolved to other modules, but will not -/// export it to the host runtime. -pub const visibility: std.builtin.SymbolVisibility = .hidden; - -/// Given a low-level syscall return value, sets errno and returns `-1`, or on -/// success returns the result. -pub fn errno(syscall_return_value: usize) c_int { - return switch (builtin.os.tag) { - .linux => { - const signed: isize = @bitCast(syscall_return_value); - const casted: c_int = @intCast(signed); - if (casted < 0) { - @branchHint(.unlikely); - std.c._errno().* = -casted; - return -1; - } - return casted; - }, - else => comptime unreachable, - }; -} diff --git a/lib/c/ctype.zig b/lib/c/ctype.zig index 5fd5669fae..9316ee102f 100644 --- a/lib/c/ctype.zig +++ b/lib/c/ctype.zig @@ -1,57 +1,57 @@ -const std = @import("std"); -const common = @import("common.zig"); const builtin = @import("builtin"); +const std = @import("std"); +const symbol = @import("../c.zig").symbol; comptime { if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) { // Functions specific to musl and wasi-libc. - @export(&isalnum, .{ .name = "isalnum", .linkage = common.linkage, .visibility = common.visibility }); - @export(&isalpha, .{ .name = "isalpha", .linkage = common.linkage, .visibility = common.visibility }); - @export(&isblank, .{ .name = "isblank", .linkage = common.linkage, .visibility = common.visibility }); - @export(&iscntrl, .{ .name = "iscntrl", .linkage = common.linkage, .visibility = common.visibility }); - @export(&isdigit, .{ .name = "isdigit", .linkage = common.linkage, .visibility = common.visibility }); - @export(&isgraph, .{ .name = "isgraph", .linkage = common.linkage, .visibility = common.visibility }); - @export(&islower, .{ .name = "islower", .linkage = common.linkage, .visibility = common.visibility }); - @export(&isprint, .{ .name = "isprint", .linkage = common.linkage, .visibility = common.visibility }); - @export(&ispunct, .{ .name = "ispunct", .linkage = common.linkage, .visibility = common.visibility }); - @export(&isspace, .{ .name = "isspace", .linkage = common.linkage, .visibility = common.visibility }); - @export(&isupper, .{ .name = "isupper", .linkage = common.linkage, .visibility = common.visibility }); - @export(&isxdigit, .{ .name = "isxdigit", .linkage = common.linkage, .visibility = common.visibility }); - @export(&tolower, .{ .name = "tolower", .linkage = common.linkage, .visibility = common.visibility }); - @export(&toupper, .{ .name = "toupper", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&isalnum, "isalnum"); + symbol(&isalpha, "isalpha"); + symbol(&isblank, "isblank"); + symbol(&iscntrl, "iscntrl"); + symbol(&isdigit, "isdigit"); + symbol(&isgraph, "isgraph"); + symbol(&islower, "islower"); + symbol(&isprint, "isprint"); + symbol(&ispunct, "ispunct"); + symbol(&isspace, "isspace"); + symbol(&isupper, "isupper"); + symbol(&isxdigit, "isxdigit"); + symbol(&tolower, "tolower"); + symbol(&toupper, "toupper"); - @export(&__isalnum_l, .{ .name = "__isalnum_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isalpha_l, .{ .name = "__isalpha_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isblank_l, .{ .name = "__isblank_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__iscntrl_l, .{ .name = "__iscntrl_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isdigit_l, .{ .name = "__isdigit_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isgraph_l, .{ .name = "__isgraph_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__islower_l, .{ .name = "__islower_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isprint_l, .{ .name = "__isprint_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__ispunct_l, .{ .name = "__ispunct_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isspace_l, .{ .name = "__isspace_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isupper_l, .{ .name = "__isupper_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isxdigit_l, .{ .name = "__isxdigit_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__tolower_l, .{ .name = "__tolower_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__toupper_l, .{ .name = "__toupper_l", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__isalnum_l, "__isalnum_l"); + symbol(&__isalpha_l, "__isalpha_l"); + symbol(&__isblank_l, "__isblank_l"); + symbol(&__iscntrl_l, "__iscntrl_l"); + symbol(&__isdigit_l, "__isdigit_l"); + symbol(&__isgraph_l, "__isgraph_l"); + symbol(&__islower_l, "__islower_l"); + symbol(&__isprint_l, "__isprint_l"); + symbol(&__ispunct_l, "__ispunct_l"); + symbol(&__isspace_l, "__isspace_l"); + symbol(&__isupper_l, "__isupper_l"); + symbol(&__isxdigit_l, "__isxdigit_l"); + symbol(&__tolower_l, "__tolower_l"); + symbol(&__toupper_l, "__toupper_l"); - @export(&__isalnum_l, .{ .name = "isalnum_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isalpha_l, .{ .name = "isalpha_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isblank_l, .{ .name = "isblank_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__iscntrl_l, .{ .name = "iscntrl_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isdigit_l, .{ .name = "isdigit_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isgraph_l, .{ .name = "isgraph_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__islower_l, .{ .name = "islower_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isprint_l, .{ .name = "isprint_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__ispunct_l, .{ .name = "ispunct_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isspace_l, .{ .name = "isspace_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isupper_l, .{ .name = "isupper_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__isxdigit_l, .{ .name = "isxdigit_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__tolower_l, .{ .name = "tolower_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__toupper_l, .{ .name = "toupper_l", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__isalnum_l, "isalnum_l"); + symbol(&__isalpha_l, "isalpha_l"); + symbol(&__isblank_l, "isblank_l"); + symbol(&__iscntrl_l, "iscntrl_l"); + symbol(&__isdigit_l, "isdigit_l"); + symbol(&__isgraph_l, "isgraph_l"); + symbol(&__islower_l, "islower_l"); + symbol(&__isprint_l, "isprint_l"); + symbol(&__ispunct_l, "ispunct_l"); + symbol(&__isspace_l, "isspace_l"); + symbol(&__isupper_l, "isupper_l"); + symbol(&__isxdigit_l, "isxdigit_l"); + symbol(&__tolower_l, "tolower_l"); + symbol(&__toupper_l, "toupper_l"); - @export(&isascii, .{ .name = "isascii", .linkage = common.linkage, .visibility = common.visibility }); - @export(&toascii, .{ .name = "toascii", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&isascii, "isascii"); + symbol(&toascii, "toascii"); } } diff --git a/lib/c/inttypes.zig b/lib/c/inttypes.zig index 39b2c9ba88..7bdcae873e 100644 --- a/lib/c/inttypes.zig +++ b/lib/c/inttypes.zig @@ -1,14 +1,16 @@ -const std = @import("std"); -const common = @import("common.zig"); const builtin = @import("builtin"); + +const std = @import("std"); const intmax_t = std.c.intmax_t; const imaxdiv_t = std.c.imaxdiv_t; +const symbol = @import("../c.zig").symbol; + comptime { if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) { // Functions specific to musl and wasi-libc. - @export(&imaxabs, .{ .name = "imaxabs", .linkage = common.linkage, .visibility = common.visibility }); - @export(&imaxdiv, .{ .name = "imaxdiv", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&imaxabs, "imaxabs"); + symbol(&imaxdiv, "imaxdiv"); } } diff --git a/lib/c/math.zig b/lib/c/math.zig index e9d92002c4..27524e9860 100644 --- a/lib/c/math.zig +++ b/lib/c/math.zig @@ -1,57 +1,59 @@ +const builtin = @import("builtin"); + const std = @import("std"); const math = std.math; -const common = @import("common.zig"); -const builtin = @import("builtin"); + +const symbol = @import("../c.zig").symbol; comptime { if (builtin.target.isMinGW()) { - @export(&isnan, .{ .name = "isnan", .linkage = common.linkage, .visibility = common.visibility }); - @export(&isnan, .{ .name = "__isnan", .linkage = common.linkage, .visibility = common.visibility }); - @export(&isnanf, .{ .name = "isnanf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&isnanf, .{ .name = "__isnanf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&isnanl, .{ .name = "isnanl", .linkage = common.linkage, .visibility = common.visibility }); - @export(&isnanl, .{ .name = "__isnanl", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&isnan, "isnan"); + symbol(&isnan, "__isnan"); + symbol(&isnanf, "isnanf"); + symbol(&isnanf, "__isnanf"); + symbol(&isnanl, "isnanl"); + symbol(&isnanl, "__isnanl"); - @export(&math.nan(f64), .{ .name = "__QNAN", .linkage = common.linkage, .visibility = common.visibility }); - @export(&math.snan(f64), .{ .name = "__SNAN", .linkage = common.linkage, .visibility = common.visibility }); - @export(&math.inf(f64), .{ .name = "__INF", .linkage = common.linkage, .visibility = common.visibility }); - @export(&math.floatTrueMin(f64), .{ .name = "__DENORM", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&math.nan(f64), "__QNAN"); + symbol(&math.snan(f64), "__SNAN"); + symbol(&math.inf(f64), "__INF"); + symbol(&math.floatTrueMin(f64), "__DENORM"); - @export(&math.nan(f32), .{ .name = "__QNANF", .linkage = common.linkage, .visibility = common.visibility }); - @export(&math.snan(f32), .{ .name = "__SNANF", .linkage = common.linkage, .visibility = common.visibility }); - @export(&math.inf(f32), .{ .name = "__INFF", .linkage = common.linkage, .visibility = common.visibility }); - @export(&math.floatTrueMin(f32), .{ .name = "__DENORMF", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&math.nan(f32), "__QNANF"); + symbol(&math.snan(f32), "__SNANF"); + symbol(&math.inf(f32), "__INFF"); + symbol(&math.floatTrueMin(f32), "__DENORMF"); - @export(&math.nan(c_longdouble), .{ .name = "__QNANL", .linkage = common.linkage, .visibility = common.visibility }); - @export(&math.snan(c_longdouble), .{ .name = "__SNANL", .linkage = common.linkage, .visibility = common.visibility }); - @export(&math.inf(c_longdouble), .{ .name = "__INFL", .linkage = common.linkage, .visibility = common.visibility }); - @export(&math.floatTrueMin(c_longdouble), .{ .name = "__DENORML", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&math.nan(c_longdouble), "__QNANL"); + symbol(&math.snan(c_longdouble), "__SNANL"); + symbol(&math.inf(c_longdouble), "__INFL"); + symbol(&math.floatTrueMin(c_longdouble), "__DENORML"); } if (builtin.target.isMinGW() or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) { - @export(&hypotf, .{ .name = "hypotf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&hypotl, .{ .name = "hypotl", .linkage = common.linkage, .visibility = common.visibility }); - @export(&nan, .{ .name = "nan", .linkage = common.linkage, .visibility = common.visibility }); - @export(&nanf, .{ .name = "nanf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&nanl, .{ .name = "nanl", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&hypotf, "hypotf"); + symbol(&hypotl, "hypotl"); + symbol(&nan, "nan"); + symbol(&nanf, "nanf"); + symbol(&nanl, "nanl"); } if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) { - @export(&acos, .{ .name = "acos", .linkage = common.linkage, .visibility = common.visibility }); - @export(&atanf, .{ .name = "atanf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&atan, .{ .name = "atan", .linkage = common.linkage, .visibility = common.visibility }); - @export(&atanl, .{ .name = "atanl", .linkage = common.linkage, .visibility = common.visibility }); - @export(&cbrt, .{ .name = "cbrt", .linkage = common.linkage, .visibility = common.visibility }); - @export(&cbrtf, .{ .name = "cbrtf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&hypot, .{ .name = "hypot", .linkage = common.linkage, .visibility = common.visibility }); - @export(&pow, .{ .name = "pow", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&acos, "acos"); + symbol(&atanf, "atanf"); + symbol(&atan, "atan"); + symbol(&atanl, "atanl"); + symbol(&cbrt, "cbrt"); + symbol(&cbrtf, "cbrtf"); + symbol(&hypot, "hypot"); + symbol(&pow, "pow"); } if (builtin.target.isMuslLibC()) { - @export(©signf, .{ .name = "copysignf", .linkage = common.linkage, .visibility = common.visibility }); - @export(©sign, .{ .name = "copysign", .linkage = common.linkage, .visibility = common.visibility }); + symbol(©signf, "copysignf"); + symbol(©sign, "copysign"); } - @export(©signl, .{ .name = "copysignl", .linkage = common.linkage, .visibility = common.visibility }); + symbol(©signl, "copysignl"); } fn acos(x: f64) callconv(.c) f64 { diff --git a/lib/c/stdlib.zig b/lib/c/stdlib.zig index 51ead9bee7..ccc8c08a14 100644 --- a/lib/c/stdlib.zig +++ b/lib/c/stdlib.zig @@ -1,47 +1,49 @@ -const std = @import("std"); -const common = @import("common.zig"); const builtin = @import("builtin"); + +const std = @import("std"); const assert = std.debug.assert; const div_t = std.c.div_t; const ldiv_t = std.c.ldiv_t; const lldiv_t = std.c.lldiv_t; +const symbol = @import("../c.zig").symbol; + comptime { _ = @import("stdlib/rand.zig"); _ = @import("stdlib/drand48.zig"); if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) { // Functions specific to musl and wasi-libc. - @export(&abs, .{ .name = "abs", .linkage = common.linkage, .visibility = common.visibility }); - @export(&labs, .{ .name = "labs", .linkage = common.linkage, .visibility = common.visibility }); - @export(&llabs, .{ .name = "llabs", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&abs, "abs"); + symbol(&labs, "labs"); + symbol(&llabs, "llabs"); - @export(&div, .{ .name = "div", .linkage = common.linkage, .visibility = common.visibility }); - @export(&ldiv, .{ .name = "ldiv", .linkage = common.linkage, .visibility = common.visibility }); - @export(&lldiv, .{ .name = "lldiv", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&div, "div"); + symbol(&ldiv, "ldiv"); + symbol(&lldiv, "lldiv"); - @export(&atoi, .{ .name = "atoi", .linkage = common.linkage, .visibility = common.visibility }); - @export(&atol, .{ .name = "atol", .linkage = common.linkage, .visibility = common.visibility }); - @export(&atoll, .{ .name = "atoll", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&atoi, "atoi"); + symbol(&atol, "atol"); + symbol(&atoll, "atoll"); - @export(&strtol, .{ .name = "strtol", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strtoll, .{ .name = "strtoll", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strtoul, .{ .name = "strtoul", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strtoull, .{ .name = "strtoull", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strtoimax, .{ .name = "strtoimax", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strtoumax, .{ .name = "strtoumax", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&strtol, "strtol"); + symbol(&strtoll, "strtoll"); + symbol(&strtoul, "strtoul"); + symbol(&strtoull, "strtoull"); + symbol(&strtoimax, "strtoimax"); + symbol(&strtoumax, "strtoumax"); - @export(&strtol, .{ .name = "__strtol_internal", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strtoll, .{ .name = "__strtoll_internal", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strtoul, .{ .name = "__strtoul_internal", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strtoull, .{ .name = "__strtoull_internal", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strtoimax, .{ .name = "__strtoimax_internal", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strtoumax, .{ .name = "__strtoumax_internal", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&strtol, "__strtol_internal"); + symbol(&strtoll, "__strtoll_internal"); + symbol(&strtoul, "__strtoul_internal"); + symbol(&strtoull, "__strtoull_internal"); + symbol(&strtoimax, "__strtoimax_internal"); + symbol(&strtoumax, "__strtoumax_internal"); - @export(&qsort_r, .{ .name = "qsort_r", .linkage = common.linkage, .visibility = common.visibility }); - @export(&qsort, .{ .name = "qsort", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&qsort_r, "qsort_r"); + symbol(&qsort, "qsort"); - @export(&bsearch, .{ .name = "bsearch", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&bsearch, "bsearch"); } } diff --git a/lib/c/stdlib/drand48.zig b/lib/c/stdlib/drand48.zig index b3104c7df4..266cc7af4a 100644 --- a/lib/c/stdlib/drand48.zig +++ b/lib/c/stdlib/drand48.zig @@ -1,21 +1,23 @@ //! drand48 functions are based off a 48-bit lcg prng: https://pubs.opengroup.org/onlinepubs/9799919799/functions/drand48.html -const std = @import("std"); -const common = @import("../common.zig"); const builtin = @import("builtin"); + +const std = @import("std"); const Lcg = std.Random.lcg.Wrapping(u48); +const symbol = @import("../../c.zig").symbol; + comptime { if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) { - @export(&erand48, .{ .name = "erand48", .linkage = common.linkage, .visibility = common.visibility }); - @export(&jrand48, .{ .name = "jrand48", .linkage = common.linkage, .visibility = common.visibility }); - @export(&nrand48, .{ .name = "nrand48", .linkage = common.linkage, .visibility = common.visibility }); - @export(&drand48, .{ .name = "drand48", .linkage = common.linkage, .visibility = common.visibility }); - @export(&lrand48, .{ .name = "lrand48", .linkage = common.linkage, .visibility = common.visibility }); - @export(&mrand48, .{ .name = "mrand48", .linkage = common.linkage, .visibility = common.visibility }); - @export(&lcong48, .{ .name = "lcong48", .linkage = common.linkage, .visibility = common.visibility }); - @export(&seed48, .{ .name = "seed48", .linkage = common.linkage, .visibility = common.visibility }); - @export(&srand48, .{ .name = "srand48", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&erand48, "erand48"); + symbol(&jrand48, "jrand48"); + symbol(&nrand48, "nrand48"); + symbol(&drand48, "drand48"); + symbol(&lrand48, "lrand48"); + symbol(&mrand48, "mrand48"); + symbol(&lcong48, "lcong48"); + symbol(&seed48, "seed48"); + symbol(&srand48, "srand48"); } } diff --git a/lib/c/stdlib/rand.zig b/lib/c/stdlib/rand.zig index 9ca7a51967..a160a9d376 100644 --- a/lib/c/stdlib/rand.zig +++ b/lib/c/stdlib/rand.zig @@ -1,12 +1,12 @@ -const std = @import("std"); -const common = @import("../common.zig"); const builtin = @import("builtin"); +const std = @import("std"); +const symbol = @import("../../c.zig").symbol; comptime { if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) { - @export(&rand, .{ .name = "rand", .linkage = common.linkage, .visibility = common.visibility }); - @export(&srand, .{ .name = "srand", .linkage = common.linkage, .visibility = common.visibility }); - @export(&rand_r, .{ .name = "rand_r", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&rand, "rand"); + symbol(&srand, "srand"); + symbol(&rand_r, "rand_r"); } } diff --git a/lib/c/string.zig b/lib/c/string.zig index e016193471..722ef0ba77 100644 --- a/lib/c/string.zig +++ b/lib/c/string.zig @@ -1,6 +1,6 @@ const builtin = @import("builtin"); const std = @import("std"); -const common = @import("common.zig"); +const symbol = @import("../c.zig").symbol; comptime { if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) { @@ -8,58 +8,58 @@ comptime { // memmove implemented in compiler_rt // memset implemented in compiler_rt // memcmp implemented in compiler_rt - @export(&memchr, .{ .name = "memchr", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strcpy, .{ .name = "strcpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strncpy, .{ .name = "strncpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strcat, .{ .name = "strcat", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strncat, .{ .name = "strncat", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strcmp, .{ .name = "strcmp", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strncmp, .{ .name = "strncmp", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strcoll, .{ .name = "strcoll", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strxfrm, .{ .name = "strxfrm", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strchr, .{ .name = "strchr", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strrchr, .{ .name = "strrchr", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strcspn, .{ .name = "strcspn", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strspn, .{ .name = "strspn", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strpbrk, .{ .name = "strpbrk", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strstr, .{ .name = "strstr", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strtok, .{ .name = "strtok", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&memchr, "memchr"); + symbol(&strcpy, "strcpy"); + symbol(&strncpy, "strncpy"); + symbol(&strcat, "strcat"); + symbol(&strncat, "strncat"); + symbol(&strcmp, "strcmp"); + symbol(&strncmp, "strncmp"); + symbol(&strcoll, "strcoll"); + symbol(&strxfrm, "strxfrm"); + symbol(&strchr, "strchr"); + symbol(&strrchr, "strrchr"); + symbol(&strcspn, "strcspn"); + symbol(&strspn, "strspn"); + symbol(&strpbrk, "strpbrk"); + symbol(&strstr, "strstr"); + symbol(&strtok, "strtok"); // strlen is in compiler_rt - @export(&strtok_r, .{ .name = "strtok_r", .linkage = common.linkage, .visibility = common.visibility }); - @export(&stpcpy, .{ .name = "stpcpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&stpncpy, .{ .name = "stpncpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strnlen, .{ .name = "strnlen", .linkage = common.linkage, .visibility = common.visibility }); - @export(&memmem, .{ .name = "memmem", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&strtok_r, "strtok_r"); + symbol(&stpcpy, "stpcpy"); + symbol(&stpncpy, "stpncpy"); + symbol(&strnlen, "strnlen"); + symbol(&memmem, "memmem"); - @export(&memccpy, .{ .name = "memccpy", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&memccpy, "memccpy"); - @export(&strsep, .{ .name = "strsep", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strlcat, .{ .name = "strlcat", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strlcpy, .{ .name = "strlcpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&explicit_bzero, .{ .name = "explicit_bzero", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&strsep, "strsep"); + symbol(&strlcat, "strlcat"); + symbol(&strlcpy, "strlcpy"); + symbol(&explicit_bzero, "explicit_bzero"); - @export(&strchrnul, .{ .name = "strchrnul", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strcasestr, .{ .name = "strcasestr", .linkage = common.linkage, .visibility = common.visibility }); - @export(&memrchr, .{ .name = "memrchr", .linkage = common.linkage, .visibility = common.visibility }); - @export(&mempcpy, .{ .name = "mempcpy", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&strchrnul, "strchrnul"); + symbol(&strcasestr, "strcasestr"); + symbol(&memrchr, "memrchr"); + symbol(&mempcpy, "mempcpy"); - @export(&__strcoll_l, .{ .name = "__strcoll_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__strxfrm_l, .{ .name = "__strxfrm_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__strcoll_l, .{ .name = "strcoll_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__strxfrm_l, .{ .name = "strxfrm_l", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__strcoll_l, "__strcoll_l"); + symbol(&__strxfrm_l, "__strxfrm_l"); + symbol(&__strcoll_l, "strcoll_l"); + symbol(&__strxfrm_l, "strxfrm_l"); // These symbols are not in the public ABI of musl/wasi. However they depend on these exports internally. - @export(&stpcpy, .{ .name = "__stpcpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&stpncpy, .{ .name = "__stpncpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strchrnul, .{ .name = "__strchrnul", .linkage = common.linkage, .visibility = common.visibility }); - @export(&memrchr, .{ .name = "__memrchr", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&stpcpy, "__stpcpy"); + symbol(&stpncpy, "__stpncpy"); + symbol(&strchrnul, "__strchrnul"); + symbol(&memrchr, "__memrchr"); } if (builtin.target.isMinGW()) { - @export(&strnlen, .{ .name = "strnlen", .linkage = common.linkage, .visibility = common.visibility }); - @export(&mempcpy, .{ .name = "mempcpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strtok_r, .{ .name = "strtok_r", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&strnlen, "strnlen"); + symbol(&mempcpy, "mempcpy"); + symbol(&strtok_r, "strtok_r"); } } diff --git a/lib/c/strings.zig b/lib/c/strings.zig index 9bebe1566f..8a052795ae 100644 --- a/lib/c/strings.zig +++ b/lib/c/strings.zig @@ -1,27 +1,27 @@ -const std = @import("std"); -const common = @import("common.zig"); const builtin = @import("builtin"); +const std = @import("std"); +const symbol = @import("../c.zig").symbol; comptime { if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) { // bcmp is implemented in compiler_rt - @export(&bcopy, .{ .name = "bcopy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&bzero, .{ .name = "bzero", .linkage = common.linkage, .visibility = common.visibility }); - @export(&index, .{ .name = "index", .linkage = common.linkage, .visibility = common.visibility }); - @export(&rindex, .{ .name = "rindex", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&bcopy, "bcopy"); + symbol(&bzero, "bzero"); + symbol(&index, "index"); + symbol(&rindex, "rindex"); - @export(&ffs, .{ .name = "ffs", .linkage = common.linkage, .visibility = common.visibility }); - @export(&ffsl, .{ .name = "ffsl", .linkage = common.linkage, .visibility = common.visibility }); - @export(&ffsll, .{ .name = "ffsll", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&ffs, "ffs"); + symbol(&ffsl, "ffsl"); + symbol(&ffsll, "ffsll"); - @export(&strcasecmp, .{ .name = "strcasecmp", .linkage = common.linkage, .visibility = common.visibility }); - @export(&strncasecmp, .{ .name = "strncasecmp", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&strcasecmp, "strcasecmp"); + symbol(&strncasecmp, "strncasecmp"); - @export(&__strcasecmp_l, .{ .name = "__strcasecmp_l", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__strncasecmp_l, .{ .name = "__strncasecmp_l", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__strcasecmp_l, "__strcasecmp_l"); + symbol(&__strncasecmp_l, "__strncasecmp_l"); - @export(&__strcasecmp_l, .{ .name = "strcasecmp_l", .linkage = .weak, .visibility = common.visibility }); - @export(&__strncasecmp_l, .{ .name = "strncasecmp_l", .linkage = .weak, .visibility = common.visibility }); + symbol(&__strcasecmp_l, "strcasecmp_l"); + symbol(&__strncasecmp_l, "strncasecmp_l"); } } diff --git a/lib/c/sys.zig b/lib/c/sys.zig deleted file mode 100644 index 71e068616b..0000000000 --- a/lib/c/sys.zig +++ /dev/null @@ -1,7 +0,0 @@ -comptime { - _ = @import("sys/mman.zig"); - _ = @import("sys/file.zig"); - _ = @import("sys/reboot.zig"); - _ = @import("sys/capability.zig"); - _ = @import("sys/utsname.zig"); -} diff --git a/lib/c/sys/capability.zig b/lib/c/sys/capability.zig index 19718a45e3..dd8faad75d 100644 --- a/lib/c/sys/capability.zig +++ b/lib/c/sys/capability.zig @@ -1,18 +1,21 @@ -const std = @import("std"); -const common = @import("../common.zig"); const builtin = @import("builtin"); +const std = @import("std"); + +const symbol = @import("../../c.zig").symbol; +const errno = @import("../../c.zig").errno; + comptime { if (builtin.target.isMuslLibC()) { - @export(&capsetLinux, .{ .name = "capset", .linkage = common.linkage, .visibility = common.visibility }); - @export(&capgetLinux, .{ .name = "capget", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&capsetLinux, "capset"); + symbol(&capgetLinux, "capget"); } } fn capsetLinux(hdrp: *anyopaque, datap: *anyopaque) callconv(.c) c_int { - return common.errno(std.os.linux.capset(@ptrCast(@alignCast(hdrp)), @ptrCast(@alignCast(datap)))); + return errno(std.os.linux.capset(@ptrCast(@alignCast(hdrp)), @ptrCast(@alignCast(datap)))); } fn capgetLinux(hdrp: *anyopaque, datap: *anyopaque) callconv(.c) c_int { - return common.errno(std.os.linux.capget(@ptrCast(@alignCast(hdrp)), @ptrCast(@alignCast(datap)))); + return errno(std.os.linux.capget(@ptrCast(@alignCast(hdrp)), @ptrCast(@alignCast(datap)))); } diff --git a/lib/c/sys/file.zig b/lib/c/sys/file.zig index 643d3fcd03..fcc7711425 100644 --- a/lib/c/sys/file.zig +++ b/lib/c/sys/file.zig @@ -1,13 +1,16 @@ -const std = @import("std"); -const common = @import("../common.zig"); const builtin = @import("builtin"); +const std = @import("std"); + +const symbol = @import("../../c.zig").symbol; +const errno = @import("../../c.zig").errno; + comptime { if (builtin.target.isMuslLibC()) { - @export(&flockLinux, .{ .name = "flock", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&flockLinux, "flock"); } } fn flockLinux(fd: c_int, operation: c_int) callconv(.c) c_int { - return common.errno(std.os.linux.flock(fd, operation)); + return errno(std.os.linux.flock(fd, operation)); } diff --git a/lib/c/sys/mman.zig b/lib/c/sys/mman.zig index 92de9ad076..3783cc4197 100644 --- a/lib/c/sys/mman.zig +++ b/lib/c/sys/mman.zig @@ -1,56 +1,59 @@ -const std = @import("std"); -const common = @import("../common.zig"); const builtin = @import("builtin"); +const std = @import("std"); + +const symbol = @import("../../c.zig").symbol; +const errno = @import("../../c.zig").errno; + comptime { if (builtin.target.isMuslLibC()) { - @export(&madviseLinux, .{ .name = "madvise", .linkage = common.linkage, .visibility = common.visibility }); - @export(&madviseLinux, .{ .name = "__madvise", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&madviseLinux, "madvise"); + symbol(&madviseLinux, "__madvise"); - @export(&mincoreLinux, .{ .name = "mincore", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&mincoreLinux, "mincore"); - @export(&mlockLinux, .{ .name = "mlock", .linkage = common.linkage, .visibility = common.visibility }); - @export(&mlockallLinux, .{ .name = "mlockall", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&mlockLinux, "mlock"); + symbol(&mlockallLinux, "mlockall"); - @export(&mprotectLinux, .{ .name = "mprotect", .linkage = common.linkage, .visibility = common.visibility }); - @export(&mprotectLinux, .{ .name = "__mprotect", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&mprotectLinux, "mprotect"); + symbol(&mprotectLinux, "__mprotect"); - @export(&munlockLinux, .{ .name = "munlock", .linkage = common.linkage, .visibility = common.visibility }); - @export(&munlockallLinux, .{ .name = "munlockall", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&munlockLinux, "munlock"); + symbol(&munlockallLinux, "munlockall"); - @export(&posix_madviseLinux, .{ .name = "posix_madvise", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&posix_madviseLinux, "posix_madvise"); } } fn madviseLinux(addr: *anyopaque, len: usize, advice: c_int) callconv(.c) c_int { - return common.errno(std.os.linux.madvise(@ptrCast(addr), len, @bitCast(advice))); + return errno(std.os.linux.madvise(@ptrCast(addr), len, @bitCast(advice))); } fn mincoreLinux(addr: *anyopaque, len: usize, vec: [*]u8) callconv(.c) c_int { - return common.errno(std.os.linux.mincore(@ptrCast(addr), len, vec)); + return errno(std.os.linux.mincore(@ptrCast(addr), len, vec)); } fn mlockLinux(addr: *const anyopaque, len: usize) callconv(.c) c_int { - return common.errno(std.os.linux.mlock(@ptrCast(addr), len)); + return errno(std.os.linux.mlock(@ptrCast(addr), len)); } fn mlockallLinux(flags: c_int) callconv(.c) c_int { - return common.errno(std.os.linux.mlockall(@bitCast(flags))); + return errno(std.os.linux.mlockall(@bitCast(flags))); } fn mprotectLinux(addr: *anyopaque, len: usize, prot: c_int) callconv(.c) c_int { const page_size = std.heap.pageSize(); const start = std.mem.alignBackward(usize, @intFromPtr(addr), page_size); const aligned_len = std.mem.alignForward(usize, len, page_size); - return common.errno(std.os.linux.mprotect(@ptrFromInt(start), aligned_len, @bitCast(prot))); + return errno(std.os.linux.mprotect(@ptrFromInt(start), aligned_len, @bitCast(prot))); } fn munlockLinux(addr: *const anyopaque, len: usize) callconv(.c) c_int { - return common.errno(std.os.linux.munlock(@ptrCast(addr), len)); + return errno(std.os.linux.munlock(@ptrCast(addr), len)); } fn munlockallLinux() callconv(.c) c_int { - return common.errno(std.os.linux.munlockall()); + return errno(std.os.linux.munlockall()); } fn posix_madviseLinux(addr: *anyopaque, len: usize, advice: c_int) callconv(.c) c_int { diff --git a/lib/c/sys/reboot.zig b/lib/c/sys/reboot.zig index 8b7b0503bd..8ec4210477 100644 --- a/lib/c/sys/reboot.zig +++ b/lib/c/sys/reboot.zig @@ -1,13 +1,16 @@ -const std = @import("std"); -const common = @import("../common.zig"); const builtin = @import("builtin"); +const std = @import("std"); + +const symbol = @import("../../c.zig").symbol; +const errno = @import("../../c.zig").errno; + comptime { if (builtin.target.isMuslLibC()) { - @export(&rebootLinux, .{ .name = "reboot", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&rebootLinux, "reboot"); } } fn rebootLinux(cmd: c_int) callconv(.c) c_int { - return common.errno(std.os.linux.reboot(.MAGIC1, .MAGIC2, @enumFromInt(cmd), null)); + return errno(std.os.linux.reboot(.MAGIC1, .MAGIC2, @enumFromInt(cmd), null)); } diff --git a/lib/c/sys/utsname.zig b/lib/c/sys/utsname.zig index 6082c1b6ce..5ae02adbc4 100644 --- a/lib/c/sys/utsname.zig +++ b/lib/c/sys/utsname.zig @@ -1,19 +1,22 @@ -const std = @import("std"); -const common = @import("../common.zig"); const builtin = @import("builtin"); +const std = @import("std"); + +const symbol = @import("../../c.zig").symbol; +const errno = @import("../../c.zig").errno; + comptime { if (builtin.target.isMuslLibC()) { - @export(&unameLinux, .{ .name = "uname", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&unameLinux, "uname"); } if (builtin.target.isWasiLibC()) { - @export(&unameWasi, .{ .name = "uname", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&unameWasi, "uname"); } } fn unameLinux(uts: *std.os.linux.utsname) callconv(.c) c_int { - return common.errno(std.os.linux.uname(uts)); + return errno(std.os.linux.uname(uts)); } fn unameWasi(uts: *std.c.utsname) callconv(.c) c_int { diff --git a/lib/c/unistd.zig b/lib/c/unistd.zig index 98290f0e04..ef0f8895c7 100644 --- a/lib/c/unistd.zig +++ b/lib/c/unistd.zig @@ -1,50 +1,53 @@ -const std = @import("std"); -const common = @import("common.zig"); const builtin = @import("builtin"); + +const std = @import("std"); const linux = std.os.linux; +const symbol = @import("../c.zig").symbol; +const errno = @import("../c.zig").errno; + comptime { if (builtin.target.isMuslLibC()) { - @export(&_exit, .{ .name = "_exit", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&_exit, "_exit"); - @export(&accessLinux, .{ .name = "access", .linkage = common.linkage, .visibility = common.visibility }); - @export(&acctLinux, .{ .name = "acct", .linkage = common.linkage, .visibility = common.visibility }); - @export(&chdirLinux, .{ .name = "chdir", .linkage = common.linkage, .visibility = common.visibility }); - @export(&chownLinux, .{ .name = "chown", .linkage = common.linkage, .visibility = common.visibility }); - @export(&fchownatLinux, .{ .name = "fchownat", .linkage = common.linkage, .visibility = common.visibility }); - @export(&lchownLinux, .{ .name = "lchown", .linkage = common.linkage, .visibility = common.visibility }); - @export(&chrootLinux, .{ .name = "chroot", .linkage = common.linkage, .visibility = common.visibility }); - @export(&ctermidLinux, .{ .name = "ctermid", .linkage = common.linkage, .visibility = common.visibility }); - @export(&dupLinux, .{ .name = "dup", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&accessLinux, "access"); + symbol(&acctLinux, "acct"); + symbol(&chdirLinux, "chdir"); + symbol(&chownLinux, "chown"); + symbol(&fchownatLinux, "fchownat"); + symbol(&lchownLinux, "lchown"); + symbol(&chrootLinux, "chroot"); + symbol(&ctermidLinux, "ctermid"); + symbol(&dupLinux, "dup"); - @export(&getegidLinux, .{ .name = "getegid", .linkage = common.linkage, .visibility = common.visibility }); - @export(&geteuidLinux, .{ .name = "geteuid", .linkage = common.linkage, .visibility = common.visibility }); - @export(&getgidLinux, .{ .name = "getgid", .linkage = common.linkage, .visibility = common.visibility }); - @export(&getgroupsLinux, .{ .name = "getgroups", .linkage = common.linkage, .visibility = common.visibility }); - @export(&getpgidLinux, .{ .name = "getpgid", .linkage = common.linkage, .visibility = common.visibility }); - @export(&getpgrpLinux, .{ .name = "getpgrp", .linkage = common.linkage, .visibility = common.visibility }); - @export(&setpgidLinux, .{ .name = "setpgid", .linkage = common.linkage, .visibility = common.visibility }); - @export(&setpgrpLinux, .{ .name = "setpgrp", .linkage = common.linkage, .visibility = common.visibility }); - @export(&getsidLinux, .{ .name = "getsid", .linkage = common.linkage, .visibility = common.visibility }); - @export(&getpidLinux, .{ .name = "getpid", .linkage = common.linkage, .visibility = common.visibility }); - @export(&getppidLinux, .{ .name = "getppid", .linkage = common.linkage, .visibility = common.visibility }); - @export(&getuidLinux, .{ .name = "getuid", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&getegidLinux, "getegid"); + symbol(&geteuidLinux, "geteuid"); + symbol(&getgidLinux, "getgid"); + symbol(&getgroupsLinux, "getgroups"); + symbol(&getpgidLinux, "getpgid"); + symbol(&getpgrpLinux, "getpgrp"); + symbol(&setpgidLinux, "setpgid"); + symbol(&setpgrpLinux, "setpgrp"); + symbol(&getsidLinux, "getsid"); + symbol(&getpidLinux, "getpid"); + symbol(&getppidLinux, "getppid"); + symbol(&getuidLinux, "getuid"); - @export(&rmdirLinux, .{ .name = "rmdir", .linkage = common.linkage, .visibility = common.visibility }); - @export(&linkLinux, .{ .name = "link", .linkage = common.linkage, .visibility = common.visibility }); - @export(&linkatLinux, .{ .name = "linkat", .linkage = common.linkage, .visibility = common.visibility }); - @export(&pipeLinux, .{ .name = "pipe", .linkage = common.linkage, .visibility = common.visibility }); - @export(&renameatLinux, .{ .name = "renameat", .linkage = common.linkage, .visibility = common.visibility }); - @export(&symlinkLinux, .{ .name = "symlink", .linkage = common.linkage, .visibility = common.visibility }); - @export(&symlinkatLinux, .{ .name = "symlinkat", .linkage = common.linkage, .visibility = common.visibility }); - @export(&syncLinux, .{ .name = "sync", .linkage = common.linkage, .visibility = common.visibility }); - @export(&unlinkLinux, .{ .name = "unlink", .linkage = common.linkage, .visibility = common.visibility }); - @export(&unlinkatLinux, .{ .name = "unlinkat", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&rmdirLinux, "rmdir"); + symbol(&linkLinux, "link"); + symbol(&linkatLinux, "linkat"); + symbol(&pipeLinux, "pipe"); + symbol(&renameatLinux, "renameat"); + symbol(&symlinkLinux, "symlink"); + symbol(&symlinkatLinux, "symlinkat"); + symbol(&syncLinux, "sync"); + symbol(&unlinkLinux, "unlink"); + symbol(&unlinkatLinux, "unlinkat"); - @export(&execveLinux, .{ .name = "execve", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&execveLinux, "execve"); } if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) { - @export(&swab, .{ .name = "swab", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&swab, "swab"); } } @@ -53,31 +56,31 @@ fn _exit(exit_code: c_int) callconv(.c) noreturn { } fn accessLinux(path: [*:0]const c_char, amode: c_int) callconv(.c) c_int { - return common.errno(linux.access(@ptrCast(path), @bitCast(amode))); + return errno(linux.access(@ptrCast(path), @bitCast(amode))); } fn acctLinux(path: [*:0]const c_char) callconv(.c) c_int { - return common.errno(linux.acct(@ptrCast(path))); + return errno(linux.acct(@ptrCast(path))); } fn chdirLinux(path: [*:0]const c_char) callconv(.c) c_int { - return common.errno(linux.chdir(@ptrCast(path))); + return errno(linux.chdir(@ptrCast(path))); } fn chownLinux(path: [*:0]const c_char, uid: linux.uid_t, gid: linux.gid_t) callconv(.c) c_int { - return common.errno(linux.chown(@ptrCast(path), uid, gid)); + return errno(linux.chown(@ptrCast(path), uid, gid)); } fn fchownatLinux(fd: c_int, path: [*:0]const c_char, uid: linux.uid_t, gid: linux.gid_t, flags: c_int) callconv(.c) c_int { - return common.errno(linux.fchownat(fd, @ptrCast(path), uid, gid, @bitCast(flags))); + return errno(linux.fchownat(fd, @ptrCast(path), uid, gid, @bitCast(flags))); } fn lchownLinux(path: [*:0]const c_char, uid: linux.uid_t, gid: linux.gid_t) callconv(.c) c_int { - return common.errno(linux.lchown(@ptrCast(path), uid, gid)); + return errno(linux.lchown(@ptrCast(path), uid, gid)); } fn chrootLinux(path: [*:0]const c_char) callconv(.c) c_int { - return common.errno(linux.chroot(@ptrCast(path))); + return errno(linux.chroot(@ptrCast(path))); } fn ctermidLinux(maybe_path: ?[*]c_char) callconv(.c) [*:0]c_char { @@ -90,7 +93,7 @@ fn ctermidLinux(maybe_path: ?[*]c_char) callconv(.c) [*:0]c_char { } fn dupLinux(fd: c_int) callconv(.c) c_int { - return common.errno(linux.dup(fd)); + return errno(linux.dup(fd)); } fn getegidLinux() callconv(.c) linux.gid_t { @@ -106,11 +109,11 @@ fn getgidLinux() callconv(.c) linux.gid_t { } fn getgroupsLinux(size: c_int, list: ?[*]linux.gid_t) callconv(.c) c_int { - return common.errno(linux.getgroups(@intCast(size), list)); + return errno(linux.getgroups(@intCast(size), list)); } fn getpgidLinux(pid: linux.pid_t) callconv(.c) linux.pid_t { - return common.errno(linux.getpgid(pid)); + return errno(linux.getpgid(pid)); } fn getpgrpLinux() callconv(.c) linux.pid_t { @@ -118,7 +121,7 @@ fn getpgrpLinux() callconv(.c) linux.pid_t { } fn setpgidLinux(pid: linux.pid_t, pgid: linux.pid_t) callconv(.c) c_int { - return common.errno(linux.setpgid(pid, pgid)); + return errno(linux.setpgid(pid, pgid)); } fn setpgrpLinux() callconv(.c) linux.pid_t { @@ -134,7 +137,7 @@ fn getppidLinux() callconv(.c) linux.pid_t { } fn getsidLinux(pid: linux.pid_t) callconv(.c) linux.pid_t { - return common.errno(linux.getsid(pid)); + return errno(linux.getsid(pid)); } fn getuidLinux() callconv(.c) linux.uid_t { @@ -142,31 +145,31 @@ fn getuidLinux() callconv(.c) linux.uid_t { } fn linkLinux(old: [*:0]const c_char, new: [*:0]const c_char) callconv(.c) c_int { - return common.errno(linux.link(@ptrCast(old), @ptrCast(new))); + return errno(linux.link(@ptrCast(old), @ptrCast(new))); } fn linkatLinux(old_fd: c_int, old: [*:0]const c_char, new_fd: c_int, new: [*:0]const c_char, flags: c_int) callconv(.c) c_int { - return common.errno(linux.linkat(old_fd, @ptrCast(old), new_fd, @ptrCast(new), @bitCast(flags))); + return errno(linux.linkat(old_fd, @ptrCast(old), new_fd, @ptrCast(new), @bitCast(flags))); } fn pipeLinux(fd: *[2]c_int) callconv(.c) c_int { - return common.errno(linux.pipe(@ptrCast(fd))); + return errno(linux.pipe(@ptrCast(fd))); } fn renameatLinux(old_fd: c_int, old: [*:0]const c_char, new_fd: c_int, new: [*:0]const c_char) callconv(.c) c_int { - return common.errno(linux.renameat(old_fd, @ptrCast(old), new_fd, @ptrCast(new))); + return errno(linux.renameat(old_fd, @ptrCast(old), new_fd, @ptrCast(new))); } fn rmdirLinux(path: [*:0]const c_char) callconv(.c) c_int { - return common.errno(linux.rmdir(@ptrCast(path))); + return errno(linux.rmdir(@ptrCast(path))); } fn symlinkLinux(existing: [*:0]const c_char, new: [*:0]const c_char) callconv(.c) c_int { - return common.errno(linux.symlink(@ptrCast(existing), @ptrCast(new))); + return errno(linux.symlink(@ptrCast(existing), @ptrCast(new))); } fn symlinkatLinux(existing: [*:0]const c_char, fd: c_int, new: [*:0]const c_char) callconv(.c) c_int { - return common.errno(linux.symlinkat(@ptrCast(existing), fd, @ptrCast(new))); + return errno(linux.symlinkat(@ptrCast(existing), fd, @ptrCast(new))); } fn syncLinux() callconv(.c) void { @@ -174,15 +177,15 @@ fn syncLinux() callconv(.c) void { } fn unlinkLinux(path: [*:0]const c_char) callconv(.c) c_int { - return common.errno(linux.unlink(@ptrCast(path))); + return errno(linux.unlink(@ptrCast(path))); } fn unlinkatLinux(fd: c_int, path: [*:0]const c_char, flags: c_int) callconv(.c) c_int { - return common.errno(linux.unlinkat(fd, @ptrCast(path), @bitCast(flags))); + return errno(linux.unlinkat(fd, @ptrCast(path), @bitCast(flags))); } fn execveLinux(path: [*:0]const c_char, argv: [*:null]const ?[*:0]c_char, envp: [*:null]const ?[*:0]c_char) callconv(.c) c_int { - return common.errno(linux.execve(@ptrCast(path), @ptrCast(argv), @ptrCast(envp))); + return errno(linux.execve(@ptrCast(path), @ptrCast(argv), @ptrCast(envp))); } fn swab(noalias src_ptr: *const anyopaque, noalias dest_ptr: *anyopaque, n: isize) callconv(.c) void { diff --git a/lib/c/wchar.zig b/lib/c/wchar.zig index b31c450cfc..b85687e8a7 100644 --- a/lib/c/wchar.zig +++ b/lib/c/wchar.zig @@ -1,44 +1,46 @@ -const std = @import("std"); -const common = @import("common.zig"); const builtin = @import("builtin"); + +const std = @import("std"); const wint_t = std.c.wint_t; const wchar_t = std.c.wchar_t; +const symbol = @import("../c.zig").symbol; + comptime { if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) { - @export(&wmemchr, .{ .name = "wmemchr", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wmemcmp, .{ .name = "wmemcmp", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wmemcpy, .{ .name = "wmemcpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wmemmove, .{ .name = "wmemmove", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wmemset, .{ .name = "wmemset", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcslen, .{ .name = "wcslen", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcsnlen, .{ .name = "wcsnlen", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcscmp, .{ .name = "wcscmp", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcsncmp, .{ .name = "wcsncmp", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcpcpy, .{ .name = "wcpcpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcpncpy, .{ .name = "wcpncpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcscpy, .{ .name = "wcscpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcsncpy, .{ .name = "wcsncpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcscat, .{ .name = "wcscat", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcsncat, .{ .name = "wcsncat", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcschr, .{ .name = "wcschr", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcsrchr, .{ .name = "wcsrchr", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcsspn, .{ .name = "wcsspn", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcscspn, .{ .name = "wcscspn", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcspbrk, .{ .name = "wcspbrk", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcstok, .{ .name = "wcstok", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcsstr, .{ .name = "wcsstr", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcswcs, .{ .name = "wcswcs", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&wmemchr, "wmemchr"); + symbol(&wmemcmp, "wmemcmp"); + symbol(&wmemcpy, "wmemcpy"); + symbol(&wmemmove, "wmemmove"); + symbol(&wmemset, "wmemset"); + symbol(&wcslen, "wcslen"); + symbol(&wcsnlen, "wcsnlen"); + symbol(&wcscmp, "wcscmp"); + symbol(&wcsncmp, "wcsncmp"); + symbol(&wcpcpy, "wcpcpy"); + symbol(&wcpncpy, "wcpncpy"); + symbol(&wcscpy, "wcscpy"); + symbol(&wcsncpy, "wcsncpy"); + symbol(&wcscat, "wcscat"); + symbol(&wcsncat, "wcsncat"); + symbol(&wcschr, "wcschr"); + symbol(&wcsrchr, "wcsrchr"); + symbol(&wcsspn, "wcsspn"); + symbol(&wcscspn, "wcscspn"); + symbol(&wcspbrk, "wcspbrk"); + symbol(&wcstok, "wcstok"); + symbol(&wcsstr, "wcsstr"); + symbol(&wcswcs, "wcswcs"); } if (builtin.target.isMinGW()) { - @export(&wmemchr, .{ .name = "wmemchr", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wmemcmp, .{ .name = "wmemcmp", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wmemcpy, .{ .name = "wmemcpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wmempcpy, .{ .name = "wmempcpy", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wmemmove, .{ .name = "wmemmove", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wmemset, .{ .name = "wmemset", .linkage = common.linkage, .visibility = common.visibility }); - @export(&wcsnlen, .{ .name = "wcsnlen", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&wmemchr, "wmemchr"); + symbol(&wmemcmp, "wmemcmp"); + symbol(&wmemcpy, "wmemcpy"); + symbol(&wmempcpy, "wmempcpy"); + symbol(&wmemmove, "wmemmove"); + symbol(&wmemset, "wmemset"); + symbol(&wcsnlen, "wcsnlen"); } }