From 04c180c8e57fecdf3478de966f32b8a1f65ad202 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sun, 8 Feb 2026 23:55:26 -0800 Subject: [PATCH] compiler_rt: partial cleanup introduce `symbol` helper function and partially migrate to using it --- lib/compiler_rt.zig | 69 ++++++++++++++-- lib/compiler_rt/absvdi2.zig | 4 +- lib/compiler_rt/absvti2.zig | 4 +- lib/compiler_rt/adddf3.zig | 5 +- lib/compiler_rt/addsf3.zig | 5 +- lib/compiler_rt/addvdi3.zig | 4 +- lib/compiler_rt/atomics.zig | 139 ++++++++++++++++---------------- lib/compiler_rt/aulldiv.zig | 10 +-- lib/compiler_rt/cmpdf2.zig | 17 ++-- lib/compiler_rt/cmptf2.zig | 33 ++++---- lib/compiler_rt/common.zig | 26 ++---- lib/compiler_rt/cos.zig | 17 ++-- lib/compiler_rt/count0bits.zig | 22 ++--- lib/compiler_rt/divdc3.zig | 4 +- lib/compiler_rt/divdf3.zig | 7 +- lib/compiler_rt/divhf3.zig | 4 +- lib/compiler_rt/divmodei4.zig | 12 +-- lib/compiler_rt/divsc3.zig | 4 +- lib/compiler_rt/divsf3.zig | 7 +- lib/compiler_rt/divtc3.zig | 5 +- lib/compiler_rt/divxc3.zig | 4 +- lib/compiler_rt/exp.zig | 19 +++-- lib/compiler_rt/extenddftf2.zig | 7 +- lib/compiler_rt/extendhfdf2.zig | 3 +- lib/compiler_rt/extendhfsf2.zig | 7 +- lib/compiler_rt/extendsfxf2.zig | 4 +- lib/compiler_rt/extendxftf2.zig | 5 +- lib/compiler_rt/fixdfsi.zig | 5 +- lib/compiler_rt/fixdfti.zig | 6 +- lib/compiler_rt/fixsfdi.zig | 7 +- lib/compiler_rt/fixtfdi.zig | 7 +- lib/compiler_rt/fixtfsi.zig | 7 +- lib/compiler_rt/fixtfti.zig | 8 +- lib/compiler_rt/fixunsdfei.zig | 8 +- lib/compiler_rt/fixunsdfti.zig | 6 +- lib/compiler_rt/fixunshfdi.zig | 4 +- lib/compiler_rt/fixunshfei.zig | 8 +- lib/compiler_rt/fixunshfti.zig | 6 +- lib/compiler_rt/fixunssfei.zig | 8 +- lib/compiler_rt/fixunssfti.zig | 5 +- lib/compiler_rt/fixunstfei.zig | 8 +- lib/compiler_rt/fixunsxfdi.zig | 4 +- lib/compiler_rt/fixunsxfei.zig | 4 +- lib/compiler_rt/fixxfdi.zig | 4 +- lib/compiler_rt/fixxfti.zig | 6 +- lib/compiler_rt/floatdihf.zig | 4 +- lib/compiler_rt/floatdisf.zig | 8 +- lib/compiler_rt/floatditf.zig | 7 +- lib/compiler_rt/floatdixf.zig | 4 +- lib/compiler_rt/floateidf.zig | 8 +- lib/compiler_rt/floateixf.zig | 8 +- lib/compiler_rt/floatsixf.zig | 3 +- lib/compiler_rt/floattidf.zig | 6 +- lib/compiler_rt/floattisf.zig | 6 +- lib/compiler_rt/floattitf.zig | 8 +- lib/compiler_rt/floatundidf.zig | 8 +- lib/compiler_rt/floatuneitf.zig | 8 +- lib/compiler_rt/floatunsihf.zig | 4 +- lib/compiler_rt/floatunsisf.zig | 5 +- lib/compiler_rt/floatunsitf.zig | 7 +- lib/compiler_rt/floatuntidf.zig | 6 +- lib/compiler_rt/floatuntihf.zig | 6 +- lib/compiler_rt/floatuntitf.zig | 8 +- lib/compiler_rt/floor_ceil.zig | 29 +++---- lib/compiler_rt/gedf2.zig | 9 ++- lib/compiler_rt/gehf2.zig | 6 +- lib/compiler_rt/gexf2.zig | 6 +- lib/compiler_rt/int.zig | 35 ++++---- lib/compiler_rt/log.zig | 18 ++--- lib/compiler_rt/log10.zig | 18 ++--- lib/compiler_rt/memcmp.zig | 30 ------- lib/compiler_rt/muldc3.zig | 4 +- lib/compiler_rt/muldf3.zig | 5 +- lib/compiler_rt/mulsc3.zig | 4 +- lib/compiler_rt/multc3.zig | 5 +- lib/compiler_rt/mulvsi3.zig | 7 +- lib/compiler_rt/negtf2.zig | 5 +- lib/compiler_rt/parity.zig | 13 ++- lib/compiler_rt/popcount.zig | 10 +-- lib/compiler_rt/powiXf2.zig | 15 ++-- lib/compiler_rt/sin.zig | 19 +++-- lib/compiler_rt/strlen.zig | 10 --- lib/compiler_rt/subdf3.zig | 5 +- lib/compiler_rt/subvdi3.zig | 4 +- lib/compiler_rt/subxf3.zig | 4 +- lib/compiler_rt/tan.zig | 15 ++-- lib/compiler_rt/trunc.zig | 19 +++-- lib/compiler_rt/truncdfhf2.zig | 5 +- lib/compiler_rt/trunctfhf2.zig | 3 +- lib/compiler_rt/trunctfsf2.zig | 7 +- lib/compiler_rt/truncxfdf2.zig | 4 +- lib/compiler_rt/truncxfhf2.zig | 3 +- lib/compiler_rt/truncxfsf2.zig | 4 +- lib/compiler_rt/udivmodei4.zig | 14 ++-- lib/compiler_rt/unorddf2.zig | 5 +- 95 files changed, 532 insertions(+), 480 deletions(-) delete mode 100644 lib/compiler_rt/memcmp.zig delete mode 100644 lib/compiler_rt/strlen.zig diff --git a/lib/compiler_rt.zig b/lib/compiler_rt.zig index 87ff89c2d9..343363188f 100644 --- a/lib/compiler_rt.zig +++ b/lib/compiler_rt.zig @@ -1,10 +1,11 @@ -const std = @import("std"); const builtin = @import("builtin"); -const common = @import("compiler_rt/common.zig"); +const ofmt_c = builtin.object_format == .c; + +const std = @import("std"); /// Avoid dragging in the runtime safety mechanisms into this .o file, unless /// we're trying to test compiler-rt. -pub const panic = if (common.test_safety) +pub const panic = if (test_safety) std.debug.FullPanic(std.debug.defaultPanic) else std.debug.no_panic; @@ -19,6 +20,33 @@ pub const std_options_debug_io: std.Io = if (builtin.is_test) else unreachable; +pub inline fn symbol(comptime func: *const anyopaque, comptime name: []const u8) void { + @export(func, .{ .name = name, .linkage = linkage, .visibility = visibility }); +} + +/// For now, we prefer weak linkage because some of the routines we implement here may also be +/// provided by system/dynamic libc. Eventually we should be more disciplined about this on a +/// per-symbol, per-target basis: https://github.com/ziglang/zig/issues/11883 +pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) + .internal +else if (ofmt_c) + .strong +else + .weak; + +/// 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 = if (linkage == .internal or builtin.link_mode == .dynamic) + .default +else + .hidden; + +pub const test_safety = switch (builtin.zig_backend) { + .stage2_aarch64 => false, + else => builtin.is_test, +}; + comptime { // Integer routines _ = @import("compiler_rt/count0bits.zig"); @@ -276,17 +304,44 @@ comptime { _ = @import("compiler_rt/memcpy.zig"); _ = @import("compiler_rt/memset.zig"); _ = @import("compiler_rt/memmove.zig"); - _ = @import("compiler_rt/memcmp.zig"); + symbol(&memcmp, "memcmp"); _ = @import("compiler_rt/bcmp.zig"); _ = @import("compiler_rt/ssp.zig"); - - _ = @import("compiler_rt/strlen.zig"); + symbol(&strlen, "strlen"); } // Temporarily used for uefi until https://github.com/ziglang/zig/issues/21630 is addressed. if (!builtin.link_libc and (builtin.os.tag == .windows or builtin.os.tag == .uefi) and (builtin.abi == .none or builtin.abi == .msvc)) { - @export(&_fltused, .{ .name = "_fltused", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&_fltused, "_fltused"); } } var _fltused: c_int = 1; + +fn strlen(s: [*:0]const c_char) callconv(.c) usize { + return std.mem.len(s); +} + +fn memcmp(vl: [*]const u8, vr: [*]const u8, n: usize) callconv(.c) c_int { + var i: usize = 0; + while (i < n) : (i += 1) { + const compared = @as(c_int, vl[i]) -% @as(c_int, vr[i]); + if (compared != 0) return compared; + } + return 0; +} + +test "memcmp" { + const arr0 = &[_]u8{ 1, 1, 1 }; + const arr1 = &[_]u8{ 1, 1, 1 }; + const arr2 = &[_]u8{ 1, 0, 1 }; + const arr3 = &[_]u8{ 1, 2, 1 }; + const arr4 = &[_]u8{ 1, 0xff, 1 }; + + try std.testing.expect(memcmp(arr0, arr1, 3) == 0); + try std.testing.expect(memcmp(arr0, arr2, 3) > 0); + try std.testing.expect(memcmp(arr0, arr3, 3) < 0); + + try std.testing.expect(memcmp(arr0, arr4, 3) < 0); + try std.testing.expect(memcmp(arr4, arr0, 3) > 0); +} diff --git a/lib/compiler_rt/absvdi2.zig b/lib/compiler_rt/absvdi2.zig index add32608e8..408d70ad16 100644 --- a/lib/compiler_rt/absvdi2.zig +++ b/lib/compiler_rt/absvdi2.zig @@ -1,8 +1,8 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const absv = @import("./absv.zig").absv; comptime { - @export(&__absvdi2, .{ .name = "__absvdi2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__absvdi2, "__absvdi2"); } pub fn __absvdi2(a: i64) callconv(.c) i64 { diff --git a/lib/compiler_rt/absvti2.zig b/lib/compiler_rt/absvti2.zig index 1b2ddaaefa..ab367d2b78 100644 --- a/lib/compiler_rt/absvti2.zig +++ b/lib/compiler_rt/absvti2.zig @@ -1,8 +1,8 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const absv = @import("./absv.zig").absv; comptime { - @export(&__absvti2, .{ .name = "__absvti2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__absvti2, "__absvti2"); } pub fn __absvti2(a: i128) callconv(.c) i128 { diff --git a/lib/compiler_rt/adddf3.zig b/lib/compiler_rt/adddf3.zig index 98fba79bbd..7a49b0d782 100644 --- a/lib/compiler_rt/adddf3.zig +++ b/lib/compiler_rt/adddf3.zig @@ -1,11 +1,12 @@ const common = @import("./common.zig"); const addf3 = @import("./addf3.zig").addf3; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_aeabi) { - @export(&__aeabi_dadd, .{ .name = "__aeabi_dadd", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_dadd, "__aeabi_dadd"); } else { - @export(&__adddf3, .{ .name = "__adddf3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__adddf3, "__adddf3"); } } diff --git a/lib/compiler_rt/addsf3.zig b/lib/compiler_rt/addsf3.zig index ef1627ae7a..fb65bec624 100644 --- a/lib/compiler_rt/addsf3.zig +++ b/lib/compiler_rt/addsf3.zig @@ -1,11 +1,12 @@ const common = @import("./common.zig"); const addf3 = @import("./addf3.zig").addf3; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_aeabi) { - @export(&__aeabi_fadd, .{ .name = "__aeabi_fadd", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_fadd, "__aeabi_fadd"); } else { - @export(&__addsf3, .{ .name = "__addsf3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__addsf3, "__addsf3"); } } diff --git a/lib/compiler_rt/addvdi3.zig b/lib/compiler_rt/addvdi3.zig index e7346b717f..a5cde2494a 100644 --- a/lib/compiler_rt/addvdi3.zig +++ b/lib/compiler_rt/addvdi3.zig @@ -1,8 +1,8 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const testing = @import("std").testing; comptime { - @export(&__addvdi3, .{ .name = "__addvdi3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__addvdi3, "__addvdi3"); } pub fn __addvdi3(a: i64, b: i64) callconv(.c) i64 { diff --git a/lib/compiler_rt/atomics.zig b/lib/compiler_rt/atomics.zig index b87b7a6315..31c87f4b1b 100644 --- a/lib/compiler_rt/atomics.zig +++ b/lib/compiler_rt/atomics.zig @@ -1,10 +1,11 @@ -const std = @import("std"); const builtin = @import("builtin"); -const common = @import("./common.zig"); const cpu = builtin.cpu; const arch = cpu.arch; -const linkage = common.linkage; -const visibility = common.visibility; + +const std = @import("std"); + +const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; // This parameter is true iff the target architecture supports the bare minimum // to implement the atomic load/store intrinsics. @@ -225,7 +226,7 @@ fn __atomic_store_16(dst: *u128, value: u128, model: i32) callconv(.c) void { } fn wideUpdate(comptime T: type, ptr: *T, val: T, update: anytype) T { - const WideAtomic = std.meta.Int(.unsigned, smallest_atomic_fetch_exch_size * 8); + const WideAtomic = @Int(.unsigned, smallest_atomic_fetch_exch_size * 8); const addr = @intFromPtr(ptr); const wide_addr = addr & ~(@as(T, smallest_atomic_fetch_exch_size) - 1); @@ -535,81 +536,81 @@ fn __atomic_fetch_umin_16(ptr: *u128, val: u128, model: i32) callconv(.c) u128 { comptime { if (supports_atomic_ops and builtin.object_format != .c) { - @export(&__atomic_load, .{ .name = "__atomic_load", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_store, .{ .name = "__atomic_store", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_exchange, .{ .name = "__atomic_exchange", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_compare_exchange, .{ .name = "__atomic_compare_exchange", .linkage = linkage, .visibility = visibility }); + symbol(&__atomic_load, "__atomic_load"); + symbol(&__atomic_store, "__atomic_store"); + symbol(&__atomic_exchange, "__atomic_exchange"); + symbol(&__atomic_compare_exchange, "__atomic_compare_exchange"); - @export(&__atomic_fetch_add_1, .{ .name = "__atomic_fetch_add_1", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_add_2, .{ .name = "__atomic_fetch_add_2", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_add_4, .{ .name = "__atomic_fetch_add_4", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_add_8, .{ .name = "__atomic_fetch_add_8", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_add_16, .{ .name = "__atomic_fetch_add_16", .linkage = linkage, .visibility = visibility }); + symbol(&__atomic_fetch_add_1, "__atomic_fetch_add_1"); + symbol(&__atomic_fetch_add_2, "__atomic_fetch_add_2"); + symbol(&__atomic_fetch_add_4, "__atomic_fetch_add_4"); + symbol(&__atomic_fetch_add_8, "__atomic_fetch_add_8"); + symbol(&__atomic_fetch_add_16, "__atomic_fetch_add_16"); - @export(&__atomic_fetch_sub_1, .{ .name = "__atomic_fetch_sub_1", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_sub_2, .{ .name = "__atomic_fetch_sub_2", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_sub_4, .{ .name = "__atomic_fetch_sub_4", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_sub_8, .{ .name = "__atomic_fetch_sub_8", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_sub_16, .{ .name = "__atomic_fetch_sub_16", .linkage = linkage, .visibility = visibility }); + symbol(&__atomic_fetch_sub_1, "__atomic_fetch_sub_1"); + symbol(&__atomic_fetch_sub_2, "__atomic_fetch_sub_2"); + symbol(&__atomic_fetch_sub_4, "__atomic_fetch_sub_4"); + symbol(&__atomic_fetch_sub_8, "__atomic_fetch_sub_8"); + symbol(&__atomic_fetch_sub_16, "__atomic_fetch_sub_16"); - @export(&__atomic_fetch_and_1, .{ .name = "__atomic_fetch_and_1", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_and_2, .{ .name = "__atomic_fetch_and_2", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_and_4, .{ .name = "__atomic_fetch_and_4", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_and_8, .{ .name = "__atomic_fetch_and_8", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_and_16, .{ .name = "__atomic_fetch_and_16", .linkage = linkage, .visibility = visibility }); + symbol(&__atomic_fetch_and_1, "__atomic_fetch_and_1"); + symbol(&__atomic_fetch_and_2, "__atomic_fetch_and_2"); + symbol(&__atomic_fetch_and_4, "__atomic_fetch_and_4"); + symbol(&__atomic_fetch_and_8, "__atomic_fetch_and_8"); + symbol(&__atomic_fetch_and_16, "__atomic_fetch_and_16"); - @export(&__atomic_fetch_or_1, .{ .name = "__atomic_fetch_or_1", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_or_2, .{ .name = "__atomic_fetch_or_2", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_or_4, .{ .name = "__atomic_fetch_or_4", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_or_8, .{ .name = "__atomic_fetch_or_8", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_or_16, .{ .name = "__atomic_fetch_or_16", .linkage = linkage, .visibility = visibility }); + symbol(&__atomic_fetch_or_1, "__atomic_fetch_or_1"); + symbol(&__atomic_fetch_or_2, "__atomic_fetch_or_2"); + symbol(&__atomic_fetch_or_4, "__atomic_fetch_or_4"); + symbol(&__atomic_fetch_or_8, "__atomic_fetch_or_8"); + symbol(&__atomic_fetch_or_16, "__atomic_fetch_or_16"); - @export(&__atomic_fetch_xor_1, .{ .name = "__atomic_fetch_xor_1", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_xor_2, .{ .name = "__atomic_fetch_xor_2", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_xor_4, .{ .name = "__atomic_fetch_xor_4", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_xor_8, .{ .name = "__atomic_fetch_xor_8", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_xor_16, .{ .name = "__atomic_fetch_xor_16", .linkage = linkage, .visibility = visibility }); + symbol(&__atomic_fetch_xor_1, "__atomic_fetch_xor_1"); + symbol(&__atomic_fetch_xor_2, "__atomic_fetch_xor_2"); + symbol(&__atomic_fetch_xor_4, "__atomic_fetch_xor_4"); + symbol(&__atomic_fetch_xor_8, "__atomic_fetch_xor_8"); + symbol(&__atomic_fetch_xor_16, "__atomic_fetch_xor_16"); - @export(&__atomic_fetch_nand_1, .{ .name = "__atomic_fetch_nand_1", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_nand_2, .{ .name = "__atomic_fetch_nand_2", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_nand_4, .{ .name = "__atomic_fetch_nand_4", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_nand_8, .{ .name = "__atomic_fetch_nand_8", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_nand_16, .{ .name = "__atomic_fetch_nand_16", .linkage = linkage, .visibility = visibility }); + symbol(&__atomic_fetch_nand_1, "__atomic_fetch_nand_1"); + symbol(&__atomic_fetch_nand_2, "__atomic_fetch_nand_2"); + symbol(&__atomic_fetch_nand_4, "__atomic_fetch_nand_4"); + symbol(&__atomic_fetch_nand_8, "__atomic_fetch_nand_8"); + symbol(&__atomic_fetch_nand_16, "__atomic_fetch_nand_16"); - @export(&__atomic_fetch_umax_1, .{ .name = "__atomic_fetch_umax_1", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_umax_2, .{ .name = "__atomic_fetch_umax_2", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_umax_4, .{ .name = "__atomic_fetch_umax_4", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_umax_8, .{ .name = "__atomic_fetch_umax_8", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_umax_16, .{ .name = "__atomic_fetch_umax_16", .linkage = linkage, .visibility = visibility }); + symbol(&__atomic_fetch_umax_1, "__atomic_fetch_umax_1"); + symbol(&__atomic_fetch_umax_2, "__atomic_fetch_umax_2"); + symbol(&__atomic_fetch_umax_4, "__atomic_fetch_umax_4"); + symbol(&__atomic_fetch_umax_8, "__atomic_fetch_umax_8"); + symbol(&__atomic_fetch_umax_16, "__atomic_fetch_umax_16"); - @export(&__atomic_fetch_umin_1, .{ .name = "__atomic_fetch_umin_1", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_umin_2, .{ .name = "__atomic_fetch_umin_2", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_umin_4, .{ .name = "__atomic_fetch_umin_4", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_umin_8, .{ .name = "__atomic_fetch_umin_8", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_fetch_umin_16, .{ .name = "__atomic_fetch_umin_16", .linkage = linkage, .visibility = visibility }); + symbol(&__atomic_fetch_umin_1, "__atomic_fetch_umin_1"); + symbol(&__atomic_fetch_umin_2, "__atomic_fetch_umin_2"); + symbol(&__atomic_fetch_umin_4, "__atomic_fetch_umin_4"); + symbol(&__atomic_fetch_umin_8, "__atomic_fetch_umin_8"); + symbol(&__atomic_fetch_umin_16, "__atomic_fetch_umin_16"); - @export(&__atomic_load_1, .{ .name = "__atomic_load_1", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_load_2, .{ .name = "__atomic_load_2", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_load_4, .{ .name = "__atomic_load_4", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_load_8, .{ .name = "__atomic_load_8", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_load_16, .{ .name = "__atomic_load_16", .linkage = linkage, .visibility = visibility }); + symbol(&__atomic_load_1, "__atomic_load_1"); + symbol(&__atomic_load_2, "__atomic_load_2"); + symbol(&__atomic_load_4, "__atomic_load_4"); + symbol(&__atomic_load_8, "__atomic_load_8"); + symbol(&__atomic_load_16, "__atomic_load_16"); - @export(&__atomic_store_1, .{ .name = "__atomic_store_1", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_store_2, .{ .name = "__atomic_store_2", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_store_4, .{ .name = "__atomic_store_4", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_store_8, .{ .name = "__atomic_store_8", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_store_16, .{ .name = "__atomic_store_16", .linkage = linkage, .visibility = visibility }); + symbol(&__atomic_store_1, "__atomic_store_1"); + symbol(&__atomic_store_2, "__atomic_store_2"); + symbol(&__atomic_store_4, "__atomic_store_4"); + symbol(&__atomic_store_8, "__atomic_store_8"); + symbol(&__atomic_store_16, "__atomic_store_16"); - @export(&__atomic_exchange_1, .{ .name = "__atomic_exchange_1", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_exchange_2, .{ .name = "__atomic_exchange_2", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_exchange_4, .{ .name = "__atomic_exchange_4", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_exchange_8, .{ .name = "__atomic_exchange_8", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_exchange_16, .{ .name = "__atomic_exchange_16", .linkage = linkage, .visibility = visibility }); + symbol(&__atomic_exchange_1, "__atomic_exchange_1"); + symbol(&__atomic_exchange_2, "__atomic_exchange_2"); + symbol(&__atomic_exchange_4, "__atomic_exchange_4"); + symbol(&__atomic_exchange_8, "__atomic_exchange_8"); + symbol(&__atomic_exchange_16, "__atomic_exchange_16"); - @export(&__atomic_compare_exchange_1, .{ .name = "__atomic_compare_exchange_1", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_compare_exchange_2, .{ .name = "__atomic_compare_exchange_2", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_compare_exchange_4, .{ .name = "__atomic_compare_exchange_4", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_compare_exchange_8, .{ .name = "__atomic_compare_exchange_8", .linkage = linkage, .visibility = visibility }); - @export(&__atomic_compare_exchange_16, .{ .name = "__atomic_compare_exchange_16", .linkage = linkage, .visibility = visibility }); + symbol(&__atomic_compare_exchange_1, "__atomic_compare_exchange_1"); + symbol(&__atomic_compare_exchange_2, "__atomic_compare_exchange_2"); + symbol(&__atomic_compare_exchange_4, "__atomic_compare_exchange_4"); + symbol(&__atomic_compare_exchange_8, "__atomic_compare_exchange_8"); + symbol(&__atomic_compare_exchange_16, "__atomic_compare_exchange_16"); } } diff --git a/lib/compiler_rt/aulldiv.zig b/lib/compiler_rt/aulldiv.zig index fbfa18dfd1..fb0d6126a8 100644 --- a/lib/compiler_rt/aulldiv.zig +++ b/lib/compiler_rt/aulldiv.zig @@ -1,15 +1,13 @@ -const std = @import("std"); const builtin = @import("builtin"); -const arch = builtin.cpu.arch; -const os = builtin.os.tag; -const abi = builtin.abi; + const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_windows_x86_msvc_abi) { // Don't let LLVM apply the stdcall name mangling on those MSVC builtins - @export(&_alldiv, .{ .name = "\x01__alldiv", .linkage = common.linkage, .visibility = common.visibility }); - @export(&_aulldiv, .{ .name = "\x01__aulldiv", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&_alldiv, "\x01__alldiv"); + symbol(&_aulldiv, "\x01__aulldiv"); } } diff --git a/lib/compiler_rt/cmpdf2.zig b/lib/compiler_rt/cmpdf2.zig index ebec596f27..691827ac4b 100644 --- a/lib/compiler_rt/cmpdf2.zig +++ b/lib/compiler_rt/cmpdf2.zig @@ -2,18 +2,19 @@ ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines const common = @import("./common.zig"); const comparef = @import("./comparef.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_aeabi) { - @export(&__aeabi_dcmpeq, .{ .name = "__aeabi_dcmpeq", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__aeabi_dcmplt, .{ .name = "__aeabi_dcmplt", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__aeabi_dcmple, .{ .name = "__aeabi_dcmple", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_dcmpeq, "__aeabi_dcmpeq"); + symbol(&__aeabi_dcmplt, "__aeabi_dcmplt"); + symbol(&__aeabi_dcmple, "__aeabi_dcmple"); } else { - @export(&__eqdf2, .{ .name = "__eqdf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__nedf2, .{ .name = "__nedf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__ledf2, .{ .name = "__ledf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__cmpdf2, .{ .name = "__cmpdf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__ltdf2, .{ .name = "__ltdf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__eqdf2, "__eqdf2"); + symbol(&__nedf2, "__nedf2"); + symbol(&__ledf2, "__ledf2"); + symbol(&__cmpdf2, "__cmpdf2"); + symbol(&__ltdf2, "__ltdf2"); } } diff --git a/lib/compiler_rt/cmptf2.zig b/lib/compiler_rt/cmptf2.zig index 3188ecf90e..846e62935c 100644 --- a/lib/compiler_rt/cmptf2.zig +++ b/lib/compiler_rt/cmptf2.zig @@ -2,27 +2,28 @@ ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines const common = @import("./common.zig"); const comparef = @import("./comparef.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_ppc_abi) { - @export(&__eqtf2, .{ .name = "__eqkf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__netf2, .{ .name = "__nekf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__lttf2, .{ .name = "__ltkf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__letf2, .{ .name = "__lekf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__eqtf2, "__eqkf2"); + symbol(&__netf2, "__nekf2"); + symbol(&__lttf2, "__ltkf2"); + symbol(&__letf2, "__lekf2"); } else if (common.want_sparc_abi) { - @export(&_Qp_cmp, .{ .name = "_Qp_cmp", .linkage = common.linkage, .visibility = common.visibility }); - @export(&_Qp_feq, .{ .name = "_Qp_feq", .linkage = common.linkage, .visibility = common.visibility }); - @export(&_Qp_fne, .{ .name = "_Qp_fne", .linkage = common.linkage, .visibility = common.visibility }); - @export(&_Qp_flt, .{ .name = "_Qp_flt", .linkage = common.linkage, .visibility = common.visibility }); - @export(&_Qp_fle, .{ .name = "_Qp_fle", .linkage = common.linkage, .visibility = common.visibility }); - @export(&_Qp_fgt, .{ .name = "_Qp_fgt", .linkage = common.linkage, .visibility = common.visibility }); - @export(&_Qp_fge, .{ .name = "_Qp_fge", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&_Qp_cmp, "_Qp_cmp"); + symbol(&_Qp_feq, "_Qp_feq"); + symbol(&_Qp_fne, "_Qp_fne"); + symbol(&_Qp_flt, "_Qp_flt"); + symbol(&_Qp_fle, "_Qp_fle"); + symbol(&_Qp_fgt, "_Qp_fgt"); + symbol(&_Qp_fge, "_Qp_fge"); } - @export(&__eqtf2, .{ .name = "__eqtf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__netf2, .{ .name = "__netf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__letf2, .{ .name = "__letf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__cmptf2, .{ .name = "__cmptf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__lttf2, .{ .name = "__lttf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__eqtf2, "__eqtf2"); + symbol(&__netf2, "__netf2"); + symbol(&__letf2, "__letf2"); + symbol(&__cmptf2, "__cmptf2"); + symbol(&__lttf2, "__lttf2"); } /// "These functions calculate a <=> b. That is, if a is less than b, they return -1; diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig index a9b4c2296c..0839d78b1b 100644 --- a/lib/compiler_rt/common.zig +++ b/lib/compiler_rt/common.zig @@ -3,23 +3,11 @@ const builtin = @import("builtin"); const native_endian = builtin.cpu.arch.endian(); const ofmt_c = builtin.object_format == .c; -/// For now, we prefer weak linkage because some of the routines we implement here may also be -/// provided by system/dynamic libc. Eventually we should be more disciplined about this on a -/// per-symbol, per-target basis: https://github.com/ziglang/zig/issues/11883 -pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) - .internal -else if (ofmt_c) - .strong -else - .weak; +/// Deprecated, everything in common should move to compiler_rt.zig +pub const linkage = @import("../compiler_rt.zig").linkage; -/// 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 = if (linkage == .internal or builtin.link_mode == .dynamic) - .default -else - .hidden; +/// Deprecated, everything in common should move to compiler_rt.zig +pub const visibility = @import("../compiler_rt.zig").visibility; pub const PreferredLoadStoreElement = element: { if (std.simd.suggestVectorLength(u8)) |vec_size| { @@ -121,10 +109,8 @@ pub const gnu_f16_abi = switch (builtin.cpu.arch) { pub const want_sparc_abi = builtin.cpu.arch.isSPARC(); -pub const test_safety = switch (builtin.zig_backend) { - .stage2_aarch64 => false, - else => builtin.is_test, -}; +/// Deprecated, everything in common should move to compiler_rt.zig +pub const test_safety = @import("../compiler_rt.zig").test_safety; /// This seems to mostly correspond to `clang::TargetInfo::HasFloat16`. pub fn F16T(comptime OtherType: type) type { diff --git a/lib/compiler_rt/cos.zig b/lib/compiler_rt/cos.zig index 3384887385..406098d56b 100644 --- a/lib/compiler_rt/cos.zig +++ b/lib/compiler_rt/cos.zig @@ -2,22 +2,23 @@ const std = @import("std"); const math = std.math; const mem = std.mem; const expect = std.testing.expect; -const common = @import("common.zig"); +const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const trig = @import("trig.zig"); const rem_pio2 = @import("rem_pio2.zig").rem_pio2; const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f; comptime { - @export(&__cosh, .{ .name = "__cosh", .linkage = common.linkage, .visibility = common.visibility }); - @export(&cosf, .{ .name = "cosf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&cos, .{ .name = "cos", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__cosx, .{ .name = "__cosx", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__cosh, "__cosh"); + symbol(&cosf, "cosf"); + symbol(&cos, "cos"); + symbol(&__cosx, "__cosx"); if (common.want_ppc_abi) { - @export(&cosq, .{ .name = "cosf128", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&cosq, "cosf128"); } - @export(&cosq, .{ .name = "cosq", .linkage = common.linkage, .visibility = common.visibility }); - @export(&cosl, .{ .name = "cosl", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&cosq, "cosq"); + symbol(&cosl, "cosl"); } pub fn __cosh(a: f16) callconv(.c) f16 { diff --git a/lib/compiler_rt/count0bits.zig b/lib/compiler_rt/count0bits.zig index 3696c89944..1208486464 100644 --- a/lib/compiler_rt/count0bits.zig +++ b/lib/compiler_rt/count0bits.zig @@ -1,17 +1,17 @@ -const std = @import("std"); const builtin = @import("builtin"); -const common = @import("common.zig"); +const std = @import("std"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__clzsi2, .{ .name = "__clzsi2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__clzdi2, .{ .name = "__clzdi2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__clzti2, .{ .name = "__clzti2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__ctzsi2, .{ .name = "__ctzsi2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__ctzdi2, .{ .name = "__ctzdi2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__ctzti2, .{ .name = "__ctzti2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__ffssi2, .{ .name = "__ffssi2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__ffsdi2, .{ .name = "__ffsdi2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__ffsti2, .{ .name = "__ffsti2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__clzsi2, "__clzsi2"); + symbol(&__clzdi2, "__clzdi2"); + symbol(&__clzti2, "__clzti2"); + symbol(&__ctzsi2, "__ctzsi2"); + symbol(&__ctzdi2, "__ctzdi2"); + symbol(&__ctzti2, "__ctzti2"); + symbol(&__ffssi2, "__ffssi2"); + symbol(&__ffsdi2, "__ffsdi2"); + symbol(&__ffsti2, "__ffsti2"); } // clz - count leading zeroes diff --git a/lib/compiler_rt/divdc3.zig b/lib/compiler_rt/divdc3.zig index ce2797ee39..e26dd26d61 100644 --- a/lib/compiler_rt/divdc3.zig +++ b/lib/compiler_rt/divdc3.zig @@ -1,10 +1,10 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const divc3 = @import("./divc3.zig"); const Complex = @import("./mulc3.zig").Complex; comptime { if (@import("builtin").zig_backend != .stage2_c) { - @export(&__divdc3, .{ .name = "__divdc3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__divdc3, "__divdc3"); } } diff --git a/lib/compiler_rt/divdf3.zig b/lib/compiler_rt/divdf3.zig index a94544165b..c57b432832 100644 --- a/lib/compiler_rt/divdf3.zig +++ b/lib/compiler_rt/divdf3.zig @@ -3,18 +3,17 @@ //! https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/lib/builtins/divdf3.c const std = @import("std"); -const builtin = @import("builtin"); -const arch = builtin.cpu.arch; const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const normalize = common.normalize; const wideMultiply = common.wideMultiply; comptime { if (common.want_aeabi) { - @export(&__aeabi_ddiv, .{ .name = "__aeabi_ddiv", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_ddiv, "__aeabi_ddiv"); } else { - @export(&__divdf3, .{ .name = "__divdf3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__divdf3, "__divdf3"); } } diff --git a/lib/compiler_rt/divhf3.zig b/lib/compiler_rt/divhf3.zig index 84bfe37871..fc2710ff27 100644 --- a/lib/compiler_rt/divhf3.zig +++ b/lib/compiler_rt/divhf3.zig @@ -1,8 +1,8 @@ -const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const divsf3 = @import("./divsf3.zig"); comptime { - @export(&__divhf3, .{ .name = "__divhf3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__divhf3, "__divhf3"); } pub fn __divhf3(a: f16, b: f16) callconv(.c) f16 { diff --git a/lib/compiler_rt/divmodei4.zig b/lib/compiler_rt/divmodei4.zig index ab11452206..d96be7dec5 100644 --- a/lib/compiler_rt/divmodei4.zig +++ b/lib/compiler_rt/divmodei4.zig @@ -1,15 +1,17 @@ -const std = @import("std"); const builtin = @import("builtin"); +const endian = builtin.cpu.arch.endian(); + +const std = @import("std"); + const common = @import("common.zig"); const udivmod = @import("udivmodei4.zig").divmod; +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__divei4, .{ .name = "__divei4", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__modei4, .{ .name = "__modei4", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__divei4, "__divei4"); + symbol(&__modei4, "__modei4"); } -const endian = builtin.cpu.arch.endian(); - inline fn limb(x: []u32, i: usize) *u32 { return if (endian == .little) &x[i] else &x[x.len - 1 - i]; } diff --git a/lib/compiler_rt/divsc3.zig b/lib/compiler_rt/divsc3.zig index 504d8f7d67..9378bfab8c 100644 --- a/lib/compiler_rt/divsc3.zig +++ b/lib/compiler_rt/divsc3.zig @@ -1,10 +1,10 @@ -const common = @import("./common.zig"); const divc3 = @import("./divc3.zig"); const Complex = @import("./mulc3.zig").Complex; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (@import("builtin").zig_backend != .stage2_c) { - @export(&__divsc3, .{ .name = "__divsc3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__divsc3, "__divsc3"); } } diff --git a/lib/compiler_rt/divsf3.zig b/lib/compiler_rt/divsf3.zig index dca1d49ebe..67e24de80d 100644 --- a/lib/compiler_rt/divsf3.zig +++ b/lib/compiler_rt/divsf3.zig @@ -3,17 +3,16 @@ //! https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/lib/builtins/divsf3.c const std = @import("std"); -const builtin = @import("builtin"); -const arch = builtin.cpu.arch; const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const normalize = common.normalize; comptime { if (common.want_aeabi) { - @export(&__aeabi_fdiv, .{ .name = "__aeabi_fdiv", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_fdiv, "__aeabi_fdiv"); } else { - @export(&__divsf3, .{ .name = "__divsf3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__divsf3, "__divsf3"); } } diff --git a/lib/compiler_rt/divtc3.zig b/lib/compiler_rt/divtc3.zig index 3bdf2a9033..d686958621 100644 --- a/lib/compiler_rt/divtc3.zig +++ b/lib/compiler_rt/divtc3.zig @@ -1,12 +1,13 @@ const common = @import("./common.zig"); const divc3 = @import("./divc3.zig"); const Complex = @import("./mulc3.zig").Complex; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (@import("builtin").zig_backend != .stage2_c) { if (common.want_ppc_abi) - @export(&__divtc3, .{ .name = "__divkc3", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__divtc3, .{ .name = "__divtc3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__divtc3, "__divkc3"); + symbol(&__divtc3, "__divtc3"); } } diff --git a/lib/compiler_rt/divxc3.zig b/lib/compiler_rt/divxc3.zig index 6e5f7905dd..86c737a839 100644 --- a/lib/compiler_rt/divxc3.zig +++ b/lib/compiler_rt/divxc3.zig @@ -1,10 +1,10 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const divc3 = @import("./divc3.zig"); const Complex = @import("./mulc3.zig").Complex; comptime { if (@import("builtin").zig_backend != .stage2_c) { - @export(&__divxc3, .{ .name = "__divxc3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__divxc3, "__divxc3"); } } diff --git a/lib/compiler_rt/exp.zig b/lib/compiler_rt/exp.zig index f25bf57092..3f18188fa0 100644 --- a/lib/compiler_rt/exp.zig +++ b/lib/compiler_rt/exp.zig @@ -4,25 +4,28 @@ // https://git.musl-libc.org/cgit/musl/tree/src/math/expf.c // https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c -const std = @import("std"); const builtin = @import("builtin"); const arch = builtin.cpu.arch; + +const std = @import("std"); const math = std.math; const mem = std.mem; const expect = std.testing.expect; const expectEqual = std.testing.expectEqual; + const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__exph, .{ .name = "__exph", .linkage = common.linkage, .visibility = common.visibility }); - @export(&expf, .{ .name = "expf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&exp, .{ .name = "exp", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__expx, .{ .name = "__expx", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__exph, "__exph"); + symbol(&expf, "expf"); + symbol(&exp, "exp"); + symbol(&__expx, "__expx"); if (common.want_ppc_abi) { - @export(&expq, .{ .name = "expf128", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&expq, "expf128"); } - @export(&expq, .{ .name = "expq", .linkage = common.linkage, .visibility = common.visibility }); - @export(&expl, .{ .name = "expl", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&expq, "expq"); + symbol(&expl, "expl"); } pub fn __exph(a: f16) callconv(.c) f16 { diff --git a/lib/compiler_rt/extenddftf2.zig b/lib/compiler_rt/extenddftf2.zig index 9ef552c2c5..0204de48ed 100644 --- a/lib/compiler_rt/extenddftf2.zig +++ b/lib/compiler_rt/extenddftf2.zig @@ -1,13 +1,14 @@ const common = @import("./common.zig"); const extendf = @import("./extendf.zig").extendf; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_ppc_abi) { - @export(&__extenddftf2, .{ .name = "__extenddfkf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__extenddftf2, "__extenddfkf2"); } else if (common.want_sparc_abi) { - @export(&_Qp_dtoq, .{ .name = "_Qp_dtoq", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&_Qp_dtoq, "_Qp_dtoq"); } - @export(&__extenddftf2, .{ .name = "__extenddftf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__extenddftf2, "__extenddftf2"); } pub fn __extenddftf2(a: f64) callconv(.c) f128 { diff --git a/lib/compiler_rt/extendhfdf2.zig b/lib/compiler_rt/extendhfdf2.zig index 3b3b65ec11..2191bafe13 100644 --- a/lib/compiler_rt/extendhfdf2.zig +++ b/lib/compiler_rt/extendhfdf2.zig @@ -1,8 +1,9 @@ const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const extendf = @import("./extendf.zig").extendf; comptime { - @export(&__extendhfdf2, .{ .name = "__extendhfdf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__extendhfdf2, "__extendhfdf2"); } pub fn __extendhfdf2(a: common.F16T(f64)) callconv(.c) f64 { diff --git a/lib/compiler_rt/extendhfsf2.zig b/lib/compiler_rt/extendhfsf2.zig index f4f8be4305..2c734f0147 100644 --- a/lib/compiler_rt/extendhfsf2.zig +++ b/lib/compiler_rt/extendhfsf2.zig @@ -1,13 +1,14 @@ const common = @import("./common.zig"); const extendf = @import("./extendf.zig").extendf; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.gnu_f16_abi) { - @export(&__gnu_h2f_ieee, .{ .name = "__gnu_h2f_ieee", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__gnu_h2f_ieee, "__gnu_h2f_ieee"); } else if (common.want_aeabi) { - @export(&__aeabi_h2f, .{ .name = "__aeabi_h2f", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_h2f, "__aeabi_h2f"); } - @export(&__extendhfsf2, .{ .name = "__extendhfsf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__extendhfsf2, "__extendhfsf2"); } pub fn __extendhfsf2(a: common.F16T(f32)) callconv(.c) f32 { diff --git a/lib/compiler_rt/extendsfxf2.zig b/lib/compiler_rt/extendsfxf2.zig index 8665c445f7..9a6796bd66 100644 --- a/lib/compiler_rt/extendsfxf2.zig +++ b/lib/compiler_rt/extendsfxf2.zig @@ -1,8 +1,8 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const extend_f80 = @import("./extendf.zig").extend_f80; comptime { - @export(&__extendsfxf2, .{ .name = "__extendsfxf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__extendsfxf2, "__extendsfxf2"); } fn __extendsfxf2(a: f32) callconv(.c) f80 { diff --git a/lib/compiler_rt/extendxftf2.zig b/lib/compiler_rt/extendxftf2.zig index cec1fa1f7c..1c39e1e84c 100644 --- a/lib/compiler_rt/extendxftf2.zig +++ b/lib/compiler_rt/extendxftf2.zig @@ -1,8 +1,9 @@ const std = @import("std"); -const common = @import("./common.zig"); + +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__extendxftf2, .{ .name = "__extendxftf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__extendxftf2, "__extendxftf2"); } fn __extendxftf2(a: f80) callconv(.c) f128 { diff --git a/lib/compiler_rt/fixdfsi.zig b/lib/compiler_rt/fixdfsi.zig index b1b26867b9..7707f89830 100644 --- a/lib/compiler_rt/fixdfsi.zig +++ b/lib/compiler_rt/fixdfsi.zig @@ -1,11 +1,12 @@ const common = @import("./common.zig"); const intFromFloat = @import("./int_from_float.zig").intFromFloat; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_aeabi) { - @export(&__aeabi_d2iz, .{ .name = "__aeabi_d2iz", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_d2iz, "__aeabi_d2iz"); } else { - @export(&__fixdfsi, .{ .name = "__fixdfsi", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixdfsi, "__fixdfsi"); } } diff --git a/lib/compiler_rt/fixdfti.zig b/lib/compiler_rt/fixdfti.zig index 499811c551..64c5a080f9 100644 --- a/lib/compiler_rt/fixdfti.zig +++ b/lib/compiler_rt/fixdfti.zig @@ -1,12 +1,12 @@ -const builtin = @import("builtin"); const common = @import("./common.zig"); const intFromFloat = @import("./int_from_float.zig").intFromFloat; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_windows_v2u64_abi) { - @export(&__fixdfti_windows_x86_64, .{ .name = "__fixdfti", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixdfti_windows_x86_64, "__fixdfti"); } else { - @export(&__fixdfti, .{ .name = "__fixdfti", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixdfti, "__fixdfti"); } } diff --git a/lib/compiler_rt/fixsfdi.zig b/lib/compiler_rt/fixsfdi.zig index 894d5a0c13..b2880aefc2 100644 --- a/lib/compiler_rt/fixsfdi.zig +++ b/lib/compiler_rt/fixsfdi.zig @@ -1,15 +1,16 @@ const builtin = @import("builtin"); const common = @import("./common.zig"); const intFromFloat = @import("./int_from_float.zig").intFromFloat; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_aeabi) { - @export(&__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_f2lz, "__aeabi_f2lz"); } else { if (common.want_windows_arm_abi) { - @export(&__fixsfdi, .{ .name = "__stoi64", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixsfdi, "__stoi64"); } - @export(&__fixsfdi, .{ .name = "__fixsfdi", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixsfdi, "__fixsfdi"); } } diff --git a/lib/compiler_rt/fixtfdi.zig b/lib/compiler_rt/fixtfdi.zig index 5c41f56595..bc1c8e56eb 100644 --- a/lib/compiler_rt/fixtfdi.zig +++ b/lib/compiler_rt/fixtfdi.zig @@ -1,13 +1,14 @@ const common = @import("./common.zig"); const intFromFloat = @import("./int_from_float.zig").intFromFloat; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_ppc_abi) { - @export(&__fixtfdi, .{ .name = "__fixkfdi", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixtfdi, "__fixkfdi"); } else if (common.want_sparc_abi) { - @export(&_Qp_qtox, .{ .name = "_Qp_qtox", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&_Qp_qtox, "_Qp_qtox"); } - @export(&__fixtfdi, .{ .name = "__fixtfdi", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixtfdi, "__fixtfdi"); } pub fn __fixtfdi(a: f128) callconv(.c) i64 { diff --git a/lib/compiler_rt/fixtfsi.zig b/lib/compiler_rt/fixtfsi.zig index 0d525cf8c4..0919566a80 100644 --- a/lib/compiler_rt/fixtfsi.zig +++ b/lib/compiler_rt/fixtfsi.zig @@ -1,13 +1,14 @@ const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const intFromFloat = @import("./int_from_float.zig").intFromFloat; comptime { if (common.want_ppc_abi) { - @export(&__fixtfsi, .{ .name = "__fixkfsi", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixtfsi, "__fixkfsi"); } else if (common.want_sparc_abi) { - @export(&_Qp_qtoi, .{ .name = "_Qp_qtoi", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&_Qp_qtoi, "_Qp_qtoi"); } - @export(&__fixtfsi, .{ .name = "__fixtfsi", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixtfsi, "__fixtfsi"); } pub fn __fixtfsi(a: f128) callconv(.c) i32 { diff --git a/lib/compiler_rt/fixtfti.zig b/lib/compiler_rt/fixtfti.zig index fe71a0f089..2a1a928256 100644 --- a/lib/compiler_rt/fixtfti.zig +++ b/lib/compiler_rt/fixtfti.zig @@ -1,14 +1,14 @@ -const builtin = @import("builtin"); const common = @import("./common.zig"); const intFromFloat = @import("./int_from_float.zig").intFromFloat; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_windows_v2u64_abi) { - @export(&__fixtfti_windows_x86_64, .{ .name = "__fixtfti", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixtfti_windows_x86_64, "__fixtfti"); } else { if (common.want_ppc_abi) - @export(&__fixtfti, .{ .name = "__fixkfti", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__fixtfti, .{ .name = "__fixtfti", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixtfti, "__fixkfti"); + symbol(&__fixtfti, "__fixtfti"); } } diff --git a/lib/compiler_rt/fixunsdfei.zig b/lib/compiler_rt/fixunsdfei.zig index be5bbf0a8a..f564f7f7a3 100644 --- a/lib/compiler_rt/fixunsdfei.zig +++ b/lib/compiler_rt/fixunsdfei.zig @@ -1,10 +1,12 @@ -const std = @import("std"); const builtin = @import("builtin"); -const common = @import("common.zig"); + +const std = @import("std"); + +const symbol = @import("../compiler_rt.zig").symbol; const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat; comptime { - @export(&__fixunsdfei, .{ .name = "__fixunsdfei", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixunsdfei, "__fixunsdfei"); } pub fn __fixunsdfei(r: [*]u8, bits: usize, a: f64) callconv(.c) void { diff --git a/lib/compiler_rt/fixunsdfti.zig b/lib/compiler_rt/fixunsdfti.zig index 28b79a0733..a90b3d67fb 100644 --- a/lib/compiler_rt/fixunsdfti.zig +++ b/lib/compiler_rt/fixunsdfti.zig @@ -1,12 +1,12 @@ -const builtin = @import("builtin"); const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const intFromFloat = @import("./int_from_float.zig").intFromFloat; comptime { if (common.want_windows_v2u64_abi) { - @export(&__fixunsdfti_windows_x86_64, .{ .name = "__fixunsdfti", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixunsdfti_windows_x86_64, "__fixunsdfti"); } else { - @export(&__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixunsdfti, "__fixunsdfti"); } } diff --git a/lib/compiler_rt/fixunshfdi.zig b/lib/compiler_rt/fixunshfdi.zig index a949ee9904..741e482506 100644 --- a/lib/compiler_rt/fixunshfdi.zig +++ b/lib/compiler_rt/fixunshfdi.zig @@ -1,8 +1,8 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const intFromFloat = @import("./int_from_float.zig").intFromFloat; comptime { - @export(&__fixunshfdi, .{ .name = "__fixunshfdi", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixunshfdi, "__fixunshfdi"); } fn __fixunshfdi(a: f16) callconv(.c) u64 { diff --git a/lib/compiler_rt/fixunshfei.zig b/lib/compiler_rt/fixunshfei.zig index 4cb7ef2ba8..a61d94f395 100644 --- a/lib/compiler_rt/fixunshfei.zig +++ b/lib/compiler_rt/fixunshfei.zig @@ -1,10 +1,12 @@ -const std = @import("std"); const builtin = @import("builtin"); -const common = @import("common.zig"); + +const std = @import("std"); + +const symbol = @import("../compiler_rt.zig").symbol; const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat; comptime { - @export(&__fixunshfei, .{ .name = "__fixunshfei", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixunshfei, "__fixunshfei"); } pub fn __fixunshfei(r: [*]u8, bits: usize, a: f16) callconv(.c) void { diff --git a/lib/compiler_rt/fixunshfti.zig b/lib/compiler_rt/fixunshfti.zig index c61be597e7..454aa9d575 100644 --- a/lib/compiler_rt/fixunshfti.zig +++ b/lib/compiler_rt/fixunshfti.zig @@ -1,12 +1,12 @@ -const builtin = @import("builtin"); const common = @import("./common.zig"); const intFromFloat = @import("./int_from_float.zig").intFromFloat; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_windows_v2u64_abi) { - @export(&__fixunshfti_windows_x86_64, .{ .name = "__fixunshfti", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixunshfti_windows_x86_64, "__fixunshfti"); } else { - @export(&__fixunshfti, .{ .name = "__fixunshfti", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixunshfti, "__fixunshfti"); } } diff --git a/lib/compiler_rt/fixunssfei.zig b/lib/compiler_rt/fixunssfei.zig index 0fb957ed1f..2fd123bd1b 100644 --- a/lib/compiler_rt/fixunssfei.zig +++ b/lib/compiler_rt/fixunssfei.zig @@ -1,10 +1,12 @@ -const std = @import("std"); const builtin = @import("builtin"); -const common = @import("common.zig"); + +const std = @import("std"); + +const symbol = @import("../compiler_rt.zig").symbol; const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat; comptime { - @export(&__fixunssfei, .{ .name = "__fixunssfei", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixunssfei, "__fixunssfei"); } pub fn __fixunssfei(r: [*]u8, bits: usize, a: f32) callconv(.c) void { diff --git a/lib/compiler_rt/fixunssfti.zig b/lib/compiler_rt/fixunssfti.zig index 693442417c..73e2d2a3f6 100644 --- a/lib/compiler_rt/fixunssfti.zig +++ b/lib/compiler_rt/fixunssfti.zig @@ -1,12 +1,13 @@ const builtin = @import("builtin"); const common = @import("./common.zig"); const intFromFloat = @import("./int_from_float.zig").intFromFloat; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_windows_v2u64_abi) { - @export(&__fixunssfti_windows_x86_64, .{ .name = "__fixunssfti", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixunssfti_windows_x86_64, "__fixunssfti"); } else { - @export(&__fixunssfti, .{ .name = "__fixunssfti", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixunssfti, "__fixunssfti"); } } diff --git a/lib/compiler_rt/fixunstfei.zig b/lib/compiler_rt/fixunstfei.zig index 84ac5010c9..3d8986da90 100644 --- a/lib/compiler_rt/fixunstfei.zig +++ b/lib/compiler_rt/fixunstfei.zig @@ -1,10 +1,12 @@ -const std = @import("std"); const builtin = @import("builtin"); -const common = @import("common.zig"); + +const std = @import("std"); + +const symbol = @import("../compiler_rt.zig").symbol; const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat; comptime { - @export(&__fixunstfei, .{ .name = "__fixunstfei", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixunstfei, "__fixunstfei"); } pub fn __fixunstfei(r: [*]u8, bits: usize, a: f128) callconv(.c) void { diff --git a/lib/compiler_rt/fixunsxfdi.zig b/lib/compiler_rt/fixunsxfdi.zig index 4dffd0253e..8385961b6b 100644 --- a/lib/compiler_rt/fixunsxfdi.zig +++ b/lib/compiler_rt/fixunsxfdi.zig @@ -1,8 +1,8 @@ -const common = @import("./common.zig"); const intFromFloat = @import("./int_from_float.zig").intFromFloat; +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__fixunsxfdi, .{ .name = "__fixunsxfdi", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixunsxfdi, "__fixunsxfdi"); } fn __fixunsxfdi(a: f80) callconv(.c) u64 { diff --git a/lib/compiler_rt/fixunsxfei.zig b/lib/compiler_rt/fixunsxfei.zig index dc795e74c6..d7902ddff5 100644 --- a/lib/compiler_rt/fixunsxfei.zig +++ b/lib/compiler_rt/fixunsxfei.zig @@ -1,10 +1,10 @@ const std = @import("std"); const builtin = @import("builtin"); -const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat; comptime { - @export(&__fixunsxfei, .{ .name = "__fixunsxfei", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixunsxfei, "__fixunsxfei"); } pub fn __fixunsxfei(r: [*]u8, bits: usize, a: f80) callconv(.c) void { diff --git a/lib/compiler_rt/fixxfdi.zig b/lib/compiler_rt/fixxfdi.zig index 155fead1bb..e9e4b7528b 100644 --- a/lib/compiler_rt/fixxfdi.zig +++ b/lib/compiler_rt/fixxfdi.zig @@ -1,8 +1,8 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const intFromFloat = @import("./int_from_float.zig").intFromFloat; comptime { - @export(&__fixxfdi, .{ .name = "__fixxfdi", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixxfdi, "__fixxfdi"); } fn __fixxfdi(a: f80) callconv(.c) i64 { diff --git a/lib/compiler_rt/fixxfti.zig b/lib/compiler_rt/fixxfti.zig index 292b9688e7..2f43814eac 100644 --- a/lib/compiler_rt/fixxfti.zig +++ b/lib/compiler_rt/fixxfti.zig @@ -1,12 +1,14 @@ const builtin = @import("builtin"); + const common = @import("./common.zig"); const intFromFloat = @import("./int_from_float.zig").intFromFloat; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_windows_v2u64_abi) { - @export(&__fixxfti_windows_x86_64, .{ .name = "__fixxfti", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixxfti_windows_x86_64, "__fixxfti"); } else { - @export(&__fixxfti, .{ .name = "__fixxfti", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__fixxfti, "__fixxfti"); } } diff --git a/lib/compiler_rt/floatdihf.zig b/lib/compiler_rt/floatdihf.zig index fd534e5946..c6865dff6b 100644 --- a/lib/compiler_rt/floatdihf.zig +++ b/lib/compiler_rt/floatdihf.zig @@ -1,8 +1,8 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { - @export(&__floatdihf, .{ .name = "__floatdihf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatdihf, "__floatdihf"); } fn __floatdihf(a: i64) callconv(.c) f16 { diff --git a/lib/compiler_rt/floatdisf.zig b/lib/compiler_rt/floatdisf.zig index 1efd9c937f..691ba91f26 100644 --- a/lib/compiler_rt/floatdisf.zig +++ b/lib/compiler_rt/floatdisf.zig @@ -1,15 +1,15 @@ -const builtin = @import("builtin"); const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { if (common.want_aeabi) { - @export(&__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_l2f, "__aeabi_l2f"); } else { if (common.want_windows_arm_abi) { - @export(&__floatdisf, .{ .name = "__i64tos", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatdisf, "__i64tos"); } - @export(&__floatdisf, .{ .name = "__floatdisf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatdisf, "__floatdisf"); } } diff --git a/lib/compiler_rt/floatditf.zig b/lib/compiler_rt/floatditf.zig index 864361b7b3..03182aab0b 100644 --- a/lib/compiler_rt/floatditf.zig +++ b/lib/compiler_rt/floatditf.zig @@ -1,13 +1,14 @@ const common = @import("./common.zig"); const floatFromInt = @import("./float_from_int.zig").floatFromInt; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_ppc_abi) { - @export(&__floatditf, .{ .name = "__floatdikf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatditf, "__floatdikf"); } else if (common.want_sparc_abi) { - @export(&_Qp_xtoq, .{ .name = "_Qp_xtoq", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&_Qp_xtoq, "_Qp_xtoq"); } - @export(&__floatditf, .{ .name = "__floatditf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatditf, "__floatditf"); } pub fn __floatditf(a: i64) callconv(.c) f128 { diff --git a/lib/compiler_rt/floatdixf.zig b/lib/compiler_rt/floatdixf.zig index 8ac6f06fb5..6bd06245d5 100644 --- a/lib/compiler_rt/floatdixf.zig +++ b/lib/compiler_rt/floatdixf.zig @@ -1,8 +1,8 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { - @export(&__floatdixf, .{ .name = "__floatdixf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatdixf, "__floatdixf"); } fn __floatdixf(a: i64) callconv(.c) f80 { diff --git a/lib/compiler_rt/floateidf.zig b/lib/compiler_rt/floateidf.zig index 6434743939..ac3972c287 100644 --- a/lib/compiler_rt/floateidf.zig +++ b/lib/compiler_rt/floateidf.zig @@ -1,10 +1,12 @@ -const std = @import("std"); const builtin = @import("builtin"); -const common = @import("common.zig"); + +const std = @import("std"); + const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt; +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__floateidf, .{ .name = "__floateidf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floateidf, "__floateidf"); } pub fn __floateidf(a: [*]const u8, bits: usize) callconv(.c) f64 { diff --git a/lib/compiler_rt/floateixf.zig b/lib/compiler_rt/floateixf.zig index ffb8445fd3..dafefa4e8f 100644 --- a/lib/compiler_rt/floateixf.zig +++ b/lib/compiler_rt/floateixf.zig @@ -1,10 +1,12 @@ -const std = @import("std"); const builtin = @import("builtin"); -const common = @import("common.zig"); + +const std = @import("std"); + +const symbol = @import("../compiler_rt.zig").symbol; const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt; comptime { - @export(&__floateixf, .{ .name = "__floateixf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floateixf, "__floateixf"); } pub fn __floateixf(a: [*]const u8, bits: usize) callconv(.c) f80 { diff --git a/lib/compiler_rt/floatsixf.zig b/lib/compiler_rt/floatsixf.zig index 59bf7ddb99..0d5fcb340d 100644 --- a/lib/compiler_rt/floatsixf.zig +++ b/lib/compiler_rt/floatsixf.zig @@ -1,8 +1,9 @@ const common = @import("./common.zig"); const floatFromInt = @import("./float_from_int.zig").floatFromInt; +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__floatsixf, .{ .name = "__floatsixf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatsixf, "__floatsixf"); } fn __floatsixf(a: i32) callconv(.c) f80 { diff --git a/lib/compiler_rt/floattidf.zig b/lib/compiler_rt/floattidf.zig index 2ac5726b51..db48fe8af3 100644 --- a/lib/compiler_rt/floattidf.zig +++ b/lib/compiler_rt/floattidf.zig @@ -1,12 +1,12 @@ -const builtin = @import("builtin"); const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { if (common.want_windows_v2u64_abi) { - @export(&__floattidf_windows_x86_64, .{ .name = "__floattidf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floattidf_windows_x86_64, "__floattidf"); } else { - @export(&__floattidf, .{ .name = "__floattidf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floattidf, "__floattidf"); } } diff --git a/lib/compiler_rt/floattisf.zig b/lib/compiler_rt/floattisf.zig index 953192f331..3e5fffcfd8 100644 --- a/lib/compiler_rt/floattisf.zig +++ b/lib/compiler_rt/floattisf.zig @@ -1,12 +1,12 @@ -const builtin = @import("builtin"); const common = @import("./common.zig"); const floatFromInt = @import("./float_from_int.zig").floatFromInt; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_windows_v2u64_abi) { - @export(&__floattisf_windows_x86_64, .{ .name = "__floattisf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floattisf_windows_x86_64, "__floattisf"); } else { - @export(&__floattisf, .{ .name = "__floattisf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floattisf, "__floattisf"); } } diff --git a/lib/compiler_rt/floattitf.zig b/lib/compiler_rt/floattitf.zig index 3973aa4ab2..e8e301c42d 100644 --- a/lib/compiler_rt/floattitf.zig +++ b/lib/compiler_rt/floattitf.zig @@ -1,14 +1,14 @@ -const builtin = @import("builtin"); const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { if (common.want_windows_v2u64_abi) { - @export(&__floattitf_windows_x86_64, .{ .name = "__floattitf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floattitf_windows_x86_64, "__floattitf"); } else { if (common.want_ppc_abi) - @export(&__floattitf, .{ .name = "__floattikf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__floattitf, .{ .name = "__floattitf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floattitf, "__floattikf"); + symbol(&__floattitf, "__floattitf"); } } diff --git a/lib/compiler_rt/floatundidf.zig b/lib/compiler_rt/floatundidf.zig index 7a9e4afe7a..6530f76ee7 100644 --- a/lib/compiler_rt/floatundidf.zig +++ b/lib/compiler_rt/floatundidf.zig @@ -1,15 +1,15 @@ -const builtin = @import("builtin"); const common = @import("./common.zig"); const floatFromInt = @import("./float_from_int.zig").floatFromInt; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_aeabi) { - @export(&__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_ul2d, "__aeabi_ul2d"); } else { if (common.want_windows_arm_abi) { - @export(&__floatundidf, .{ .name = "__u64tod", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatundidf, "__u64tod"); } - @export(&__floatundidf, .{ .name = "__floatundidf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatundidf, "__floatundidf"); } } diff --git a/lib/compiler_rt/floatuneitf.zig b/lib/compiler_rt/floatuneitf.zig index d84678ce11..ddee65dfb1 100644 --- a/lib/compiler_rt/floatuneitf.zig +++ b/lib/compiler_rt/floatuneitf.zig @@ -1,10 +1,12 @@ -const std = @import("std"); const builtin = @import("builtin"); -const common = @import("common.zig"); + +const std = @import("std"); + +const symbol = @import("../compiler_rt.zig").symbol; const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt; comptime { - @export(&__floatuneitf, .{ .name = "__floatuneitf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatuneitf, "__floatuneitf"); } pub fn __floatuneitf(a: [*]const u8, bits: usize) callconv(.c) f128 { diff --git a/lib/compiler_rt/floatunsihf.zig b/lib/compiler_rt/floatunsihf.zig index 123b76fcde..a2e42ca10f 100644 --- a/lib/compiler_rt/floatunsihf.zig +++ b/lib/compiler_rt/floatunsihf.zig @@ -1,8 +1,8 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { - @export(&__floatunsihf, .{ .name = "__floatunsihf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatunsihf, "__floatunsihf"); } pub fn __floatunsihf(a: u32) callconv(.c) f16 { diff --git a/lib/compiler_rt/floatunsisf.zig b/lib/compiler_rt/floatunsisf.zig index 4bcceba5c8..72ac1a5901 100644 --- a/lib/compiler_rt/floatunsisf.zig +++ b/lib/compiler_rt/floatunsisf.zig @@ -1,11 +1,12 @@ const common = @import("./common.zig"); const floatFromInt = @import("./float_from_int.zig").floatFromInt; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_aeabi) { - @export(&__aeabi_ui2f, .{ .name = "__aeabi_ui2f", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_ui2f, "__aeabi_ui2f"); } else { - @export(&__floatunsisf, .{ .name = "__floatunsisf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatunsisf, "__floatunsisf"); } } diff --git a/lib/compiler_rt/floatunsitf.zig b/lib/compiler_rt/floatunsitf.zig index e491987003..6ad2ca5c56 100644 --- a/lib/compiler_rt/floatunsitf.zig +++ b/lib/compiler_rt/floatunsitf.zig @@ -1,13 +1,14 @@ const common = @import("./common.zig"); const floatFromInt = @import("./float_from_int.zig").floatFromInt; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_ppc_abi) { - @export(&__floatunsitf, .{ .name = "__floatunsikf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatunsitf, "__floatunsikf"); } else if (common.want_sparc_abi) { - @export(&_Qp_uitoq, .{ .name = "_Qp_uitoq", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&_Qp_uitoq, "_Qp_uitoq"); } - @export(&__floatunsitf, .{ .name = "__floatunsitf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatunsitf, "__floatunsitf"); } pub fn __floatunsitf(a: u32) callconv(.c) f128 { diff --git a/lib/compiler_rt/floatuntidf.zig b/lib/compiler_rt/floatuntidf.zig index 284e50dd36..d2d34f5754 100644 --- a/lib/compiler_rt/floatuntidf.zig +++ b/lib/compiler_rt/floatuntidf.zig @@ -1,12 +1,12 @@ -const builtin = @import("builtin"); const common = @import("./common.zig"); const floatFromInt = @import("./float_from_int.zig").floatFromInt; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_windows_v2u64_abi) { - @export(&__floatuntidf_windows_x86_64, .{ .name = "__floatuntidf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatuntidf_windows_x86_64, "__floatuntidf"); } else { - @export(&__floatuntidf, .{ .name = "__floatuntidf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatuntidf, "__floatuntidf"); } } diff --git a/lib/compiler_rt/floatuntihf.zig b/lib/compiler_rt/floatuntihf.zig index 41da6f1bfb..629e8088eb 100644 --- a/lib/compiler_rt/floatuntihf.zig +++ b/lib/compiler_rt/floatuntihf.zig @@ -1,12 +1,12 @@ -const builtin = @import("builtin"); const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { if (common.want_windows_v2u64_abi) { - @export(&__floatuntihf_windows_x86_64, .{ .name = "__floatuntihf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatuntihf_windows_x86_64, "__floatuntihf"); } else { - @export(&__floatuntihf, .{ .name = "__floatuntihf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatuntihf, "__floatuntihf"); } } diff --git a/lib/compiler_rt/floatuntitf.zig b/lib/compiler_rt/floatuntitf.zig index 77dd22ed59..64063495b8 100644 --- a/lib/compiler_rt/floatuntitf.zig +++ b/lib/compiler_rt/floatuntitf.zig @@ -1,14 +1,14 @@ -const builtin = @import("builtin"); const common = @import("./common.zig"); const floatFromInt = @import("./float_from_int.zig").floatFromInt; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_windows_v2u64_abi) { - @export(&__floatuntitf_windows_x86_64, .{ .name = "__floatuntitf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatuntitf_windows_x86_64, "__floatuntitf"); } else { if (common.want_ppc_abi) - @export(&__floatuntitf, .{ .name = "__floatuntikf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__floatuntitf, .{ .name = "__floatuntitf", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floatuntitf, "__floatuntikf"); + symbol(&__floatuntitf, "__floatuntitf"); } } diff --git a/lib/compiler_rt/floor_ceil.zig b/lib/compiler_rt/floor_ceil.zig index e669cb812d..c44e9c2e57 100644 --- a/lib/compiler_rt/floor_ceil.zig +++ b/lib/compiler_rt/floor_ceil.zig @@ -15,29 +15,30 @@ const mem = std.mem; const expect = std.testing.expect; const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { // floor - @export(&__floorh, .{ .name = "__floorh", .linkage = common.linkage, .visibility = common.visibility }); - @export(&floorf, .{ .name = "floorf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&floor, .{ .name = "floor", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__floorx, .{ .name = "__floorx", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__floorh, "__floorh"); + symbol(&floorf, "floorf"); + symbol(&floor, "floor"); + symbol(&__floorx, "__floorx"); if (common.want_ppc_abi) { - @export(&floorq, .{ .name = "floorf128", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&floorq, "floorf128"); } - @export(&floorq, .{ .name = "floorq", .linkage = common.linkage, .visibility = common.visibility }); - @export(&floorl, .{ .name = "floorl", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&floorq, "floorq"); + symbol(&floorl, "floorl"); // ceil - @export(&__ceilh, .{ .name = "__ceilh", .linkage = common.linkage, .visibility = common.visibility }); - @export(&ceilf, .{ .name = "ceilf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&ceil, .{ .name = "ceil", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__ceilx, .{ .name = "__ceilx", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__ceilh, "__ceilh"); + symbol(&ceilf, "ceilf"); + symbol(&ceil, "ceil"); + symbol(&__ceilx, "__ceilx"); if (common.want_ppc_abi) { - @export(&ceilq, .{ .name = "ceilf128", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&ceilq, "ceilf128"); } - @export(&ceilq, .{ .name = "ceilq", .linkage = common.linkage, .visibility = common.visibility }); - @export(&ceill, .{ .name = "ceill", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&ceilq, "ceilq"); + symbol(&ceill, "ceill"); } pub fn __floorh(x: f16) callconv(.c) f16 { diff --git a/lib/compiler_rt/gedf2.zig b/lib/compiler_rt/gedf2.zig index aeb08b4a8b..bd16de17f8 100644 --- a/lib/compiler_rt/gedf2.zig +++ b/lib/compiler_rt/gedf2.zig @@ -2,14 +2,15 @@ ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines const common = @import("./common.zig"); const comparef = @import("./comparef.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_aeabi) { - @export(&__aeabi_dcmpge, .{ .name = "__aeabi_dcmpge", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__aeabi_dcmpgt, .{ .name = "__aeabi_dcmpgt", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_dcmpge, "__aeabi_dcmpge"); + symbol(&__aeabi_dcmpgt, "__aeabi_dcmpgt"); } else { - @export(&__gedf2, .{ .name = "__gedf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__gtdf2, .{ .name = "__gtdf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__gedf2, "__gedf2"); + symbol(&__gtdf2, "__gtdf2"); } } diff --git a/lib/compiler_rt/gehf2.zig b/lib/compiler_rt/gehf2.zig index b46d4a1a24..e4e15a449d 100644 --- a/lib/compiler_rt/gehf2.zig +++ b/lib/compiler_rt/gehf2.zig @@ -1,11 +1,11 @@ ///! The quoted behavior definitions are from ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const comparef = @import("./comparef.zig"); comptime { - @export(&__gehf2, .{ .name = "__gehf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__gthf2, .{ .name = "__gthf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__gehf2, "__gehf2"); + symbol(&__gthf2, "__gthf2"); } /// "These functions return a value greater than or equal to zero if neither diff --git a/lib/compiler_rt/gexf2.zig b/lib/compiler_rt/gexf2.zig index 365c298cc6..c6b3a1befd 100644 --- a/lib/compiler_rt/gexf2.zig +++ b/lib/compiler_rt/gexf2.zig @@ -1,9 +1,9 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const comparef = @import("./comparef.zig"); comptime { - @export(&__gexf2, .{ .name = "__gexf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__gtxf2, .{ .name = "__gtxf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__gexf2, "__gexf2"); + symbol(&__gtxf2, "__gtxf2"); } fn __gexf2(a: f80, b: f80) callconv(.c) i32 { diff --git a/lib/compiler_rt/int.zig b/lib/compiler_rt/int.zig index 3f38bad973..01827cf640 100644 --- a/lib/compiler_rt/int.zig +++ b/lib/compiler_rt/int.zig @@ -1,34 +1,37 @@ //! Builtin functions that operate on integer types const builtin = @import("builtin"); +const arch = builtin.cpu.arch; + const std = @import("std"); const testing = std.testing; const maxInt = std.math.maxInt; const minInt = std.math.minInt; -const arch = builtin.cpu.arch; + const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const udivmod = @import("udivmod.zig").udivmod; const __divti3 = @import("divti3.zig").__divti3; comptime { - @export(&__divmodti4, .{ .name = "__divmodti4", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__udivmoddi4, .{ .name = "__udivmoddi4", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__divmoddi4, .{ .name = "__divmoddi4", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__divmodti4, "__divmodti4"); + symbol(&__udivmoddi4, "__udivmoddi4"); + symbol(&__divmoddi4, "__divmoddi4"); if (common.want_aeabi) { - @export(&__aeabi_idiv, .{ .name = "__aeabi_idiv", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__aeabi_uidiv, .{ .name = "__aeabi_uidiv", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_idiv, "__aeabi_idiv"); + symbol(&__aeabi_uidiv, "__aeabi_uidiv"); } else { - @export(&__divsi3, .{ .name = "__divsi3", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__udivsi3, .{ .name = "__udivsi3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__divsi3, "__divsi3"); + symbol(&__udivsi3, "__udivsi3"); } - @export(&__divdi3, .{ .name = "__divdi3", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__udivdi3, .{ .name = "__udivdi3", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__modsi3, .{ .name = "__modsi3", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__moddi3, .{ .name = "__moddi3", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__umodsi3, .{ .name = "__umodsi3", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__umoddi3, .{ .name = "__umoddi3", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__divmodsi4, .{ .name = "__divmodsi4", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__udivmodsi4, .{ .name = "__udivmodsi4", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__divdi3, "__divdi3"); + symbol(&__udivdi3, "__udivdi3"); + symbol(&__modsi3, "__modsi3"); + symbol(&__moddi3, "__moddi3"); + symbol(&__umodsi3, "__umodsi3"); + symbol(&__umoddi3, "__umoddi3"); + symbol(&__divmodsi4, "__divmodsi4"); + symbol(&__udivmodsi4, "__udivmodsi4"); } pub fn __divmodti4(a: i128, b: i128, rem: *i128) callconv(.c) i128 { diff --git a/lib/compiler_rt/log.zig b/lib/compiler_rt/log.zig index 3270b27916..96dd319f72 100644 --- a/lib/compiler_rt/log.zig +++ b/lib/compiler_rt/log.zig @@ -5,23 +5,23 @@ //! https://git.musl-libc.org/cgit/musl/tree/src/math/log.c?h=1b76ff0767d01df72f692806ee5adee13c67ef88 const std = @import("std"); -const builtin = @import("builtin"); const math = std.math; const expect = std.testing.expect; const expectEqual = std.testing.expectEqual; -const arch = builtin.cpu.arch; + const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__logh, .{ .name = "__logh", .linkage = common.linkage, .visibility = common.visibility }); - @export(&logf, .{ .name = "logf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&log, .{ .name = "log", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__logx, .{ .name = "__logx", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__logh, "__logh"); + symbol(&logf, "logf"); + symbol(&log, "log"); + symbol(&__logx, "__logx"); if (common.want_ppc_abi) { - @export(&logq, .{ .name = "logf128", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&logq, "logf128"); } - @export(&logq, .{ .name = "logq", .linkage = common.linkage, .visibility = common.visibility }); - @export(&logl, .{ .name = "logl", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&logq, "logq"); + symbol(&logl, "logl"); } pub fn __logh(a: f16) callconv(.c) f16 { diff --git a/lib/compiler_rt/log10.zig b/lib/compiler_rt/log10.zig index d501cef461..d2741e3b23 100644 --- a/lib/compiler_rt/log10.zig +++ b/lib/compiler_rt/log10.zig @@ -5,24 +5,24 @@ //! https://git.musl-libc.org/cgit/musl/tree/src/math/log10.c const std = @import("std"); -const builtin = @import("builtin"); const math = std.math; const expect = std.testing.expect; const expectEqual = std.testing.expectEqual; const maxInt = std.math.maxInt; -const arch = builtin.cpu.arch; + const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__log10h, .{ .name = "__log10h", .linkage = common.linkage, .visibility = common.visibility }); - @export(&log10f, .{ .name = "log10f", .linkage = common.linkage, .visibility = common.visibility }); - @export(&log10, .{ .name = "log10", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__log10x, .{ .name = "__log10x", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__log10h, "__log10h"); + symbol(&log10f, "log10f"); + symbol(&log10, "log10"); + symbol(&__log10x, "__log10x"); if (common.want_ppc_abi) { - @export(&log10q, .{ .name = "log10f128", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&log10q, "log10f128"); } - @export(&log10q, .{ .name = "log10q", .linkage = common.linkage, .visibility = common.visibility }); - @export(&log10l, .{ .name = "log10l", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&log10q, "log10q"); + symbol(&log10l, "log10l"); } pub fn __log10h(a: f16) callconv(.c) f16 { diff --git a/lib/compiler_rt/memcmp.zig b/lib/compiler_rt/memcmp.zig deleted file mode 100644 index f332d82eac..0000000000 --- a/lib/compiler_rt/memcmp.zig +++ /dev/null @@ -1,30 +0,0 @@ -const std = @import("std"); -const common = @import("./common.zig"); - -comptime { - @export(&memcmp, .{ .name = "memcmp", .linkage = common.linkage, .visibility = common.visibility }); -} - -pub fn memcmp(vl: [*]const u8, vr: [*]const u8, n: usize) callconv(.c) c_int { - var i: usize = 0; - while (i < n) : (i += 1) { - const compared = @as(c_int, vl[i]) -% @as(c_int, vr[i]); - if (compared != 0) return compared; - } - return 0; -} - -test "memcmp" { - const arr0 = &[_]u8{ 1, 1, 1 }; - const arr1 = &[_]u8{ 1, 1, 1 }; - const arr2 = &[_]u8{ 1, 0, 1 }; - const arr3 = &[_]u8{ 1, 2, 1 }; - const arr4 = &[_]u8{ 1, 0xff, 1 }; - - try std.testing.expect(memcmp(arr0, arr1, 3) == 0); - try std.testing.expect(memcmp(arr0, arr2, 3) > 0); - try std.testing.expect(memcmp(arr0, arr3, 3) < 0); - - try std.testing.expect(memcmp(arr0, arr4, 3) < 0); - try std.testing.expect(memcmp(arr4, arr0, 3) > 0); -} diff --git a/lib/compiler_rt/muldc3.zig b/lib/compiler_rt/muldc3.zig index 9670c13128..d5facaa2b6 100644 --- a/lib/compiler_rt/muldc3.zig +++ b/lib/compiler_rt/muldc3.zig @@ -1,9 +1,9 @@ -const common = @import("./common.zig"); const mulc3 = @import("./mulc3.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (@import("builtin").zig_backend != .stage2_c) { - @export(&__muldc3, .{ .name = "__muldc3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__muldc3, "__muldc3"); } } diff --git a/lib/compiler_rt/muldf3.zig b/lib/compiler_rt/muldf3.zig index cf67df0913..e9c978430e 100644 --- a/lib/compiler_rt/muldf3.zig +++ b/lib/compiler_rt/muldf3.zig @@ -1,11 +1,12 @@ const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const mulf3 = @import("./mulf3.zig").mulf3; comptime { if (common.want_aeabi) { - @export(&__aeabi_dmul, .{ .name = "__aeabi_dmul", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_dmul, "__aeabi_dmul"); } else { - @export(&__muldf3, .{ .name = "__muldf3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__muldf3, "__muldf3"); } } diff --git a/lib/compiler_rt/mulsc3.zig b/lib/compiler_rt/mulsc3.zig index 49c1e31aec..e735e65ead 100644 --- a/lib/compiler_rt/mulsc3.zig +++ b/lib/compiler_rt/mulsc3.zig @@ -1,9 +1,9 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const mulc3 = @import("./mulc3.zig"); comptime { if (@import("builtin").zig_backend != .stage2_c) { - @export(&__mulsc3, .{ .name = "__mulsc3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__mulsc3, "__mulsc3"); } } diff --git a/lib/compiler_rt/multc3.zig b/lib/compiler_rt/multc3.zig index 1ed373660f..13870c6465 100644 --- a/lib/compiler_rt/multc3.zig +++ b/lib/compiler_rt/multc3.zig @@ -1,11 +1,12 @@ const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const mulc3 = @import("./mulc3.zig"); comptime { if (@import("builtin").zig_backend != .stage2_c) { if (common.want_ppc_abi) - @export(&__multc3, .{ .name = "__mulkc3", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__multc3, .{ .name = "__multc3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__multc3, "__mulkc3"); + symbol(&__multc3, "__multc3"); } } diff --git a/lib/compiler_rt/mulvsi3.zig b/lib/compiler_rt/mulvsi3.zig index e773ea0d9a..0935ea497a 100644 --- a/lib/compiler_rt/mulvsi3.zig +++ b/lib/compiler_rt/mulvsi3.zig @@ -1,9 +1,10 @@ -const mulv = @import("mulo.zig"); -const common = @import("./common.zig"); const testing = @import("std").testing; +const mulv = @import("mulo.zig"); +const symbol = @import("../compiler_rt.zig").symbol; + comptime { - @export(&__mulvsi3, .{ .name = "__mulvsi3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__mulvsi3, "__mulvsi3"); } pub fn __mulvsi3(a: i32, b: i32) callconv(.c) i32 { diff --git a/lib/compiler_rt/negtf2.zig b/lib/compiler_rt/negtf2.zig index ecb5cc2c90..9d981ce2ff 100644 --- a/lib/compiler_rt/negtf2.zig +++ b/lib/compiler_rt/negtf2.zig @@ -1,9 +1,10 @@ const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_ppc_abi) - @export(&__negtf2, .{ .name = "__negkf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__negtf2, .{ .name = "__negtf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__negtf2, "__negkf2"); + symbol(&__negtf2, "__negtf2"); } fn __negtf2(a: f128) callconv(.c) f128 { diff --git a/lib/compiler_rt/parity.zig b/lib/compiler_rt/parity.zig index 71d50f327b..e388169904 100644 --- a/lib/compiler_rt/parity.zig +++ b/lib/compiler_rt/parity.zig @@ -1,14 +1,11 @@ //! parity - if number of bits set is even => 0, else => 1 //! - pariytXi2_generic for big and little endian - -const std = @import("std"); -const builtin = @import("builtin"); -const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__paritysi2, .{ .name = "__paritysi2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__paritydi2, .{ .name = "__paritydi2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__parityti2, .{ .name = "__parityti2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__paritysi2, "__paritysi2"); + symbol(&__paritydi2, "__paritydi2"); + symbol(&__parityti2, "__parityti2"); } pub fn __paritysi2(a: i32) callconv(.c) i32 { @@ -24,7 +21,7 @@ pub fn __parityti2(a: i128) callconv(.c) i32 { } inline fn parityXi2(comptime T: type, a: T) i32 { - var x: std.meta.Int(.unsigned, @typeInfo(T).int.bits) = @bitCast(a); + var x: @Int(.unsigned, @typeInfo(T).int.bits) = @bitCast(a); // Bit Twiddling Hacks: Compute parity in parallel comptime var shift: u8 = @bitSizeOf(T) / 2; inline while (shift > 2) { diff --git a/lib/compiler_rt/popcount.zig b/lib/compiler_rt/popcount.zig index 12ecda16cc..b1ef500ea1 100644 --- a/lib/compiler_rt/popcount.zig +++ b/lib/compiler_rt/popcount.zig @@ -6,14 +6,12 @@ //! TAOCP: Combinational Algorithms, Bitwise Tricks And Techniques, //! subsubsection "Working with the rightmost bits" and "Sideways addition". -const builtin = @import("builtin"); -const std = @import("std"); -const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__popcountsi2, .{ .name = "__popcountsi2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__popcountdi2, .{ .name = "__popcountdi2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__popcountti2, .{ .name = "__popcountti2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__popcountsi2, "__popcountsi2"); + symbol(&__popcountdi2, "__popcountdi2"); + symbol(&__popcountti2, "__popcountti2"); } pub fn __popcountsi2(a: i32) callconv(.c) i32 { diff --git a/lib/compiler_rt/powiXf2.zig b/lib/compiler_rt/powiXf2.zig index b603998d55..91767818bd 100644 --- a/lib/compiler_rt/powiXf2.zig +++ b/lib/compiler_rt/powiXf2.zig @@ -3,18 +3,17 @@ //! Multiplication order (left-to-right or right-to-left) does not matter for //! error propagation and this method is optimized for performance, not accuracy. -const builtin = @import("builtin"); const common = @import("common.zig"); -const std = @import("std"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__powihf2, .{ .name = "__powihf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__powisf2, .{ .name = "__powisf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__powidf2, .{ .name = "__powidf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__powihf2, "__powihf2"); + symbol(&__powisf2, "__powisf2"); + symbol(&__powidf2, "__powidf2"); if (common.want_ppc_abi) - @export(&__powitf2, .{ .name = "__powikf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__powitf2, .{ .name = "__powitf2", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__powixf2, .{ .name = "__powixf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__powitf2, "__powikf2"); + symbol(&__powitf2, "__powitf2"); + symbol(&__powixf2, "__powixf2"); } inline fn powiXf2(comptime FT: type, a: FT, b: i32) FT { diff --git a/lib/compiler_rt/sin.zig b/lib/compiler_rt/sin.zig index d25c1cd23a..ab1775d7ce 100644 --- a/lib/compiler_rt/sin.zig +++ b/lib/compiler_rt/sin.zig @@ -5,27 +5,26 @@ //! https://git.musl-libc.org/cgit/musl/tree/src/math/sin.c const std = @import("std"); -const builtin = @import("builtin"); -const arch = builtin.cpu.arch; const math = std.math; const mem = std.mem; const expect = std.testing.expect; -const common = @import("common.zig"); +const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const trig = @import("trig.zig"); const rem_pio2 = @import("rem_pio2.zig").rem_pio2; const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f; comptime { - @export(&__sinh, .{ .name = "__sinh", .linkage = common.linkage, .visibility = common.visibility }); - @export(&sinf, .{ .name = "sinf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&sin, .{ .name = "sin", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__sinx, .{ .name = "__sinx", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__sinh, "__sinh"); + symbol(&sinf, "sinf"); + symbol(&sin, "sin"); + symbol(&__sinx, "__sinx"); if (common.want_ppc_abi) { - @export(&sinq, .{ .name = "sinf128", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&sinq, "sinf128"); } - @export(&sinq, .{ .name = "sinq", .linkage = common.linkage, .visibility = common.visibility }); - @export(&sinl, .{ .name = "sinl", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&sinq, "sinq"); + symbol(&sinl, "sinl"); } pub fn __sinh(x: f16) callconv(.c) f16 { diff --git a/lib/compiler_rt/strlen.zig b/lib/compiler_rt/strlen.zig deleted file mode 100644 index 01d4e760dc..0000000000 --- a/lib/compiler_rt/strlen.zig +++ /dev/null @@ -1,10 +0,0 @@ -const std = @import("std"); -const common = @import("common.zig"); - -comptime { - @export(&strlen, .{ .name = "strlen", .linkage = common.linkage, .visibility = common.visibility }); -} - -fn strlen(s: [*:0]const c_char) callconv(.c) usize { - return std.mem.len(s); -} diff --git a/lib/compiler_rt/subdf3.zig b/lib/compiler_rt/subdf3.zig index b1d7850902..3e7dcc3dd2 100644 --- a/lib/compiler_rt/subdf3.zig +++ b/lib/compiler_rt/subdf3.zig @@ -1,11 +1,12 @@ const common = @import("./common.zig"); const addf3 = @import("./addf3.zig").addf3; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_aeabi) { - @export(&__aeabi_dsub, .{ .name = "__aeabi_dsub", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_dsub, "__aeabi_dsub"); } else { - @export(&__subdf3, .{ .name = "__subdf3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__subdf3, "__subdf3"); } } diff --git a/lib/compiler_rt/subvdi3.zig b/lib/compiler_rt/subvdi3.zig index 17c893c911..62bb1b4068 100644 --- a/lib/compiler_rt/subvdi3.zig +++ b/lib/compiler_rt/subvdi3.zig @@ -1,8 +1,8 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const testing = @import("std").testing; comptime { - @export(&__subvdi3, .{ .name = "__subvdi3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__subvdi3, "__subvdi3"); } pub fn __subvdi3(a: i64, b: i64) callconv(.c) i64 { diff --git a/lib/compiler_rt/subxf3.zig b/lib/compiler_rt/subxf3.zig index d119f0bd98..1c2dcd6542 100644 --- a/lib/compiler_rt/subxf3.zig +++ b/lib/compiler_rt/subxf3.zig @@ -1,8 +1,8 @@ const std = @import("std"); -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__subxf3, .{ .name = "__subxf3", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__subxf3, "__subxf3"); } fn __subxf3(a: f80, b: f80) callconv(.c) f80 { diff --git a/lib/compiler_rt/tan.zig b/lib/compiler_rt/tan.zig index a78d7afb67..17b7f1f1e7 100644 --- a/lib/compiler_rt/tan.zig +++ b/lib/compiler_rt/tan.zig @@ -17,17 +17,18 @@ const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f; const arch = builtin.cpu.arch; const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__tanh, .{ .name = "__tanh", .linkage = common.linkage, .visibility = common.visibility }); - @export(&tanf, .{ .name = "tanf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&tan, .{ .name = "tan", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__tanx, .{ .name = "__tanx", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__tanh, "__tanh"); + symbol(&tanf, "tanf"); + symbol(&tan, "tan"); + symbol(&__tanx, "__tanx"); if (common.want_ppc_abi) { - @export(&tanq, .{ .name = "tanf128", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&tanq, "tanf128"); } - @export(&tanq, .{ .name = "tanq", .linkage = common.linkage, .visibility = common.visibility }); - @export(&tanl, .{ .name = "tanl", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&tanq, "tanq"); + symbol(&tanl, "tanl"); } pub fn __tanh(x: f16) callconv(.c) f16 { diff --git a/lib/compiler_rt/trunc.zig b/lib/compiler_rt/trunc.zig index 55468c752f..799fbc9fbb 100644 --- a/lib/compiler_rt/trunc.zig +++ b/lib/compiler_rt/trunc.zig @@ -4,24 +4,27 @@ //! https://git.musl-libc.org/cgit/musl/tree/src/math/truncf.c //! https://git.musl-libc.org/cgit/musl/tree/src/math/trunc.c -const std = @import("std"); const builtin = @import("builtin"); const arch = builtin.cpu.arch; + +const std = @import("std"); const math = std.math; const mem = std.mem; const expect = std.testing.expect; + const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__trunch, .{ .name = "__trunch", .linkage = common.linkage, .visibility = common.visibility }); - @export(&truncf, .{ .name = "truncf", .linkage = common.linkage, .visibility = common.visibility }); - @export(&trunc, .{ .name = "trunc", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__truncx, .{ .name = "__truncx", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__trunch, "__trunch"); + symbol(&truncf, "truncf"); + symbol(&trunc, "trunc"); + symbol(&__truncx, "__truncx"); if (common.want_ppc_abi) { - @export(&truncq, .{ .name = "truncf128", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&truncq, "truncf128"); } - @export(&truncq, .{ .name = "truncq", .linkage = common.linkage, .visibility = common.visibility }); - @export(&truncl, .{ .name = "truncl", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&truncq, "truncq"); + symbol(&truncl, "truncl"); } pub fn __trunch(x: f16) callconv(.c) f16 { diff --git a/lib/compiler_rt/truncdfhf2.zig b/lib/compiler_rt/truncdfhf2.zig index 4db14f0211..43ad7fb20d 100644 --- a/lib/compiler_rt/truncdfhf2.zig +++ b/lib/compiler_rt/truncdfhf2.zig @@ -1,11 +1,12 @@ const common = @import("./common.zig"); const truncf = @import("./truncf.zig").truncf; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_aeabi) { - @export(&__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_d2h, "__aeabi_d2h"); } - @export(&__truncdfhf2, .{ .name = "__truncdfhf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__truncdfhf2, "__truncdfhf2"); } pub fn __truncdfhf2(a: f64) callconv(.c) common.F16T(f64) { diff --git a/lib/compiler_rt/trunctfhf2.zig b/lib/compiler_rt/trunctfhf2.zig index f5adc918c2..bd0e7a5dc2 100644 --- a/lib/compiler_rt/trunctfhf2.zig +++ b/lib/compiler_rt/trunctfhf2.zig @@ -1,8 +1,9 @@ const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const truncf = @import("./truncf.zig").truncf; comptime { - @export(&__trunctfhf2, .{ .name = "__trunctfhf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__trunctfhf2, "__trunctfhf2"); } pub fn __trunctfhf2(a: f128) callconv(.c) common.F16T(f128) { diff --git a/lib/compiler_rt/trunctfsf2.zig b/lib/compiler_rt/trunctfsf2.zig index 17e7570c9f..bab5534bfe 100644 --- a/lib/compiler_rt/trunctfsf2.zig +++ b/lib/compiler_rt/trunctfsf2.zig @@ -1,13 +1,14 @@ const common = @import("./common.zig"); const truncf = @import("./truncf.zig").truncf; +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_ppc_abi) { - @export(&__trunctfsf2, .{ .name = "__trunckfsf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__trunctfsf2, "__trunckfsf2"); } else if (common.want_sparc_abi) { - @export(&_Qp_qtos, .{ .name = "_Qp_qtos", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&_Qp_qtos, "_Qp_qtos"); } - @export(&__trunctfsf2, .{ .name = "__trunctfsf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__trunctfsf2, "__trunctfsf2"); } pub fn __trunctfsf2(a: f128) callconv(.c) f32 { diff --git a/lib/compiler_rt/truncxfdf2.zig b/lib/compiler_rt/truncxfdf2.zig index 1d7e66c278..6140d94181 100644 --- a/lib/compiler_rt/truncxfdf2.zig +++ b/lib/compiler_rt/truncxfdf2.zig @@ -1,8 +1,8 @@ -const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const trunc_f80 = @import("./truncf.zig").trunc_f80; comptime { - @export(&__truncxfdf2, .{ .name = "__truncxfdf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__truncxfdf2, "__truncxfdf2"); } fn __truncxfdf2(a: f80) callconv(.c) f64 { diff --git a/lib/compiler_rt/truncxfhf2.zig b/lib/compiler_rt/truncxfhf2.zig index b2dd9c7468..b6abce58d5 100644 --- a/lib/compiler_rt/truncxfhf2.zig +++ b/lib/compiler_rt/truncxfhf2.zig @@ -1,8 +1,9 @@ const common = @import("./common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; const trunc_f80 = @import("./truncf.zig").trunc_f80; comptime { - @export(&__truncxfhf2, .{ .name = "__truncxfhf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__truncxfhf2, "__truncxfhf2"); } fn __truncxfhf2(a: f80) callconv(.c) common.F16T(f80) { diff --git a/lib/compiler_rt/truncxfsf2.zig b/lib/compiler_rt/truncxfsf2.zig index 9d36f7aa29..8aaf7e6906 100644 --- a/lib/compiler_rt/truncxfsf2.zig +++ b/lib/compiler_rt/truncxfsf2.zig @@ -1,8 +1,8 @@ -const common = @import("./common.zig"); const trunc_f80 = @import("./truncf.zig").trunc_f80; +const symbol = @import("../compiler_rt.zig").symbol; comptime { - @export(&__truncxfsf2, .{ .name = "__truncxfsf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__truncxfsf2, "__truncxfsf2"); } fn __truncxfsf2(a: f80) callconv(.c) f32 { diff --git a/lib/compiler_rt/udivmodei4.zig b/lib/compiler_rt/udivmodei4.zig index 0923f3f222..fd8cc6717e 100644 --- a/lib/compiler_rt/udivmodei4.zig +++ b/lib/compiler_rt/udivmodei4.zig @@ -1,18 +1,20 @@ -const std = @import("std"); const builtin = @import("builtin"); -const common = @import("common.zig"); +const endian = builtin.cpu.arch.endian(); + +const std = @import("std"); const shr = std.math.shr; const shl = std.math.shl; +const common = @import("common.zig"); +const symbol = @import("../compiler_rt.zig").symbol; + const max_limbs = std.math.divCeil(usize, 65535, 32) catch unreachable; // max supported type is u65535 comptime { - @export(&__udivei4, .{ .name = "__udivei4", .linkage = common.linkage, .visibility = common.visibility }); - @export(&__umodei4, .{ .name = "__umodei4", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__udivei4, "__udivei4"); + symbol(&__umodei4, "__umodei4"); } -const endian = builtin.cpu.arch.endian(); - /// Get the value of a limb. inline fn limb(x: []const u32, i: usize) u32 { return if (endian == .little) x[i] else x[x.len - 1 - i]; diff --git a/lib/compiler_rt/unorddf2.zig b/lib/compiler_rt/unorddf2.zig index 5b17343a51..634f14398d 100644 --- a/lib/compiler_rt/unorddf2.zig +++ b/lib/compiler_rt/unorddf2.zig @@ -1,11 +1,12 @@ const common = @import("./common.zig"); const comparef = @import("./comparef.zig"); +const symbol = @import("../compiler_rt.zig").symbol; comptime { if (common.want_aeabi) { - @export(&__aeabi_dcmpun, .{ .name = "__aeabi_dcmpun", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__aeabi_dcmpun, "__aeabi_dcmpun"); } else { - @export(&__unorddf2, .{ .name = "__unorddf2", .linkage = common.linkage, .visibility = common.visibility }); + symbol(&__unorddf2, "__unorddf2"); } }