From 80790be3094f65877231209532c04f7fdb4441a7 Mon Sep 17 00:00:00 2001 From: Jakub Konka Date: Fri, 10 Jun 2022 10:25:59 +0200 Subject: [PATCH] compiler_rt: compile each unit separately for improved archiving --- lib/compiler_rt.zig | 933 ++------------------------- lib/compiler_rt/absv.zig | 10 + lib/compiler_rt/addXf3.zig | 59 +- lib/compiler_rt/addo.zig | 10 + lib/compiler_rt/arm.zig | 72 +++ lib/compiler_rt/atomics.zig | 2 +- lib/compiler_rt/aulldiv.zig | 15 + lib/compiler_rt/bswap.zig | 9 + lib/compiler_rt/ceil.zig | 23 + lib/compiler_rt/clear_cache.zig | 9 +- lib/compiler_rt/cmp.zig | 12 + lib/compiler_rt/common.zig | 144 +++++ lib/compiler_rt/compareXf2.zig | 144 ++++- lib/compiler_rt/cos.zig | 23 + lib/compiler_rt/count0bits.zig | 15 + lib/compiler_rt/divdf3.zig | 137 +--- lib/compiler_rt/divsf3.zig | 28 +- lib/compiler_rt/divtf3.zig | 23 +- lib/compiler_rt/divti3.zig | 28 +- lib/compiler_rt/divxf3.zig | 14 +- lib/compiler_rt/emutls.zig | 14 +- lib/compiler_rt/exp.zig | 23 + lib/compiler_rt/exp2.zig | 23 + lib/compiler_rt/extendXfYf2.zig | 40 +- lib/compiler_rt/extend_f80.zig | 21 +- lib/compiler_rt/fabs.zig | 23 + lib/compiler_rt/fixXfYi.zig | 90 ++- lib/compiler_rt/floatXiYf.zig | 91 ++- lib/compiler_rt/floor.zig | 23 + lib/compiler_rt/fma.zig | 23 + lib/compiler_rt/fmax.zig | 23 + lib/compiler_rt/fmin.zig | 23 + lib/compiler_rt/fmod.zig | 26 +- lib/compiler_rt/int.zig | 35 + lib/compiler_rt/log.zig | 23 + lib/compiler_rt/log10.zig | 23 + lib/compiler_rt/log2.zig | 23 + lib/compiler_rt/modti3.zig | 29 +- lib/compiler_rt/mulXf3.zig | 28 +- lib/compiler_rt/muldi3.zig | 21 +- lib/compiler_rt/mulo.zig | 11 +- lib/compiler_rt/multi3.zig | 24 +- lib/compiler_rt/negXf2.zig | 17 + lib/compiler_rt/negXi2.zig | 9 + lib/compiler_rt/negv.zig | 11 + lib/compiler_rt/os_version_check.zig | 58 +- lib/compiler_rt/parity.zig | 9 + lib/compiler_rt/popcount.zig | 9 + lib/compiler_rt/round.zig | 23 + lib/compiler_rt/shift.zig | 38 +- lib/compiler_rt/sin.zig | 23 + lib/compiler_rt/sincos.zig | 27 +- lib/compiler_rt/sparc.zig | 34 + lib/compiler_rt/sqrt.zig | 23 + lib/compiler_rt/stack_probe.zig | 53 +- lib/compiler_rt/subo.zig | 10 + lib/compiler_rt/tan.zig | 24 + lib/compiler_rt/trunc.zig | 23 + lib/compiler_rt/truncXfYf2.zig | 44 +- lib/compiler_rt/trunc_f80.zig | 14 +- lib/compiler_rt/udivmodti4.zig | 28 +- lib/compiler_rt/udivti3.zig | 34 +- lib/compiler_rt/umodti3.zig | 33 +- src/Compilation.zig | 27 +- src/compiler_rt.zig | 186 ++++++ src/link/Coff.zig | 2 +- src/link/Elf.zig | 2 +- src/link/MachO.zig | 2 +- src/link/Wasm.zig | 2 +- src/musl.zig | 1 - 70 files changed, 2003 insertions(+), 1133 deletions(-) create mode 100644 lib/compiler_rt/common.zig create mode 100644 src/compiler_rt.zig diff --git a/lib/compiler_rt.zig b/lib/compiler_rt.zig index 563d3d0820..92d783cc25 100644 --- a/lib/compiler_rt.zig +++ b/lib/compiler_rt.zig @@ -1,542 +1,69 @@ -const std = @import("std"); const builtin = @import("builtin"); -const is_test = builtin.is_test; -const os_tag = builtin.os.tag; -const arch = builtin.cpu.arch; -const abi = builtin.abi; - -const is_gnu = abi.isGnu(); -const is_mingw = os_tag == .windows and is_gnu; -const is_darwin = std.Target.Os.Tag.isDarwin(os_tag); -const is_ppc = arch.isPPC() or arch.isPPC64(); - -const linkage = if (is_test) - std.builtin.GlobalLinkage.Internal -else - std.builtin.GlobalLinkage.Weak; - -const strong_linkage = if (is_test) - std.builtin.GlobalLinkage.Internal -else - std.builtin.GlobalLinkage.Strong; +pub const panic = @import("compiler_rt/common.zig").panic; comptime { // These files do their own comptime exporting logic. _ = @import("compiler_rt/atomics.zig"); - if (builtin.zig_backend != .stage2_llvm) { // TODO - _ = @import("compiler_rt/clear_cache.zig").clear_cache; - } - - const __extenddftf2 = @import("compiler_rt/extendXfYf2.zig").__extenddftf2; - @export(__extenddftf2, .{ .name = "__extenddftf2", .linkage = linkage }); - const __extendsftf2 = @import("compiler_rt/extendXfYf2.zig").__extendsftf2; - @export(__extendsftf2, .{ .name = "__extendsftf2", .linkage = linkage }); - const __extendhfsf2 = @import("compiler_rt/extendXfYf2.zig").__extendhfsf2; - @export(__extendhfsf2, .{ .name = "__extendhfsf2", .linkage = linkage }); - const __extendhftf2 = @import("compiler_rt/extendXfYf2.zig").__extendhftf2; - @export(__extendhftf2, .{ .name = "__extendhftf2", .linkage = linkage }); - - const __extendhfxf2 = @import("compiler_rt/extend_f80.zig").__extendhfxf2; - @export(__extendhfxf2, .{ .name = "__extendhfxf2", .linkage = linkage }); - const __extendsfxf2 = @import("compiler_rt/extend_f80.zig").__extendsfxf2; - @export(__extendsfxf2, .{ .name = "__extendsfxf2", .linkage = linkage }); - const __extenddfxf2 = @import("compiler_rt/extend_f80.zig").__extenddfxf2; - @export(__extenddfxf2, .{ .name = "__extenddfxf2", .linkage = linkage }); - const __extendxftf2 = @import("compiler_rt/extend_f80.zig").__extendxftf2; - @export(__extendxftf2, .{ .name = "__extendxftf2", .linkage = linkage }); - - const __lesf2 = @import("compiler_rt/compareXf2.zig").__lesf2; - @export(__lesf2, .{ .name = "__lesf2", .linkage = linkage }); - const __ledf2 = @import("compiler_rt/compareXf2.zig").__ledf2; - @export(__ledf2, .{ .name = "__ledf2", .linkage = linkage }); - const __letf2 = @import("compiler_rt/compareXf2.zig").__letf2; - @export(__letf2, .{ .name = "__letf2", .linkage = linkage }); - const __lexf2 = @import("compiler_rt/compareXf2.zig").__lexf2; - @export(__lexf2, .{ .name = "__lexf2", .linkage = linkage }); - - const __gesf2 = @import("compiler_rt/compareXf2.zig").__gesf2; - @export(__gesf2, .{ .name = "__gesf2", .linkage = linkage }); - const __gedf2 = @import("compiler_rt/compareXf2.zig").__gedf2; - @export(__gedf2, .{ .name = "__gedf2", .linkage = linkage }); - const __getf2 = @import("compiler_rt/compareXf2.zig").__getf2; - @export(__getf2, .{ .name = "__getf2", .linkage = linkage }); - const __gexf2 = @import("compiler_rt/compareXf2.zig").__gexf2; - @export(__gexf2, .{ .name = "__gexf2", .linkage = linkage }); - - const __eqsf2 = @import("compiler_rt/compareXf2.zig").__eqsf2; - @export(__eqsf2, .{ .name = "__eqsf2", .linkage = linkage }); - const __eqdf2 = @import("compiler_rt/compareXf2.zig").__eqdf2; - @export(__eqdf2, .{ .name = "__eqdf2", .linkage = linkage }); - const __eqxf2 = @import("compiler_rt/compareXf2.zig").__eqxf2; - @export(__eqxf2, .{ .name = "__eqxf2", .linkage = linkage }); - - const __ltsf2 = @import("compiler_rt/compareXf2.zig").__ltsf2; - @export(__ltsf2, .{ .name = "__ltsf2", .linkage = linkage }); - const __ltdf2 = @import("compiler_rt/compareXf2.zig").__ltdf2; - @export(__ltdf2, .{ .name = "__ltdf2", .linkage = linkage }); - const __ltxf2 = @import("compiler_rt/compareXf2.zig").__ltxf2; - @export(__ltxf2, .{ .name = "__ltxf2", .linkage = linkage }); - - const __nesf2 = @import("compiler_rt/compareXf2.zig").__nesf2; - @export(__nesf2, .{ .name = "__nesf2", .linkage = linkage }); - const __nedf2 = @import("compiler_rt/compareXf2.zig").__nedf2; - @export(__nedf2, .{ .name = "__nedf2", .linkage = linkage }); - const __nexf2 = @import("compiler_rt/compareXf2.zig").__nexf2; - @export(__nexf2, .{ .name = "__nexf2", .linkage = linkage }); - - const __gtsf2 = @import("compiler_rt/compareXf2.zig").__gtsf2; - @export(__gtsf2, .{ .name = "__gtsf2", .linkage = linkage }); - const __gtdf2 = @import("compiler_rt/compareXf2.zig").__gtdf2; - @export(__gtdf2, .{ .name = "__gtdf2", .linkage = linkage }); - const __gtxf2 = @import("compiler_rt/compareXf2.zig").__gtxf2; - @export(__gtxf2, .{ .name = "__gtxf2", .linkage = linkage }); - - if (!is_test) { - @export(__lesf2, .{ .name = "__cmpsf2", .linkage = linkage }); - @export(__ledf2, .{ .name = "__cmpdf2", .linkage = linkage }); - @export(__letf2, .{ .name = "__cmptf2", .linkage = linkage }); - @export(__letf2, .{ .name = "__eqtf2", .linkage = linkage }); - @export(__letf2, .{ .name = "__lttf2", .linkage = linkage }); - @export(__getf2, .{ .name = "__gttf2", .linkage = linkage }); - @export(__letf2, .{ .name = "__netf2", .linkage = linkage }); - @export(__extendhfsf2, .{ .name = "__gnu_h2f_ieee", .linkage = linkage }); - } - - if (builtin.os.tag == .windows) { - // Default stack-probe functions emitted by LLVM - if (is_mingw) { - const _chkstk = @import("compiler_rt/stack_probe.zig")._chkstk; - @export(_chkstk, .{ .name = "_alloca", .linkage = strong_linkage }); - const ___chkstk_ms = @import("compiler_rt/stack_probe.zig").___chkstk_ms; - @export(___chkstk_ms, .{ .name = "___chkstk_ms", .linkage = strong_linkage }); - } else if (!builtin.link_libc) { - // This symbols are otherwise exported by MSVCRT.lib - const _chkstk = @import("compiler_rt/stack_probe.zig")._chkstk; - @export(_chkstk, .{ .name = "_chkstk", .linkage = strong_linkage }); - const __chkstk = @import("compiler_rt/stack_probe.zig").__chkstk; - @export(__chkstk, .{ .name = "__chkstk", .linkage = strong_linkage }); - } - - switch (arch) { - .i386 => { - const __divti3 = @import("compiler_rt/divti3.zig").__divti3; - @export(__divti3, .{ .name = "__divti3", .linkage = linkage }); - const __modti3 = @import("compiler_rt/modti3.zig").__modti3; - @export(__modti3, .{ .name = "__modti3", .linkage = linkage }); - const __multi3 = @import("compiler_rt/multi3.zig").__multi3; - @export(__multi3, .{ .name = "__multi3", .linkage = linkage }); - const __udivti3 = @import("compiler_rt/udivti3.zig").__udivti3; - @export(__udivti3, .{ .name = "__udivti3", .linkage = linkage }); - const __udivmodti4 = @import("compiler_rt/udivmodti4.zig").__udivmodti4; - @export(__udivmodti4, .{ .name = "__udivmodti4", .linkage = linkage }); - const __umodti3 = @import("compiler_rt/umodti3.zig").__umodti3; - @export(__umodti3, .{ .name = "__umodti3", .linkage = linkage }); - }, - .x86_64 => { - // The "ti" functions must use Vector(2, u64) parameter types to adhere to the ABI - // that LLVM expects compiler-rt to have. - const __divti3_windows_x86_64 = @import("compiler_rt/divti3.zig").__divti3_windows_x86_64; - @export(__divti3_windows_x86_64, .{ .name = "__divti3", .linkage = linkage }); - const __modti3_windows_x86_64 = @import("compiler_rt/modti3.zig").__modti3_windows_x86_64; - @export(__modti3_windows_x86_64, .{ .name = "__modti3", .linkage = linkage }); - const __multi3_windows_x86_64 = @import("compiler_rt/multi3.zig").__multi3_windows_x86_64; - @export(__multi3_windows_x86_64, .{ .name = "__multi3", .linkage = linkage }); - const __udivti3_windows_x86_64 = @import("compiler_rt/udivti3.zig").__udivti3_windows_x86_64; - @export(__udivti3_windows_x86_64, .{ .name = "__udivti3", .linkage = linkage }); - const __udivmodti4_windows_x86_64 = @import("compiler_rt/udivmodti4.zig").__udivmodti4_windows_x86_64; - @export(__udivmodti4_windows_x86_64, .{ .name = "__udivmodti4", .linkage = linkage }); - const __umodti3_windows_x86_64 = @import("compiler_rt/umodti3.zig").__umodti3_windows_x86_64; - @export(__umodti3_windows_x86_64, .{ .name = "__umodti3", .linkage = linkage }); - }, - else => {}, - } - if (arch.isAARCH64()) { - const __chkstk = @import("compiler_rt/stack_probe.zig").__chkstk; - @export(__chkstk, .{ .name = "__chkstk", .linkage = strong_linkage }); - const __divti3_windows = @import("compiler_rt/divti3.zig").__divti3; - @export(__divti3_windows, .{ .name = "__divti3", .linkage = linkage }); - const __modti3 = @import("compiler_rt/modti3.zig").__modti3; - @export(__modti3, .{ .name = "__modti3", .linkage = linkage }); - const __udivti3_windows = @import("compiler_rt/udivti3.zig").__udivti3; - @export(__udivti3_windows, .{ .name = "__udivti3", .linkage = linkage }); - const __umodti3 = @import("compiler_rt/umodti3.zig").__umodti3; - @export(__umodti3, .{ .name = "__umodti3", .linkage = linkage }); - } - } else { - const __divti3 = @import("compiler_rt/divti3.zig").__divti3; - @export(__divti3, .{ .name = "__divti3", .linkage = linkage }); - const __modti3 = @import("compiler_rt/modti3.zig").__modti3; - @export(__modti3, .{ .name = "__modti3", .linkage = linkage }); - const __multi3 = @import("compiler_rt/multi3.zig").__multi3; - @export(__multi3, .{ .name = "__multi3", .linkage = linkage }); - const __udivti3 = @import("compiler_rt/udivti3.zig").__udivti3; - @export(__udivti3, .{ .name = "__udivti3", .linkage = linkage }); - const __udivmodti4 = @import("compiler_rt/udivmodti4.zig").__udivmodti4; - @export(__udivmodti4, .{ .name = "__udivmodti4", .linkage = linkage }); - const __umodti3 = @import("compiler_rt/umodti3.zig").__umodti3; - @export(__umodti3, .{ .name = "__umodti3", .linkage = linkage }); - } - - const __truncdfhf2 = @import("compiler_rt/truncXfYf2.zig").__truncdfhf2; - @export(__truncdfhf2, .{ .name = "__truncdfhf2", .linkage = linkage }); - const __trunctfhf2 = @import("compiler_rt/truncXfYf2.zig").__trunctfhf2; - @export(__trunctfhf2, .{ .name = "__trunctfhf2", .linkage = linkage }); - const __trunctfdf2 = @import("compiler_rt/truncXfYf2.zig").__trunctfdf2; - @export(__trunctfdf2, .{ .name = "__trunctfdf2", .linkage = linkage }); - const __trunctfsf2 = @import("compiler_rt/truncXfYf2.zig").__trunctfsf2; - @export(__trunctfsf2, .{ .name = "__trunctfsf2", .linkage = linkage }); - - const __truncdfsf2 = @import("compiler_rt/truncXfYf2.zig").__truncdfsf2; - @export(__truncdfsf2, .{ .name = "__truncdfsf2", .linkage = linkage }); - - const __truncxfhf2 = @import("compiler_rt/trunc_f80.zig").__truncxfhf2; - @export(__truncxfhf2, .{ .name = "__truncxfhf2", .linkage = linkage }); - const __truncxfsf2 = @import("compiler_rt/trunc_f80.zig").__truncxfsf2; - @export(__truncxfsf2, .{ .name = "__truncxfsf2", .linkage = linkage }); - const __truncxfdf2 = @import("compiler_rt/trunc_f80.zig").__truncxfdf2; - @export(__truncxfdf2, .{ .name = "__truncxfdf2", .linkage = linkage }); - const __trunctfxf2 = @import("compiler_rt/trunc_f80.zig").__trunctfxf2; - @export(__trunctfxf2, .{ .name = "__trunctfxf2", .linkage = linkage }); - - switch (arch) { - .i386, - .x86_64, - => { - const zig_probe_stack = @import("compiler_rt/stack_probe.zig").zig_probe_stack; - @export(zig_probe_stack, .{ - .name = "__zig_probe_stack", - .linkage = linkage, - }); - }, - else => {}, - } - - const __unordsf2 = @import("compiler_rt/compareXf2.zig").__unordsf2; - @export(__unordsf2, .{ .name = "__unordsf2", .linkage = linkage }); - const __unorddf2 = @import("compiler_rt/compareXf2.zig").__unorddf2; - @export(__unorddf2, .{ .name = "__unorddf2", .linkage = linkage }); - const __unordtf2 = @import("compiler_rt/compareXf2.zig").__unordtf2; - @export(__unordtf2, .{ .name = "__unordtf2", .linkage = linkage }); - - const __addsf3 = @import("compiler_rt/addXf3.zig").__addsf3; - @export(__addsf3, .{ .name = "__addsf3", .linkage = linkage }); - const __adddf3 = @import("compiler_rt/addXf3.zig").__adddf3; - @export(__adddf3, .{ .name = "__adddf3", .linkage = linkage }); - const __addxf3 = @import("compiler_rt/addXf3.zig").__addxf3; - @export(__addxf3, .{ .name = "__addxf3", .linkage = linkage }); - const __addtf3 = @import("compiler_rt/addXf3.zig").__addtf3; - @export(__addtf3, .{ .name = "__addtf3", .linkage = linkage }); - - const __subsf3 = @import("compiler_rt/addXf3.zig").__subsf3; - @export(__subsf3, .{ .name = "__subsf3", .linkage = linkage }); - const __subdf3 = @import("compiler_rt/addXf3.zig").__subdf3; - @export(__subdf3, .{ .name = "__subdf3", .linkage = linkage }); - const __subxf3 = @import("compiler_rt/addXf3.zig").__subxf3; - @export(__subxf3, .{ .name = "__subxf3", .linkage = linkage }); - const __subtf3 = @import("compiler_rt/addXf3.zig").__subtf3; - @export(__subtf3, .{ .name = "__subtf3", .linkage = linkage }); - - const __mulsf3 = @import("compiler_rt/mulXf3.zig").__mulsf3; - @export(__mulsf3, .{ .name = "__mulsf3", .linkage = linkage }); - const __muldf3 = @import("compiler_rt/mulXf3.zig").__muldf3; - @export(__muldf3, .{ .name = "__muldf3", .linkage = linkage }); - const __mulxf3 = @import("compiler_rt/mulXf3.zig").__mulxf3; - @export(__mulxf3, .{ .name = "__mulxf3", .linkage = linkage }); - const __multf3 = @import("compiler_rt/mulXf3.zig").__multf3; - @export(__multf3, .{ .name = "__multf3", .linkage = linkage }); - - const __divsf3 = @import("compiler_rt/divsf3.zig").__divsf3; - @export(__divsf3, .{ .name = "__divsf3", .linkage = linkage }); - const __divdf3 = @import("compiler_rt/divdf3.zig").__divdf3; - @export(__divdf3, .{ .name = "__divdf3", .linkage = linkage }); - const __divxf3 = @import("compiler_rt/divxf3.zig").__divxf3; - @export(__divxf3, .{ .name = "__divxf3", .linkage = linkage }); - const __divtf3 = @import("compiler_rt/divtf3.zig").__divtf3; - @export(__divtf3, .{ .name = "__divtf3", .linkage = linkage }); - - // Integer Bit operations - const __clzsi2 = @import("compiler_rt/count0bits.zig").__clzsi2; - @export(__clzsi2, .{ .name = "__clzsi2", .linkage = linkage }); - const __clzdi2 = @import("compiler_rt/count0bits.zig").__clzdi2; - @export(__clzdi2, .{ .name = "__clzdi2", .linkage = linkage }); - const __clzti2 = @import("compiler_rt/count0bits.zig").__clzti2; - @export(__clzti2, .{ .name = "__clzti2", .linkage = linkage }); - const __ctzsi2 = @import("compiler_rt/count0bits.zig").__ctzsi2; - @export(__ctzsi2, .{ .name = "__ctzsi2", .linkage = linkage }); - const __ctzdi2 = @import("compiler_rt/count0bits.zig").__ctzdi2; - @export(__ctzdi2, .{ .name = "__ctzdi2", .linkage = linkage }); - const __ctzti2 = @import("compiler_rt/count0bits.zig").__ctzti2; - @export(__ctzti2, .{ .name = "__ctzti2", .linkage = linkage }); - const __ffssi2 = @import("compiler_rt/count0bits.zig").__ffssi2; - @export(__ffssi2, .{ .name = "__ffssi2", .linkage = linkage }); - const __ffsdi2 = @import("compiler_rt/count0bits.zig").__ffsdi2; - @export(__ffsdi2, .{ .name = "__ffsdi2", .linkage = linkage }); - const __ffsti2 = @import("compiler_rt/count0bits.zig").__ffsti2; - @export(__ffsti2, .{ .name = "__ffsti2", .linkage = linkage }); - const __paritysi2 = @import("compiler_rt/parity.zig").__paritysi2; - @export(__paritysi2, .{ .name = "__paritysi2", .linkage = linkage }); - const __paritydi2 = @import("compiler_rt/parity.zig").__paritydi2; - @export(__paritydi2, .{ .name = "__paritydi2", .linkage = linkage }); - const __parityti2 = @import("compiler_rt/parity.zig").__parityti2; - @export(__parityti2, .{ .name = "__parityti2", .linkage = linkage }); - const __popcountsi2 = @import("compiler_rt/popcount.zig").__popcountsi2; - @export(__popcountsi2, .{ .name = "__popcountsi2", .linkage = linkage }); - const __popcountdi2 = @import("compiler_rt/popcount.zig").__popcountdi2; - @export(__popcountdi2, .{ .name = "__popcountdi2", .linkage = linkage }); - const __popcountti2 = @import("compiler_rt/popcount.zig").__popcountti2; - @export(__popcountti2, .{ .name = "__popcountti2", .linkage = linkage }); - const __bswapsi2 = @import("compiler_rt/bswap.zig").__bswapsi2; - @export(__bswapsi2, .{ .name = "__bswapsi2", .linkage = linkage }); - const __bswapdi2 = @import("compiler_rt/bswap.zig").__bswapdi2; - @export(__bswapdi2, .{ .name = "__bswapdi2", .linkage = linkage }); - const __bswapti2 = @import("compiler_rt/bswap.zig").__bswapti2; - @export(__bswapti2, .{ .name = "__bswapti2", .linkage = linkage }); - - // Integral -> Float Conversion - - // Conversion to f32 - const __floatsisf = @import("compiler_rt/floatXiYf.zig").__floatsisf; - @export(__floatsisf, .{ .name = "__floatsisf", .linkage = linkage }); - const __floatunsisf = @import("compiler_rt/floatXiYf.zig").__floatunsisf; - @export(__floatunsisf, .{ .name = "__floatunsisf", .linkage = linkage }); - - const __floatundisf = @import("compiler_rt/floatXiYf.zig").__floatundisf; - @export(__floatundisf, .{ .name = "__floatundisf", .linkage = linkage }); - const __floatdisf = @import("compiler_rt/floatXiYf.zig").__floatdisf; - @export(__floatdisf, .{ .name = "__floatdisf", .linkage = linkage }); - - const __floattisf = @import("compiler_rt/floatXiYf.zig").__floattisf; - @export(__floattisf, .{ .name = "__floattisf", .linkage = linkage }); - const __floatuntisf = @import("compiler_rt/floatXiYf.zig").__floatuntisf; - @export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = linkage }); - - // Conversion to f64 - const __floatsidf = @import("compiler_rt/floatXiYf.zig").__floatsidf; - @export(__floatsidf, .{ .name = "__floatsidf", .linkage = linkage }); - const __floatunsidf = @import("compiler_rt/floatXiYf.zig").__floatunsidf; - @export(__floatunsidf, .{ .name = "__floatunsidf", .linkage = linkage }); - - const __floatdidf = @import("compiler_rt/floatXiYf.zig").__floatdidf; - @export(__floatdidf, .{ .name = "__floatdidf", .linkage = linkage }); - const __floatundidf = @import("compiler_rt/floatXiYf.zig").__floatundidf; - @export(__floatundidf, .{ .name = "__floatundidf", .linkage = linkage }); - - const __floattidf = @import("compiler_rt/floatXiYf.zig").__floattidf; - @export(__floattidf, .{ .name = "__floattidf", .linkage = linkage }); - const __floatuntidf = @import("compiler_rt/floatXiYf.zig").__floatuntidf; - @export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = linkage }); - - // Conversion to f80 - const __floatsixf = @import("compiler_rt/floatXiYf.zig").__floatsixf; - @export(__floatsixf, .{ .name = "__floatsixf", .linkage = linkage }); - const __floatunsixf = @import("compiler_rt/floatXiYf.zig").__floatunsixf; - @export(__floatunsixf, .{ .name = "__floatunsixf", .linkage = linkage }); - - const __floatdixf = @import("compiler_rt/floatXiYf.zig").__floatdixf; - @export(__floatdixf, .{ .name = "__floatdixf", .linkage = linkage }); - const __floatundixf = @import("compiler_rt/floatXiYf.zig").__floatundixf; - @export(__floatundixf, .{ .name = "__floatundixf", .linkage = linkage }); - - const __floattixf = @import("compiler_rt/floatXiYf.zig").__floattixf; - @export(__floattixf, .{ .name = "__floattixf", .linkage = linkage }); - const __floatuntixf = @import("compiler_rt/floatXiYf.zig").__floatuntixf; - @export(__floatuntixf, .{ .name = "__floatuntixf", .linkage = linkage }); - - // Conversion to f128 - const __floatsitf = @import("compiler_rt/floatXiYf.zig").__floatsitf; - @export(__floatsitf, .{ .name = "__floatsitf", .linkage = linkage }); - const __floatunsitf = @import("compiler_rt/floatXiYf.zig").__floatunsitf; - @export(__floatunsitf, .{ .name = "__floatunsitf", .linkage = linkage }); - - const __floatditf = @import("compiler_rt/floatXiYf.zig").__floatditf; - @export(__floatditf, .{ .name = "__floatditf", .linkage = linkage }); - const __floatunditf = @import("compiler_rt/floatXiYf.zig").__floatunditf; - @export(__floatunditf, .{ .name = "__floatunditf", .linkage = linkage }); - - const __floattitf = @import("compiler_rt/floatXiYf.zig").__floattitf; - @export(__floattitf, .{ .name = "__floattitf", .linkage = linkage }); - const __floatuntitf = @import("compiler_rt/floatXiYf.zig").__floatuntitf; - @export(__floatuntitf, .{ .name = "__floatuntitf", .linkage = linkage }); - - // Float -> Integral Conversion - - // Conversion from f32 - const __fixsfsi = @import("compiler_rt/fixXfYi.zig").__fixsfsi; - @export(__fixsfsi, .{ .name = "__fixsfsi", .linkage = linkage }); - const __fixunssfsi = @import("compiler_rt/fixXfYi.zig").__fixunssfsi; - @export(__fixunssfsi, .{ .name = "__fixunssfsi", .linkage = linkage }); - - const __fixsfdi = @import("compiler_rt/fixXfYi.zig").__fixsfdi; - @export(__fixsfdi, .{ .name = "__fixsfdi", .linkage = linkage }); - const __fixunssfdi = @import("compiler_rt/fixXfYi.zig").__fixunssfdi; - @export(__fixunssfdi, .{ .name = "__fixunssfdi", .linkage = linkage }); - - const __fixsfti = @import("compiler_rt/fixXfYi.zig").__fixsfti; - @export(__fixsfti, .{ .name = "__fixsfti", .linkage = linkage }); - const __fixunssfti = @import("compiler_rt/fixXfYi.zig").__fixunssfti; - @export(__fixunssfti, .{ .name = "__fixunssfti", .linkage = linkage }); - - // Conversion from f64 - const __fixdfsi = @import("compiler_rt/fixXfYi.zig").__fixdfsi; - @export(__fixdfsi, .{ .name = "__fixdfsi", .linkage = linkage }); - const __fixunsdfsi = @import("compiler_rt/fixXfYi.zig").__fixunsdfsi; - @export(__fixunsdfsi, .{ .name = "__fixunsdfsi", .linkage = linkage }); - - const __fixdfdi = @import("compiler_rt/fixXfYi.zig").__fixdfdi; - @export(__fixdfdi, .{ .name = "__fixdfdi", .linkage = linkage }); - const __fixunsdfdi = @import("compiler_rt/fixXfYi.zig").__fixunsdfdi; - @export(__fixunsdfdi, .{ .name = "__fixunsdfdi", .linkage = linkage }); - - const __fixdfti = @import("compiler_rt/fixXfYi.zig").__fixdfti; - @export(__fixdfti, .{ .name = "__fixdfti", .linkage = linkage }); - const __fixunsdfti = @import("compiler_rt/fixXfYi.zig").__fixunsdfti; - @export(__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = linkage }); - - // Conversion from f80 - const __fixxfsi = @import("compiler_rt/fixXfYi.zig").__fixxfsi; - @export(__fixxfsi, .{ .name = "__fixxfsi", .linkage = linkage }); - const __fixunsxfsi = @import("compiler_rt/fixXfYi.zig").__fixunsxfsi; - @export(__fixunsxfsi, .{ .name = "__fixunsxfsi", .linkage = linkage }); - - const __fixxfdi = @import("compiler_rt/fixXfYi.zig").__fixxfdi; - @export(__fixxfdi, .{ .name = "__fixxfdi", .linkage = linkage }); - const __fixunsxfdi = @import("compiler_rt/fixXfYi.zig").__fixunsxfdi; - @export(__fixunsxfdi, .{ .name = "__fixunsxfdi", .linkage = linkage }); - - const __fixxfti = @import("compiler_rt/fixXfYi.zig").__fixxfti; - @export(__fixxfti, .{ .name = "__fixxfti", .linkage = linkage }); - const __fixunsxfti = @import("compiler_rt/fixXfYi.zig").__fixunsxfti; - @export(__fixunsxfti, .{ .name = "__fixunsxfti", .linkage = linkage }); - - // Conversion from f128 - const __fixtfsi = @import("compiler_rt/fixXfYi.zig").__fixtfsi; - @export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = linkage }); - const __fixunstfsi = @import("compiler_rt/fixXfYi.zig").__fixunstfsi; - @export(__fixunstfsi, .{ .name = "__fixunstfsi", .linkage = linkage }); - - const __fixtfdi = @import("compiler_rt/fixXfYi.zig").__fixtfdi; - @export(__fixtfdi, .{ .name = "__fixtfdi", .linkage = linkage }); - const __fixunstfdi = @import("compiler_rt/fixXfYi.zig").__fixunstfdi; - @export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = linkage }); - - const __fixtfti = @import("compiler_rt/fixXfYi.zig").__fixtfti; - @export(__fixtfti, .{ .name = "__fixtfti", .linkage = linkage }); - const __fixunstfti = @import("compiler_rt/fixXfYi.zig").__fixunstfti; - @export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = linkage }); - - const __udivmoddi4 = @import("compiler_rt/int.zig").__udivmoddi4; - @export(__udivmoddi4, .{ .name = "__udivmoddi4", .linkage = linkage }); - - const __truncsfhf2 = @import("compiler_rt/truncXfYf2.zig").__truncsfhf2; - @export(__truncsfhf2, .{ .name = "__truncsfhf2", .linkage = linkage }); - if (!is_test) { - @export(__truncsfhf2, .{ .name = "__gnu_f2h_ieee", .linkage = linkage }); - } - const __extendsfdf2 = @import("compiler_rt/extendXfYf2.zig").__extendsfdf2; - @export(__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = linkage }); - - if (is_darwin) { - const __isPlatformVersionAtLeast = @import("compiler_rt/os_version_check.zig").__isPlatformVersionAtLeast; - @export(__isPlatformVersionAtLeast, .{ .name = "__isPlatformVersionAtLeast", .linkage = linkage }); - } - - // Integer Arithmetic - const __ashldi3 = @import("compiler_rt/shift.zig").__ashldi3; - @export(__ashldi3, .{ .name = "__ashldi3", .linkage = linkage }); - const __ashlti3 = @import("compiler_rt/shift.zig").__ashlti3; - @export(__ashlti3, .{ .name = "__ashlti3", .linkage = linkage }); - const __ashrdi3 = @import("compiler_rt/shift.zig").__ashrdi3; - @export(__ashrdi3, .{ .name = "__ashrdi3", .linkage = linkage }); - const __ashrti3 = @import("compiler_rt/shift.zig").__ashrti3; - @export(__ashrti3, .{ .name = "__ashrti3", .linkage = linkage }); - const __lshrdi3 = @import("compiler_rt/shift.zig").__lshrdi3; - @export(__lshrdi3, .{ .name = "__lshrdi3", .linkage = linkage }); - const __lshrti3 = @import("compiler_rt/shift.zig").__lshrti3; - @export(__lshrti3, .{ .name = "__lshrti3", .linkage = linkage }); - const __negsi2 = @import("compiler_rt/negXi2.zig").__negsi2; - @export(__negsi2, .{ .name = "__negsi2", .linkage = linkage }); - const __negdi2 = @import("compiler_rt/negXi2.zig").__negdi2; - @export(__negdi2, .{ .name = "__negdi2", .linkage = linkage }); - const __negti2 = @import("compiler_rt/negXi2.zig").__negti2; - @export(__negti2, .{ .name = "__negti2", .linkage = linkage }); - - const __mulsi3 = @import("compiler_rt/int.zig").__mulsi3; - @export(__mulsi3, .{ .name = "__mulsi3", .linkage = linkage }); - const __muldi3 = @import("compiler_rt/muldi3.zig").__muldi3; - @export(__muldi3, .{ .name = "__muldi3", .linkage = linkage }); - const __divmoddi4 = @import("compiler_rt/int.zig").__divmoddi4; - @export(__divmoddi4, .{ .name = "__divmoddi4", .linkage = linkage }); - const __divsi3 = @import("compiler_rt/int.zig").__divsi3; - @export(__divsi3, .{ .name = "__divsi3", .linkage = linkage }); - const __divdi3 = @import("compiler_rt/int.zig").__divdi3; - @export(__divdi3, .{ .name = "__divdi3", .linkage = linkage }); - const __udivsi3 = @import("compiler_rt/int.zig").__udivsi3; - @export(__udivsi3, .{ .name = "__udivsi3", .linkage = linkage }); - const __udivdi3 = @import("compiler_rt/int.zig").__udivdi3; - @export(__udivdi3, .{ .name = "__udivdi3", .linkage = linkage }); - const __modsi3 = @import("compiler_rt/int.zig").__modsi3; - @export(__modsi3, .{ .name = "__modsi3", .linkage = linkage }); - const __moddi3 = @import("compiler_rt/int.zig").__moddi3; - @export(__moddi3, .{ .name = "__moddi3", .linkage = linkage }); - const __umodsi3 = @import("compiler_rt/int.zig").__umodsi3; - @export(__umodsi3, .{ .name = "__umodsi3", .linkage = linkage }); - const __umoddi3 = @import("compiler_rt/int.zig").__umoddi3; - @export(__umoddi3, .{ .name = "__umoddi3", .linkage = linkage }); - const __divmodsi4 = @import("compiler_rt/int.zig").__divmodsi4; - @export(__divmodsi4, .{ .name = "__divmodsi4", .linkage = linkage }); - const __udivmodsi4 = @import("compiler_rt/int.zig").__udivmodsi4; - @export(__udivmodsi4, .{ .name = "__udivmodsi4", .linkage = linkage }); - - // Integer Arithmetic with trapping overflow - const __absvsi2 = @import("compiler_rt/absv.zig").__absvsi2; - @export(__absvsi2, .{ .name = "__absvsi2", .linkage = linkage }); - const __absvdi2 = @import("compiler_rt/absv.zig").__absvdi2; - @export(__absvdi2, .{ .name = "__absvdi2", .linkage = linkage }); - const __absvti2 = @import("compiler_rt/absv.zig").__absvti2; - @export(__absvti2, .{ .name = "__absvti2", .linkage = linkage }); - const __negvsi2 = @import("compiler_rt/negv.zig").__negvsi2; - @export(__negvsi2, .{ .name = "__negvsi2", .linkage = linkage }); - const __negvdi2 = @import("compiler_rt/negv.zig").__negvdi2; - @export(__negvdi2, .{ .name = "__negvdi2", .linkage = linkage }); - const __negvti2 = @import("compiler_rt/negv.zig").__negvti2; - @export(__negvti2, .{ .name = "__negvti2", .linkage = linkage }); - - // Integer arithmetic which returns if overflow - const __addosi4 = @import("compiler_rt/addo.zig").__addosi4; - @export(__addosi4, .{ .name = "__addosi4", .linkage = linkage }); - const __addodi4 = @import("compiler_rt/addo.zig").__addodi4; - @export(__addodi4, .{ .name = "__addodi4", .linkage = linkage }); - const __addoti4 = @import("compiler_rt/addo.zig").__addoti4; - @export(__addoti4, .{ .name = "__addoti4", .linkage = linkage }); - const __subosi4 = @import("compiler_rt/subo.zig").__subosi4; - @export(__subosi4, .{ .name = "__subosi4", .linkage = linkage }); - const __subodi4 = @import("compiler_rt/subo.zig").__subodi4; - @export(__subodi4, .{ .name = "__subodi4", .linkage = linkage }); - const __suboti4 = @import("compiler_rt/subo.zig").__suboti4; - @export(__suboti4, .{ .name = "__suboti4", .linkage = linkage }); - const __mulosi4 = @import("compiler_rt/mulo.zig").__mulosi4; - @export(__mulosi4, .{ .name = "__mulosi4", .linkage = linkage }); - const __mulodi4 = @import("compiler_rt/mulo.zig").__mulodi4; - @export(__mulodi4, .{ .name = "__mulodi4", .linkage = linkage }); - const __muloti4 = @import("compiler_rt/mulo.zig").__muloti4; - @export(__muloti4, .{ .name = "__muloti4", .linkage = linkage }); - - // Integer Comparison - // (a < b) => 0 - // (a == b) => 1 - // (a > b) => 2 - const __cmpsi2 = @import("compiler_rt/cmp.zig").__cmpsi2; - @export(__cmpsi2, .{ .name = "__cmpsi2", .linkage = linkage }); - const __cmpdi2 = @import("compiler_rt/cmp.zig").__cmpdi2; - @export(__cmpdi2, .{ .name = "__cmpdi2", .linkage = linkage }); - const __cmpti2 = @import("compiler_rt/cmp.zig").__cmpti2; - @export(__cmpti2, .{ .name = "__cmpti2", .linkage = linkage }); - const __ucmpsi2 = @import("compiler_rt/cmp.zig").__ucmpsi2; - @export(__ucmpsi2, .{ .name = "__ucmpsi2", .linkage = linkage }); - const __ucmpdi2 = @import("compiler_rt/cmp.zig").__ucmpdi2; - @export(__ucmpdi2, .{ .name = "__ucmpdi2", .linkage = linkage }); - const __ucmpti2 = @import("compiler_rt/cmp.zig").__ucmpti2; - @export(__ucmpti2, .{ .name = "__ucmpti2", .linkage = linkage }); + _ = @import("compiler_rt/sin.zig"); + _ = @import("compiler_rt/cos.zig"); + _ = @import("compiler_rt/sincos.zig"); + _ = @import("compiler_rt/ceil.zig"); + _ = @import("compiler_rt/exp.zig"); + _ = @import("compiler_rt/exp2.zig"); + _ = @import("compiler_rt/fabs.zig"); + _ = @import("compiler_rt/floor.zig"); + _ = @import("compiler_rt/fma.zig"); + _ = @import("compiler_rt/fmax.zig"); + _ = @import("compiler_rt/fmin.zig"); + _ = @import("compiler_rt/fmod.zig"); + _ = @import("compiler_rt/log.zig"); + _ = @import("compiler_rt/log10.zig"); + _ = @import("compiler_rt/log2.zig"); + _ = @import("compiler_rt/round.zig"); + _ = @import("compiler_rt/sqrt.zig"); + _ = @import("compiler_rt/tan.zig"); + _ = @import("compiler_rt/trunc.zig"); + _ = @import("compiler_rt/extendXfYf2.zig"); + _ = @import("compiler_rt/extend_f80.zig"); + _ = @import("compiler_rt/compareXf2.zig"); + _ = @import("compiler_rt/stack_probe.zig"); + _ = @import("compiler_rt/divti3.zig"); + _ = @import("compiler_rt/modti3.zig"); + _ = @import("compiler_rt/multi3.zig"); + _ = @import("compiler_rt/udivti3.zig"); + _ = @import("compiler_rt/udivmodti4.zig"); + _ = @import("compiler_rt/umodti3.zig"); + _ = @import("compiler_rt/truncXfYf2.zig"); + _ = @import("compiler_rt/trunc_f80.zig"); + _ = @import("compiler_rt/addXf3.zig"); + _ = @import("compiler_rt/mulXf3.zig"); + _ = @import("compiler_rt/divsf3.zig"); + _ = @import("compiler_rt/divdf3.zig"); + _ = @import("compiler_rt/divxf3.zig"); + _ = @import("compiler_rt/divtf3.zig"); + _ = @import("compiler_rt/floatXiYf.zig"); + _ = @import("compiler_rt/fixXfYi.zig"); + _ = @import("compiler_rt/count0bits.zig"); + _ = @import("compiler_rt/parity.zig"); + _ = @import("compiler_rt/popcount.zig"); + _ = @import("compiler_rt/bswap.zig"); + _ = @import("compiler_rt/int.zig"); + _ = @import("compiler_rt/shift.zig"); + _ = @import("compiler_rt/negXi2.zig"); + _ = @import("compiler_rt/muldi3.zig"); + _ = @import("compiler_rt/absv.zig"); + _ = @import("compiler_rt/negv.zig"); + _ = @import("compiler_rt/addo.zig"); + _ = @import("compiler_rt/subo.zig"); + _ = @import("compiler_rt/mulo.zig"); + _ = @import("compiler_rt/cmp.zig"); + _ = @import("compiler_rt/negXf2.zig"); + _ = @import("compiler_rt/os_version_check.zig"); + _ = @import("compiler_rt/emutls.zig"); + _ = @import("compiler_rt/arm.zig"); + _ = @import("compiler_rt/aulldiv.zig"); + _ = @import("compiler_rt/sparc.zig"); + _ = @import("compiler_rt/clear_cache.zig"); // missing: Floating point raised to integer power @@ -544,342 +71,4 @@ comptime { // (a + ib) * (c + id) // (a + ib) / (c + id) - const __negsf2 = @import("compiler_rt/negXf2.zig").__negsf2; - @export(__negsf2, .{ .name = "__negsf2", .linkage = linkage }); - const __negdf2 = @import("compiler_rt/negXf2.zig").__negdf2; - @export(__negdf2, .{ .name = "__negdf2", .linkage = linkage }); - - if (builtin.link_libc and os_tag == .openbsd) { - const __emutls_get_address = @import("compiler_rt/emutls.zig").__emutls_get_address; - @export(__emutls_get_address, .{ .name = "__emutls_get_address", .linkage = linkage }); - } - - if ((arch.isARM() or arch.isThumb()) and !is_test) { - const __aeabi_unwind_cpp_pr0 = @import("compiler_rt/arm.zig").__aeabi_unwind_cpp_pr0; - @export(__aeabi_unwind_cpp_pr0, .{ .name = "__aeabi_unwind_cpp_pr0", .linkage = linkage }); - const __aeabi_unwind_cpp_pr1 = @import("compiler_rt/arm.zig").__aeabi_unwind_cpp_pr1; - @export(__aeabi_unwind_cpp_pr1, .{ .name = "__aeabi_unwind_cpp_pr1", .linkage = linkage }); - const __aeabi_unwind_cpp_pr2 = @import("compiler_rt/arm.zig").__aeabi_unwind_cpp_pr2; - @export(__aeabi_unwind_cpp_pr2, .{ .name = "__aeabi_unwind_cpp_pr2", .linkage = linkage }); - - @export(__muldi3, .{ .name = "__aeabi_lmul", .linkage = linkage }); - - const __aeabi_ldivmod = @import("compiler_rt/arm.zig").__aeabi_ldivmod; - @export(__aeabi_ldivmod, .{ .name = "__aeabi_ldivmod", .linkage = linkage }); - const __aeabi_uldivmod = @import("compiler_rt/arm.zig").__aeabi_uldivmod; - @export(__aeabi_uldivmod, .{ .name = "__aeabi_uldivmod", .linkage = linkage }); - - @export(__divsi3, .{ .name = "__aeabi_idiv", .linkage = linkage }); - const __aeabi_idivmod = @import("compiler_rt/arm.zig").__aeabi_idivmod; - @export(__aeabi_idivmod, .{ .name = "__aeabi_idivmod", .linkage = linkage }); - @export(__udivsi3, .{ .name = "__aeabi_uidiv", .linkage = linkage }); - const __aeabi_uidivmod = @import("compiler_rt/arm.zig").__aeabi_uidivmod; - @export(__aeabi_uidivmod, .{ .name = "__aeabi_uidivmod", .linkage = linkage }); - - const __aeabi_memcpy = @import("compiler_rt/arm.zig").__aeabi_memcpy; - @export(__aeabi_memcpy, .{ .name = "__aeabi_memcpy", .linkage = linkage }); - @export(__aeabi_memcpy, .{ .name = "__aeabi_memcpy4", .linkage = linkage }); - @export(__aeabi_memcpy, .{ .name = "__aeabi_memcpy8", .linkage = linkage }); - - const __aeabi_memmove = @import("compiler_rt/arm.zig").__aeabi_memmove; - @export(__aeabi_memmove, .{ .name = "__aeabi_memmove", .linkage = linkage }); - @export(__aeabi_memmove, .{ .name = "__aeabi_memmove4", .linkage = linkage }); - @export(__aeabi_memmove, .{ .name = "__aeabi_memmove8", .linkage = linkage }); - - const __aeabi_memset = @import("compiler_rt/arm.zig").__aeabi_memset; - @export(__aeabi_memset, .{ .name = "__aeabi_memset", .linkage = linkage }); - @export(__aeabi_memset, .{ .name = "__aeabi_memset4", .linkage = linkage }); - @export(__aeabi_memset, .{ .name = "__aeabi_memset8", .linkage = linkage }); - - const __aeabi_memclr = @import("compiler_rt/arm.zig").__aeabi_memclr; - @export(__aeabi_memclr, .{ .name = "__aeabi_memclr", .linkage = linkage }); - @export(__aeabi_memclr, .{ .name = "__aeabi_memclr4", .linkage = linkage }); - @export(__aeabi_memclr, .{ .name = "__aeabi_memclr8", .linkage = linkage }); - - if (os_tag == .linux) { - const __aeabi_read_tp = @import("compiler_rt/arm.zig").__aeabi_read_tp; - @export(__aeabi_read_tp, .{ .name = "__aeabi_read_tp", .linkage = linkage }); - } - - const __aeabi_f2d = @import("compiler_rt/extendXfYf2.zig").__aeabi_f2d; - @export(__aeabi_f2d, .{ .name = "__aeabi_f2d", .linkage = linkage }); - const __aeabi_i2d = @import("compiler_rt/floatXiYf.zig").__aeabi_i2d; - @export(__aeabi_i2d, .{ .name = "__aeabi_i2d", .linkage = linkage }); - const __aeabi_l2d = @import("compiler_rt/floatXiYf.zig").__aeabi_l2d; - @export(__aeabi_l2d, .{ .name = "__aeabi_l2d", .linkage = linkage }); - const __aeabi_l2f = @import("compiler_rt/floatXiYf.zig").__aeabi_l2f; - @export(__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = linkage }); - const __aeabi_ui2d = @import("compiler_rt/floatXiYf.zig").__aeabi_ui2d; - @export(__aeabi_ui2d, .{ .name = "__aeabi_ui2d", .linkage = linkage }); - const __aeabi_ul2d = @import("compiler_rt/floatXiYf.zig").__aeabi_ul2d; - @export(__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = linkage }); - const __aeabi_ui2f = @import("compiler_rt/floatXiYf.zig").__aeabi_ui2f; - @export(__aeabi_ui2f, .{ .name = "__aeabi_ui2f", .linkage = linkage }); - const __aeabi_ul2f = @import("compiler_rt/floatXiYf.zig").__aeabi_ul2f; - @export(__aeabi_ul2f, .{ .name = "__aeabi_ul2f", .linkage = linkage }); - - const __aeabi_fneg = @import("compiler_rt/negXf2.zig").__aeabi_fneg; - @export(__aeabi_fneg, .{ .name = "__aeabi_fneg", .linkage = linkage }); - const __aeabi_dneg = @import("compiler_rt/negXf2.zig").__aeabi_dneg; - @export(__aeabi_dneg, .{ .name = "__aeabi_dneg", .linkage = linkage }); - - const __aeabi_fmul = @import("compiler_rt/mulXf3.zig").__aeabi_fmul; - @export(__aeabi_fmul, .{ .name = "__aeabi_fmul", .linkage = linkage }); - const __aeabi_dmul = @import("compiler_rt/mulXf3.zig").__aeabi_dmul; - @export(__aeabi_dmul, .{ .name = "__aeabi_dmul", .linkage = linkage }); - - const __aeabi_d2h = @import("compiler_rt/truncXfYf2.zig").__aeabi_d2h; - @export(__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = linkage }); - - const __aeabi_f2ulz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2ulz; - @export(__aeabi_f2ulz, .{ .name = "__aeabi_f2ulz", .linkage = linkage }); - const __aeabi_d2ulz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2ulz; - @export(__aeabi_d2ulz, .{ .name = "__aeabi_d2ulz", .linkage = linkage }); - - const __aeabi_f2lz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2lz; - @export(__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = linkage }); - const __aeabi_d2lz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2lz; - @export(__aeabi_d2lz, .{ .name = "__aeabi_d2lz", .linkage = linkage }); - - const __aeabi_d2uiz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2uiz; - @export(__aeabi_d2uiz, .{ .name = "__aeabi_d2uiz", .linkage = linkage }); - - const __aeabi_h2f = @import("compiler_rt/extendXfYf2.zig").__aeabi_h2f; - @export(__aeabi_h2f, .{ .name = "__aeabi_h2f", .linkage = linkage }); - const __aeabi_f2h = @import("compiler_rt/truncXfYf2.zig").__aeabi_f2h; - @export(__aeabi_f2h, .{ .name = "__aeabi_f2h", .linkage = linkage }); - - const __aeabi_i2f = @import("compiler_rt/floatXiYf.zig").__aeabi_i2f; - @export(__aeabi_i2f, .{ .name = "__aeabi_i2f", .linkage = linkage }); - const __aeabi_d2f = @import("compiler_rt/truncXfYf2.zig").__aeabi_d2f; - @export(__aeabi_d2f, .{ .name = "__aeabi_d2f", .linkage = linkage }); - - const __aeabi_fadd = @import("compiler_rt/addXf3.zig").__aeabi_fadd; - @export(__aeabi_fadd, .{ .name = "__aeabi_fadd", .linkage = linkage }); - const __aeabi_dadd = @import("compiler_rt/addXf3.zig").__aeabi_dadd; - @export(__aeabi_dadd, .{ .name = "__aeabi_dadd", .linkage = linkage }); - const __aeabi_fsub = @import("compiler_rt/addXf3.zig").__aeabi_fsub; - @export(__aeabi_fsub, .{ .name = "__aeabi_fsub", .linkage = linkage }); - const __aeabi_dsub = @import("compiler_rt/addXf3.zig").__aeabi_dsub; - @export(__aeabi_dsub, .{ .name = "__aeabi_dsub", .linkage = linkage }); - - const __aeabi_f2uiz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2uiz; - @export(__aeabi_f2uiz, .{ .name = "__aeabi_f2uiz", .linkage = linkage }); - - const __aeabi_f2iz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2iz; - @export(__aeabi_f2iz, .{ .name = "__aeabi_f2iz", .linkage = linkage }); - const __aeabi_d2iz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2iz; - @export(__aeabi_d2iz, .{ .name = "__aeabi_d2iz", .linkage = linkage }); - - const __aeabi_fdiv = @import("compiler_rt/divsf3.zig").__aeabi_fdiv; - @export(__aeabi_fdiv, .{ .name = "__aeabi_fdiv", .linkage = linkage }); - const __aeabi_ddiv = @import("compiler_rt/divdf3.zig").__aeabi_ddiv; - @export(__aeabi_ddiv, .{ .name = "__aeabi_ddiv", .linkage = linkage }); - - const __aeabi_llsl = @import("compiler_rt/shift.zig").__aeabi_llsl; - @export(__aeabi_llsl, .{ .name = "__aeabi_llsl", .linkage = linkage }); - const __aeabi_lasr = @import("compiler_rt/shift.zig").__aeabi_lasr; - @export(__aeabi_lasr, .{ .name = "__aeabi_lasr", .linkage = linkage }); - const __aeabi_llsr = @import("compiler_rt/shift.zig").__aeabi_llsr; - @export(__aeabi_llsr, .{ .name = "__aeabi_llsr", .linkage = linkage }); - - const __aeabi_fcmpeq = @import("compiler_rt/compareXf2.zig").__aeabi_fcmpeq; - @export(__aeabi_fcmpeq, .{ .name = "__aeabi_fcmpeq", .linkage = linkage }); - const __aeabi_fcmplt = @import("compiler_rt/compareXf2.zig").__aeabi_fcmplt; - @export(__aeabi_fcmplt, .{ .name = "__aeabi_fcmplt", .linkage = linkage }); - const __aeabi_fcmple = @import("compiler_rt/compareXf2.zig").__aeabi_fcmple; - @export(__aeabi_fcmple, .{ .name = "__aeabi_fcmple", .linkage = linkage }); - const __aeabi_fcmpge = @import("compiler_rt/compareXf2.zig").__aeabi_fcmpge; - @export(__aeabi_fcmpge, .{ .name = "__aeabi_fcmpge", .linkage = linkage }); - const __aeabi_fcmpgt = @import("compiler_rt/compareXf2.zig").__aeabi_fcmpgt; - @export(__aeabi_fcmpgt, .{ .name = "__aeabi_fcmpgt", .linkage = linkage }); - const __aeabi_fcmpun = @import("compiler_rt/compareXf2.zig").__aeabi_fcmpun; - @export(__aeabi_fcmpun, .{ .name = "__aeabi_fcmpun", .linkage = linkage }); - - const __aeabi_dcmpeq = @import("compiler_rt/compareXf2.zig").__aeabi_dcmpeq; - @export(__aeabi_dcmpeq, .{ .name = "__aeabi_dcmpeq", .linkage = linkage }); - const __aeabi_dcmplt = @import("compiler_rt/compareXf2.zig").__aeabi_dcmplt; - @export(__aeabi_dcmplt, .{ .name = "__aeabi_dcmplt", .linkage = linkage }); - const __aeabi_dcmple = @import("compiler_rt/compareXf2.zig").__aeabi_dcmple; - @export(__aeabi_dcmple, .{ .name = "__aeabi_dcmple", .linkage = linkage }); - const __aeabi_dcmpge = @import("compiler_rt/compareXf2.zig").__aeabi_dcmpge; - @export(__aeabi_dcmpge, .{ .name = "__aeabi_dcmpge", .linkage = linkage }); - const __aeabi_dcmpgt = @import("compiler_rt/compareXf2.zig").__aeabi_dcmpgt; - @export(__aeabi_dcmpgt, .{ .name = "__aeabi_dcmpgt", .linkage = linkage }); - const __aeabi_dcmpun = @import("compiler_rt/compareXf2.zig").__aeabi_dcmpun; - @export(__aeabi_dcmpun, .{ .name = "__aeabi_dcmpun", .linkage = linkage }); - } - - if (arch == .i386 and abi == .msvc) { - // Don't let LLVM apply the stdcall name mangling on those MSVC builtins - const _alldiv = @import("compiler_rt/aulldiv.zig")._alldiv; - @export(_alldiv, .{ .name = "\x01__alldiv", .linkage = strong_linkage }); - const _aulldiv = @import("compiler_rt/aulldiv.zig")._aulldiv; - @export(_aulldiv, .{ .name = "\x01__aulldiv", .linkage = strong_linkage }); - const _allrem = @import("compiler_rt/aullrem.zig")._allrem; - @export(_allrem, .{ .name = "\x01__allrem", .linkage = strong_linkage }); - const _aullrem = @import("compiler_rt/aullrem.zig")._aullrem; - @export(_aullrem, .{ .name = "\x01__aullrem", .linkage = strong_linkage }); - } - - mathExport("ceil", @import("./compiler_rt/ceil.zig")); - mathExport("cos", @import("./compiler_rt/cos.zig")); - mathExport("exp", @import("./compiler_rt/exp.zig")); - mathExport("exp2", @import("./compiler_rt/exp2.zig")); - mathExport("fabs", @import("./compiler_rt/fabs.zig")); - mathExport("floor", @import("./compiler_rt/floor.zig")); - mathExport("fma", @import("./compiler_rt/fma.zig")); - mathExport("fmax", @import("./compiler_rt/fmax.zig")); - mathExport("fmin", @import("./compiler_rt/fmin.zig")); - mathExport("fmod", @import("./compiler_rt/fmod.zig")); - mathExport("log", @import("./compiler_rt/log.zig")); - mathExport("log10", @import("./compiler_rt/log10.zig")); - mathExport("log2", @import("./compiler_rt/log2.zig")); - mathExport("round", @import("./compiler_rt/round.zig")); - mathExport("sin", @import("./compiler_rt/sin.zig")); - mathExport("sincos", @import("./compiler_rt/sincos.zig")); - mathExport("sqrt", @import("./compiler_rt/sqrt.zig")); - mathExport("tan", @import("./compiler_rt/tan.zig")); - mathExport("trunc", @import("./compiler_rt/trunc.zig")); - - if (arch.isSPARC()) { - // SPARC systems use a different naming scheme - const _Qp_add = @import("compiler_rt/sparc.zig")._Qp_add; - @export(_Qp_add, .{ .name = "_Qp_add", .linkage = linkage }); - const _Qp_div = @import("compiler_rt/sparc.zig")._Qp_div; - @export(_Qp_div, .{ .name = "_Qp_div", .linkage = linkage }); - const _Qp_mul = @import("compiler_rt/sparc.zig")._Qp_mul; - @export(_Qp_mul, .{ .name = "_Qp_mul", .linkage = linkage }); - const _Qp_sub = @import("compiler_rt/sparc.zig")._Qp_sub; - @export(_Qp_sub, .{ .name = "_Qp_sub", .linkage = linkage }); - - const _Qp_cmp = @import("compiler_rt/sparc.zig")._Qp_cmp; - @export(_Qp_cmp, .{ .name = "_Qp_cmp", .linkage = linkage }); - const _Qp_feq = @import("compiler_rt/sparc.zig")._Qp_feq; - @export(_Qp_feq, .{ .name = "_Qp_feq", .linkage = linkage }); - const _Qp_fne = @import("compiler_rt/sparc.zig")._Qp_fne; - @export(_Qp_fne, .{ .name = "_Qp_fne", .linkage = linkage }); - const _Qp_flt = @import("compiler_rt/sparc.zig")._Qp_flt; - @export(_Qp_flt, .{ .name = "_Qp_flt", .linkage = linkage }); - const _Qp_fle = @import("compiler_rt/sparc.zig")._Qp_fle; - @export(_Qp_fle, .{ .name = "_Qp_fle", .linkage = linkage }); - const _Qp_fgt = @import("compiler_rt/sparc.zig")._Qp_fgt; - @export(_Qp_fgt, .{ .name = "_Qp_fgt", .linkage = linkage }); - const _Qp_fge = @import("compiler_rt/sparc.zig")._Qp_fge; - @export(_Qp_fge, .{ .name = "_Qp_fge", .linkage = linkage }); - - const _Qp_itoq = @import("compiler_rt/sparc.zig")._Qp_itoq; - @export(_Qp_itoq, .{ .name = "_Qp_itoq", .linkage = linkage }); - const _Qp_uitoq = @import("compiler_rt/sparc.zig")._Qp_uitoq; - @export(_Qp_uitoq, .{ .name = "_Qp_uitoq", .linkage = linkage }); - const _Qp_xtoq = @import("compiler_rt/sparc.zig")._Qp_xtoq; - @export(_Qp_xtoq, .{ .name = "_Qp_xtoq", .linkage = linkage }); - const _Qp_uxtoq = @import("compiler_rt/sparc.zig")._Qp_uxtoq; - @export(_Qp_uxtoq, .{ .name = "_Qp_uxtoq", .linkage = linkage }); - const _Qp_stoq = @import("compiler_rt/sparc.zig")._Qp_stoq; - @export(_Qp_stoq, .{ .name = "_Qp_stoq", .linkage = linkage }); - const _Qp_dtoq = @import("compiler_rt/sparc.zig")._Qp_dtoq; - @export(_Qp_dtoq, .{ .name = "_Qp_dtoq", .linkage = linkage }); - const _Qp_qtoi = @import("compiler_rt/sparc.zig")._Qp_qtoi; - @export(_Qp_qtoi, .{ .name = "_Qp_qtoi", .linkage = linkage }); - const _Qp_qtoui = @import("compiler_rt/sparc.zig")._Qp_qtoui; - @export(_Qp_qtoui, .{ .name = "_Qp_qtoui", .linkage = linkage }); - const _Qp_qtox = @import("compiler_rt/sparc.zig")._Qp_qtox; - @export(_Qp_qtox, .{ .name = "_Qp_qtox", .linkage = linkage }); - const _Qp_qtoux = @import("compiler_rt/sparc.zig")._Qp_qtoux; - @export(_Qp_qtoux, .{ .name = "_Qp_qtoux", .linkage = linkage }); - const _Qp_qtos = @import("compiler_rt/sparc.zig")._Qp_qtos; - @export(_Qp_qtos, .{ .name = "_Qp_qtos", .linkage = linkage }); - const _Qp_qtod = @import("compiler_rt/sparc.zig")._Qp_qtod; - @export(_Qp_qtod, .{ .name = "_Qp_qtod", .linkage = linkage }); - } - - if (is_ppc and !is_test) { - @export(__addtf3, .{ .name = "__addkf3", .linkage = linkage }); - @export(__subtf3, .{ .name = "__subkf3", .linkage = linkage }); - @export(__multf3, .{ .name = "__mulkf3", .linkage = linkage }); - @export(__divtf3, .{ .name = "__divkf3", .linkage = linkage }); - @export(__extendsftf2, .{ .name = "__extendsfkf2", .linkage = linkage }); - @export(__extenddftf2, .{ .name = "__extenddfkf2", .linkage = linkage }); - @export(__trunctfsf2, .{ .name = "__trunckfsf2", .linkage = linkage }); - @export(__trunctfdf2, .{ .name = "__trunckfdf2", .linkage = linkage }); - @export(__fixtfdi, .{ .name = "__fixkfdi", .linkage = linkage }); - @export(__fixtfsi, .{ .name = "__fixkfsi", .linkage = linkage }); - @export(__fixunstfsi, .{ .name = "__fixunskfsi", .linkage = linkage }); - @export(__fixunstfdi, .{ .name = "__fixunskfdi", .linkage = linkage }); - @export(__floatsitf, .{ .name = "__floatsikf", .linkage = linkage }); - @export(__floatditf, .{ .name = "__floatdikf", .linkage = linkage }); - @export(__floatunditf, .{ .name = "__floatundikf", .linkage = linkage }); - @export(__floatunsitf, .{ .name = "__floatunsikf", .linkage = linkage }); - @export(__floatuntitf, .{ .name = "__floatuntikf", .linkage = linkage }); - - @export(__letf2, .{ .name = "__eqkf2", .linkage = linkage }); - @export(__letf2, .{ .name = "__nekf2", .linkage = linkage }); - @export(__getf2, .{ .name = "__gekf2", .linkage = linkage }); - @export(__letf2, .{ .name = "__ltkf2", .linkage = linkage }); - @export(__letf2, .{ .name = "__lekf2", .linkage = linkage }); - @export(__getf2, .{ .name = "__gtkf2", .linkage = linkage }); - @export(__unordtf2, .{ .name = "__unordkf2", .linkage = linkage }); - } -} - -inline fn mathExport(double_name: []const u8, comptime import: type) void { - const half_name = "__" ++ double_name ++ "h"; - const half_fn = @field(import, half_name); - const float_name = double_name ++ "f"; - const float_fn = @field(import, float_name); - const double_fn = @field(import, double_name); - const long_double_name = double_name ++ "l"; - const xf80_name = "__" ++ double_name ++ "x"; - const xf80_fn = @field(import, xf80_name); - const quad_name = double_name ++ "q"; - const quad_fn = @field(import, quad_name); - - @export(half_fn, .{ .name = half_name, .linkage = linkage }); - @export(float_fn, .{ .name = float_name, .linkage = linkage }); - @export(double_fn, .{ .name = double_name, .linkage = linkage }); - @export(xf80_fn, .{ .name = xf80_name, .linkage = linkage }); - @export(quad_fn, .{ .name = quad_name, .linkage = linkage }); - - if (is_test) return; - - const pairs = .{ - .{ f16, half_fn }, - .{ f32, float_fn }, - .{ f64, double_fn }, - .{ f80, xf80_fn }, - .{ f128, quad_fn }, - }; - - if (builtin.os.tag == .windows) { - // Weak aliases don't work on Windows, so we have to provide the 'l' variants - // as additional function definitions that jump to the real definition. - const long_double_fn = @field(import, long_double_name); - @export(long_double_fn, .{ .name = long_double_name, .linkage = linkage }); - } else { - inline for (pairs) |pair| { - const F = pair[0]; - const func = pair[1]; - if (builtin.target.longDoubleIs(F)) { - @export(func, .{ .name = long_double_name, .linkage = linkage }); - } - } - } - - if (is_ppc) { - // LLVM PPC backend lowers f128 ops with the suffix `f128` instead of `l`. - @export(quad_fn, .{ .name = double_name ++ "f128", .linkage = linkage }); - } -} - -// Avoid dragging in the runtime safety mechanisms into this .o file, -// unless we're trying to test this file. -pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn { - _ = error_return_trace; - @setCold(true); - if (is_test) { - std.debug.panic("{s}", .{msg}); - } else { - unreachable; - } } diff --git a/lib/compiler_rt/absv.zig b/lib/compiler_rt/absv.zig index f14497daf2..3d9476b6c7 100644 --- a/lib/compiler_rt/absv.zig +++ b/lib/compiler_rt/absv.zig @@ -1,6 +1,16 @@ // absv - absolute oVerflow // * @panic, if value can not be represented // - absvXi4_generic for unoptimized version +const std = @import("std"); +const builtin = @import("builtin"); +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__absvsi2, .{ .name = "__absvsi2", .linkage = linkage }); + @export(__absvdi2, .{ .name = "__absvdi2", .linkage = linkage }); + @export(__absvti2, .{ .name = "__absvti2", .linkage = linkage }); +} inline fn absvXi(comptime ST: type, a: ST) ST { const UT = switch (ST) { diff --git a/lib/compiler_rt/addXf3.zig b/lib/compiler_rt/addXf3.zig index 1a9de0fb74..e2cf9d0112 100644 --- a/lib/compiler_rt/addXf3.zig +++ b/lib/compiler_rt/addXf3.zig @@ -3,9 +3,41 @@ // https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/lib/builtins/fp_add_impl.inc const std = @import("std"); -const math = std.math; const builtin = @import("builtin"); -const compiler_rt = @import("../compiler_rt.zig"); +const math = std.math; +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; + +const common = @import("common.zig"); +const normalize = common.normalize; +pub const panic = common.panic; + +comptime { + @export(__addsf3, .{ .name = "__addsf3", .linkage = linkage }); + @export(__adddf3, .{ .name = "__adddf3", .linkage = linkage }); + @export(__addxf3, .{ .name = "__addxf3", .linkage = linkage }); + @export(__addtf3, .{ .name = "__addtf3", .linkage = linkage }); + + @export(__subsf3, .{ .name = "__subsf3", .linkage = linkage }); + @export(__subdf3, .{ .name = "__subdf3", .linkage = linkage }); + @export(__subxf3, .{ .name = "__subxf3", .linkage = linkage }); + @export(__subtf3, .{ .name = "__subtf3", .linkage = linkage }); + + if (!is_test) { + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_fadd, .{ .name = "__aeabi_fadd", .linkage = linkage }); + @export(__aeabi_dadd, .{ .name = "__aeabi_dadd", .linkage = linkage }); + @export(__aeabi_fsub, .{ .name = "__aeabi_fsub", .linkage = linkage }); + @export(__aeabi_dsub, .{ .name = "__aeabi_dsub", .linkage = linkage }); + } + + if (arch.isPPC() or arch.isPPC64()) { + @export(__addkf3, .{ .name = "__addkf3", .linkage = linkage }); + @export(__subkf3, .{ .name = "__subkf3", .linkage = linkage }); + } + } +} pub fn __addsf3(a: f32, b: f32) callconv(.C) f32 { return addXf3(f32, a, b); @@ -29,6 +61,10 @@ pub fn __addtf3(a: f128, b: f128) callconv(.C) f128 { return addXf3(f128, a, b); } +pub fn __addkf3(a: f128, b: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, __addtf3, .{ a, b }); +} + pub fn __subsf3(a: f32, b: f32) callconv(.C) f32 { const neg_b = @bitCast(f32, @bitCast(u32, b) ^ (@as(u32, 1) << 31)); return addXf3(f32, a, neg_b); @@ -44,6 +80,10 @@ pub fn __subtf3(a: f128, b: f128) callconv(.C) f128 { return addXf3(f128, a, neg_b); } +pub fn __subkf3(a: f128, b: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, __subtf3, .{ a, b }); +} + pub fn __aeabi_fadd(a: f32, b: f32) callconv(.AAPCS) f32 { @setRuntimeSafety(false); return @call(.{ .modifier = .always_inline }, __addsf3, .{ a, b }); @@ -65,20 +105,7 @@ pub fn __aeabi_dsub(a: f64, b: f64) callconv(.AAPCS) f64 { } // TODO: restore inline keyword, see: https://github.com/ziglang/zig/issues/2154 -fn normalize(comptime T: type, significand: *std.meta.Int(.unsigned, @typeInfo(T).Float.bits)) i32 { - const bits = @typeInfo(T).Float.bits; - const Z = std.meta.Int(.unsigned, bits); - const S = std.meta.Int(.unsigned, bits - @clz(Z, @as(Z, bits) - 1)); - const fractionalBits = math.floatFractionalBits(T); - const integerBit = @as(Z, 1) << fractionalBits; - - const shift = @clz(std.meta.Int(.unsigned, bits), significand.*) - @clz(Z, integerBit); - significand.* <<= @intCast(S, shift); - return @as(i32, 1) - shift; -} - -// TODO: restore inline keyword, see: https://github.com/ziglang/zig/issues/2154 -fn addXf3(comptime T: type, a: T, b: T) T { +pub fn addXf3(comptime T: type, a: T, b: T) T { const bits = @typeInfo(T).Float.bits; const Z = std.meta.Int(.unsigned, bits); const S = std.meta.Int(.unsigned, bits - @clz(Z, @as(Z, bits) - 1)); diff --git a/lib/compiler_rt/addo.zig b/lib/compiler_rt/addo.zig index 91ed15747c..d14fe36710 100644 --- a/lib/compiler_rt/addo.zig +++ b/lib/compiler_rt/addo.zig @@ -1,4 +1,14 @@ +const std = @import("std"); const builtin = @import("builtin"); +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__addosi4, .{ .name = "__addosi4", .linkage = linkage }); + @export(__addodi4, .{ .name = "__addodi4", .linkage = linkage }); + @export(__addoti4, .{ .name = "__addoti4", .linkage = linkage }); +} // addo - add overflow // * return a+%b. diff --git a/lib/compiler_rt/arm.zig b/lib/compiler_rt/arm.zig index f30d2fd6ec..f974f67cce 100644 --- a/lib/compiler_rt/arm.zig +++ b/lib/compiler_rt/arm.zig @@ -1,5 +1,45 @@ // ARM specific builtins +const std = @import("std"); const builtin = @import("builtin"); +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + if (!builtin.is_test) { + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_unwind_cpp_pr0, .{ .name = "__aeabi_unwind_cpp_pr0", .linkage = linkage }); + @export(__aeabi_unwind_cpp_pr1, .{ .name = "__aeabi_unwind_cpp_pr1", .linkage = linkage }); + @export(__aeabi_unwind_cpp_pr2, .{ .name = "__aeabi_unwind_cpp_pr2", .linkage = linkage }); + + @export(__aeabi_ldivmod, .{ .name = "__aeabi_ldivmod", .linkage = linkage }); + @export(__aeabi_uldivmod, .{ .name = "__aeabi_uldivmod", .linkage = linkage }); + + @export(__aeabi_idivmod, .{ .name = "__aeabi_idivmod", .linkage = linkage }); + @export(__aeabi_uidivmod, .{ .name = "__aeabi_uidivmod", .linkage = linkage }); + + @export(__aeabi_memcpy, .{ .name = "__aeabi_memcpy", .linkage = linkage }); + @export(__aeabi_memcpy4, .{ .name = "__aeabi_memcpy4", .linkage = linkage }); + @export(__aeabi_memcpy8, .{ .name = "__aeabi_memcpy8", .linkage = linkage }); + + @export(__aeabi_memmove, .{ .name = "__aeabi_memmove", .linkage = linkage }); + @export(__aeabi_memmove4, .{ .name = "__aeabi_memmove4", .linkage = linkage }); + @export(__aeabi_memmove8, .{ .name = "__aeabi_memmove8", .linkage = linkage }); + + @export(__aeabi_memset, .{ .name = "__aeabi_memset", .linkage = linkage }); + @export(__aeabi_memset4, .{ .name = "__aeabi_memset4", .linkage = linkage }); + @export(__aeabi_memset8, .{ .name = "__aeabi_memset8", .linkage = linkage }); + + @export(__aeabi_memclr, .{ .name = "__aeabi_memclr", .linkage = linkage }); + @export(__aeabi_memclr4, .{ .name = "__aeabi_memclr4", .linkage = linkage }); + @export(__aeabi_memclr8, .{ .name = "__aeabi_memclr8", .linkage = linkage }); + + if (builtin.os.tag == .linux) { + @export(__aeabi_read_tp, .{ .name = "__aeabi_read_tp", .linkage = linkage }); + } + } + } +} const __divmodsi4 = @import("int.zig").__divmodsi4; const __udivmodsi4 = @import("int.zig").__udivmodsi4; @@ -14,11 +54,27 @@ pub fn __aeabi_memcpy(dest: [*]u8, src: [*]u8, n: usize) callconv(.AAPCS) void { @setRuntimeSafety(false); _ = memcpy(dest, src, n); } +pub fn __aeabi_memcpy4(dest: [*]u8, src: [*]u8, n: usize) callconv(.AAPCS) void { + @setRuntimeSafety(false); + _ = memcpy(dest, src, n); +} +pub fn __aeabi_memcpy8(dest: [*]u8, src: [*]u8, n: usize) callconv(.AAPCS) void { + @setRuntimeSafety(false); + _ = memcpy(dest, src, n); +} pub fn __aeabi_memmove(dest: [*]u8, src: [*]u8, n: usize) callconv(.AAPCS) void { @setRuntimeSafety(false); _ = memmove(dest, src, n); } +pub fn __aeabi_memmove4(dest: [*]u8, src: [*]u8, n: usize) callconv(.AAPCS) void { + @setRuntimeSafety(false); + _ = memmove(dest, src, n); +} +pub fn __aeabi_memmove8(dest: [*]u8, src: [*]u8, n: usize) callconv(.AAPCS) void { + @setRuntimeSafety(false); + _ = memmove(dest, src, n); +} pub fn __aeabi_memset(dest: [*]u8, n: usize, c: u8) callconv(.AAPCS) void { @setRuntimeSafety(false); @@ -26,11 +82,27 @@ pub fn __aeabi_memset(dest: [*]u8, n: usize, c: u8) callconv(.AAPCS) void { // two arguments swapped _ = memset(dest, c, n); } +pub fn __aeabi_memset4(dest: [*]u8, n: usize, c: u8) callconv(.AAPCS) void { + @setRuntimeSafety(false); + _ = memset(dest, c, n); +} +pub fn __aeabi_memset8(dest: [*]u8, n: usize, c: u8) callconv(.AAPCS) void { + @setRuntimeSafety(false); + _ = memset(dest, c, n); +} pub fn __aeabi_memclr(dest: [*]u8, n: usize) callconv(.AAPCS) void { @setRuntimeSafety(false); _ = memset(dest, 0, n); } +pub fn __aeabi_memclr4(dest: [*]u8, n: usize) callconv(.AAPCS) void { + @setRuntimeSafety(false); + _ = memset(dest, 0, n); +} +pub fn __aeabi_memclr8(dest: [*]u8, n: usize) callconv(.AAPCS) void { + @setRuntimeSafety(false); + _ = memset(dest, 0, n); +} // Dummy functions to avoid errors during the linking phase pub fn __aeabi_unwind_cpp_pr0() callconv(.C) void {} diff --git a/lib/compiler_rt/atomics.zig b/lib/compiler_rt/atomics.zig index 20545d0791..6935a858aa 100644 --- a/lib/compiler_rt/atomics.zig +++ b/lib/compiler_rt/atomics.zig @@ -2,8 +2,8 @@ const std = @import("std"); const builtin = @import("builtin"); const cpu = builtin.cpu; const arch = cpu.arch; - const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; // This parameter is true iff the target architecture supports the bare minimum // to implement the atomic load/store intrinsics. diff --git a/lib/compiler_rt/aulldiv.zig b/lib/compiler_rt/aulldiv.zig index 7709e17e63..7154cb39a1 100644 --- a/lib/compiler_rt/aulldiv.zig +++ b/lib/compiler_rt/aulldiv.zig @@ -1,4 +1,19 @@ +const std = @import("std"); const builtin = @import("builtin"); +const arch = builtin.cpu.arch; +const abi = builtin.abi; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Strong; +pub const panic = @import("common.zig").panic; + +comptime { + if (arch == .i386 and abi == .msvc) { + // Don't let LLVM apply the stdcall name mangling on those MSVC builtins + @export(_alldiv, .{ .name = "\x01__alldiv", .linkage = linkage }); + @export(_aulldiv, .{ .name = "\x01__aulldiv", .linkage = linkage }); + @export(_allrem, .{ .name = "\x01__allrem", .linkage = linkage }); + @export(_aullrem, .{ .name = "\x01__aullrem", .linkage = linkage }); + } +} pub fn _alldiv(a: i64, b: i64) callconv(.Stdcall) i64 { @setRuntimeSafety(builtin.is_test); diff --git a/lib/compiler_rt/bswap.zig b/lib/compiler_rt/bswap.zig index f1d2138811..bab39dfb59 100644 --- a/lib/compiler_rt/bswap.zig +++ b/lib/compiler_rt/bswap.zig @@ -1,5 +1,14 @@ const std = @import("std"); const builtin = @import("builtin"); +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__bswapsi2, .{ .name = "__bswapsi2", .linkage = linkage }); + @export(__bswapdi2, .{ .name = "__bswapdi2", .linkage = linkage }); + @export(__bswapti2, .{ .name = "__bswapti2", .linkage = linkage }); +} // bswap - byteswap // - bswapXi2 for unoptimized big and little endian diff --git a/lib/compiler_rt/ceil.zig b/lib/compiler_rt/ceil.zig index 06020ea8f8..9e7e4b3c2b 100644 --- a/lib/compiler_rt/ceil.zig +++ b/lib/compiler_rt/ceil.zig @@ -5,8 +5,27 @@ // https://git.musl-libc.org/cgit/musl/tree/src/math/ceil.c const std = @import("std"); +const builtin = @import("builtin"); +const arch = builtin.cpu.arch; const math = std.math; const expect = std.testing.expect; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__ceilh, .{ .name = "__ceilh", .linkage = linkage }); + @export(ceilf, .{ .name = "ceilf", .linkage = linkage }); + @export(ceil, .{ .name = "ceil", .linkage = linkage }); + @export(__ceilx, .{ .name = "__ceilx", .linkage = linkage }); + @export(ceilq, .{ .name = "ceilq", .linkage = linkage }); + @export(ceill, .{ .name = "ceill", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(ceilf128, .{ .name = "ceilf128", .linkage = linkage }); + } + } +} pub fn __ceilh(x: f16) callconv(.C) f16 { // TODO: more efficient implementation @@ -111,6 +130,10 @@ pub fn ceilq(x: f128) callconv(.C) f128 { } } +pub fn ceilf128(x: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, ceilq, .{x}); +} + pub fn ceill(x: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __ceilh(x), diff --git a/lib/compiler_rt/clear_cache.zig b/lib/compiler_rt/clear_cache.zig index 0765a23811..b21606814c 100644 --- a/lib/compiler_rt/clear_cache.zig +++ b/lib/compiler_rt/clear_cache.zig @@ -2,6 +2,7 @@ const std = @import("std"); const builtin = @import("builtin"); const arch = builtin.cpu.arch; const os = builtin.os.tag; +pub const panic = @import("common.zig").panic; // Ported from llvm-project d32170dbd5b0d54436537b6b75beaf44324e0c28 @@ -10,7 +11,13 @@ const os = builtin.os.tag; // It is expected to invalidate the instruction cache for the // specified range. -pub fn clear_cache(start: usize, end: usize) callconv(.C) void { +comptime { + if (builtin.zig_backend != .stage2_llvm) { + _ = clear_cache; + } +} + +fn clear_cache(start: usize, end: usize) callconv(.C) void { const x86 = switch (arch) { .i386, .x86_64 => true, else => false, diff --git a/lib/compiler_rt/cmp.zig b/lib/compiler_rt/cmp.zig index 9eb4227527..1ac2e93b06 100644 --- a/lib/compiler_rt/cmp.zig +++ b/lib/compiler_rt/cmp.zig @@ -1,5 +1,17 @@ const std = @import("std"); const builtin = @import("builtin"); +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__cmpsi2, .{ .name = "__cmpsi2", .linkage = linkage }); + @export(__cmpdi2, .{ .name = "__cmpdi2", .linkage = linkage }); + @export(__cmpti2, .{ .name = "__cmpti2", .linkage = linkage }); + @export(__ucmpsi2, .{ .name = "__ucmpsi2", .linkage = linkage }); + @export(__ucmpdi2, .{ .name = "__ucmpdi2", .linkage = linkage }); + @export(__ucmpti2, .{ .name = "__ucmpti2", .linkage = linkage }); +} // cmp - signed compare // - cmpXi2_generic for unoptimized little and big endian diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig new file mode 100644 index 0000000000..7e9bdf81c8 --- /dev/null +++ b/lib/compiler_rt/common.zig @@ -0,0 +1,144 @@ +const std = @import("std"); +const builtin = @import("builtin"); +const math = std.math; +const is_test = builtin.is_test; + +// Avoid dragging in the runtime safety mechanisms into this .o file, +// unless we're trying to test this file. +pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn { + _ = error_return_trace; + @setCold(true); + if (is_test) { + std.debug.panic("{s}", .{msg}); + } else { + unreachable; + } +} + +pub fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void { + @setRuntimeSafety(is_test); + switch (Z) { + u16 => { + // 16x16 --> 32 bit multiply + const product = @as(u32, a) * @as(u32, b); + hi.* = @intCast(u16, product >> 16); + lo.* = @truncate(u16, product); + }, + u32 => { + // 32x32 --> 64 bit multiply + const product = @as(u64, a) * @as(u64, b); + hi.* = @truncate(u32, product >> 32); + lo.* = @truncate(u32, product); + }, + u64 => { + const S = struct { + fn loWord(x: u64) u64 { + return @truncate(u32, x); + } + fn hiWord(x: u64) u64 { + return @truncate(u32, x >> 32); + } + }; + // 64x64 -> 128 wide multiply for platforms that don't have such an operation; + // many 64-bit platforms have this operation, but they tend to have hardware + // floating-point, so we don't bother with a special case for them here. + // Each of the component 32x32 -> 64 products + const plolo: u64 = S.loWord(a) * S.loWord(b); + const plohi: u64 = S.loWord(a) * S.hiWord(b); + const philo: u64 = S.hiWord(a) * S.loWord(b); + const phihi: u64 = S.hiWord(a) * S.hiWord(b); + // Sum terms that contribute to lo in a way that allows us to get the carry + const r0: u64 = S.loWord(plolo); + const r1: u64 = S.hiWord(plolo) +% S.loWord(plohi) +% S.loWord(philo); + lo.* = r0 +% (r1 << 32); + // Sum terms contributing to hi with the carry from lo + hi.* = S.hiWord(plohi) +% S.hiWord(philo) +% S.hiWord(r1) +% phihi; + }, + u128 => { + const Word_LoMask = @as(u64, 0x00000000ffffffff); + const Word_HiMask = @as(u64, 0xffffffff00000000); + const Word_FullMask = @as(u64, 0xffffffffffffffff); + const S = struct { + fn Word_1(x: u128) u64 { + return @truncate(u32, x >> 96); + } + fn Word_2(x: u128) u64 { + return @truncate(u32, x >> 64); + } + fn Word_3(x: u128) u64 { + return @truncate(u32, x >> 32); + } + fn Word_4(x: u128) u64 { + return @truncate(u32, x); + } + }; + // 128x128 -> 256 wide multiply for platforms that don't have such an operation; + // many 64-bit platforms have this operation, but they tend to have hardware + // floating-point, so we don't bother with a special case for them here. + + const product11: u64 = S.Word_1(a) * S.Word_1(b); + const product12: u64 = S.Word_1(a) * S.Word_2(b); + const product13: u64 = S.Word_1(a) * S.Word_3(b); + const product14: u64 = S.Word_1(a) * S.Word_4(b); + const product21: u64 = S.Word_2(a) * S.Word_1(b); + const product22: u64 = S.Word_2(a) * S.Word_2(b); + const product23: u64 = S.Word_2(a) * S.Word_3(b); + const product24: u64 = S.Word_2(a) * S.Word_4(b); + const product31: u64 = S.Word_3(a) * S.Word_1(b); + const product32: u64 = S.Word_3(a) * S.Word_2(b); + const product33: u64 = S.Word_3(a) * S.Word_3(b); + const product34: u64 = S.Word_3(a) * S.Word_4(b); + const product41: u64 = S.Word_4(a) * S.Word_1(b); + const product42: u64 = S.Word_4(a) * S.Word_2(b); + const product43: u64 = S.Word_4(a) * S.Word_3(b); + const product44: u64 = S.Word_4(a) * S.Word_4(b); + + const sum0: u128 = @as(u128, product44); + const sum1: u128 = @as(u128, product34) +% + @as(u128, product43); + const sum2: u128 = @as(u128, product24) +% + @as(u128, product33) +% + @as(u128, product42); + const sum3: u128 = @as(u128, product14) +% + @as(u128, product23) +% + @as(u128, product32) +% + @as(u128, product41); + const sum4: u128 = @as(u128, product13) +% + @as(u128, product22) +% + @as(u128, product31); + const sum5: u128 = @as(u128, product12) +% + @as(u128, product21); + const sum6: u128 = @as(u128, product11); + + const r0: u128 = (sum0 & Word_FullMask) +% + ((sum1 & Word_LoMask) << 32); + const r1: u128 = (sum0 >> 64) +% + ((sum1 >> 32) & Word_FullMask) +% + (sum2 & Word_FullMask) +% + ((sum3 << 32) & Word_HiMask); + + lo.* = r0 +% (r1 << 64); + hi.* = (r1 >> 64) +% + (sum1 >> 96) +% + (sum2 >> 64) +% + (sum3 >> 32) +% + sum4 +% + (sum5 << 32) +% + (sum6 << 64); + }, + else => @compileError("unsupported"), + } +} + +// TODO: restore inline keyword, see: https://github.com/ziglang/zig/issues/2154 +pub fn normalize(comptime T: type, significand: *std.meta.Int(.unsigned, @typeInfo(T).Float.bits)) i32 { + const bits = @typeInfo(T).Float.bits; + const Z = std.meta.Int(.unsigned, bits); + const S = std.meta.Int(.unsigned, bits - @clz(Z, @as(Z, bits) - 1)); + const fractionalBits = math.floatFractionalBits(T); + const integerBit = @as(Z, 1) << fractionalBits; + + const shift = @clz(std.meta.Int(.unsigned, bits), significand.*) - @clz(Z, integerBit); + significand.* <<= @intCast(S, shift); + return @as(i32, 1) - shift; +} diff --git a/lib/compiler_rt/compareXf2.zig b/lib/compiler_rt/compareXf2.zig index 9640298f8f..d21a6777e4 100644 --- a/lib/compiler_rt/compareXf2.zig +++ b/lib/compiler_rt/compareXf2.zig @@ -4,6 +4,78 @@ const std = @import("std"); const builtin = @import("builtin"); +const is_test = builtin.is_test; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__lesf2, .{ .name = "__lesf2", .linkage = linkage }); + @export(__ledf2, .{ .name = "__ledf2", .linkage = linkage }); + @export(__letf2, .{ .name = "__letf2", .linkage = linkage }); + @export(__lexf2, .{ .name = "__lexf2", .linkage = linkage }); + + @export(__gesf2, .{ .name = "__gesf2", .linkage = linkage }); + @export(__gedf2, .{ .name = "__gedf2", .linkage = linkage }); + @export(__getf2, .{ .name = "__getf2", .linkage = linkage }); + @export(__gexf2, .{ .name = "__gexf2", .linkage = linkage }); + + @export(__eqsf2, .{ .name = "__eqsf2", .linkage = linkage }); + @export(__eqdf2, .{ .name = "__eqdf2", .linkage = linkage }); + @export(__eqxf2, .{ .name = "__eqxf2", .linkage = linkage }); + + @export(__ltsf2, .{ .name = "__ltsf2", .linkage = linkage }); + @export(__ltdf2, .{ .name = "__ltdf2", .linkage = linkage }); + @export(__ltxf2, .{ .name = "__ltxf2", .linkage = linkage }); + + @export(__nesf2, .{ .name = "__nesf2", .linkage = linkage }); + @export(__nedf2, .{ .name = "__nedf2", .linkage = linkage }); + @export(__nexf2, .{ .name = "__nexf2", .linkage = linkage }); + + @export(__gtsf2, .{ .name = "__gtsf2", .linkage = linkage }); + @export(__gtdf2, .{ .name = "__gtdf2", .linkage = linkage }); + @export(__gtxf2, .{ .name = "__gtxf2", .linkage = linkage }); + + @export(__unordsf2, .{ .name = "__unordsf2", .linkage = linkage }); + @export(__unorddf2, .{ .name = "__unorddf2", .linkage = linkage }); + @export(__unordtf2, .{ .name = "__unordtf2", .linkage = linkage }); + + if (!is_test) { + @export(__cmpsf2, .{ .name = "__cmpsf2", .linkage = linkage }); + @export(__cmpdf2, .{ .name = "__cmpdf2", .linkage = linkage }); + @export(__cmptf2, .{ .name = "__cmptf2", .linkage = linkage }); + @export(__eqtf2, .{ .name = "__eqtf2", .linkage = linkage }); + @export(__lttf2, .{ .name = "__lttf2", .linkage = linkage }); + @export(__gttf2, .{ .name = "__gttf2", .linkage = linkage }); + @export(__netf2, .{ .name = "__netf2", .linkage = linkage }); + + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_fcmpeq, .{ .name = "__aeabi_fcmpeq", .linkage = linkage }); + @export(__aeabi_fcmplt, .{ .name = "__aeabi_fcmplt", .linkage = linkage }); + @export(__aeabi_fcmple, .{ .name = "__aeabi_fcmple", .linkage = linkage }); + @export(__aeabi_fcmpge, .{ .name = "__aeabi_fcmpge", .linkage = linkage }); + @export(__aeabi_fcmpgt, .{ .name = "__aeabi_fcmpgt", .linkage = linkage }); + @export(__aeabi_fcmpun, .{ .name = "__aeabi_fcmpun", .linkage = linkage }); + + @export(__aeabi_dcmpeq, .{ .name = "__aeabi_dcmpeq", .linkage = linkage }); + @export(__aeabi_dcmplt, .{ .name = "__aeabi_dcmplt", .linkage = linkage }); + @export(__aeabi_dcmple, .{ .name = "__aeabi_dcmple", .linkage = linkage }); + @export(__aeabi_dcmpge, .{ .name = "__aeabi_dcmpge", .linkage = linkage }); + @export(__aeabi_dcmpgt, .{ .name = "__aeabi_dcmpgt", .linkage = linkage }); + @export(__aeabi_dcmpun, .{ .name = "__aeabi_dcmpun", .linkage = linkage }); + } + + if (arch.isPPC() or arch.isPPC64()) { + @export(__eqkf2, .{ .name = "__eqkf2", .linkage = linkage }); + @export(__nekf2, .{ .name = "__nekf2", .linkage = linkage }); + @export(__gekf2, .{ .name = "__gekf2", .linkage = linkage }); + @export(__ltkf2, .{ .name = "__ltkf2", .linkage = linkage }); + @export(__lekf2, .{ .name = "__lekf2", .linkage = linkage }); + @export(__gtkf2, .{ .name = "__gtkf2", .linkage = linkage }); + @export(__unordkf2, .{ .name = "__unordkf2", .linkage = linkage }); + } + } +} const LE = enum(i32) { Less = -1, @@ -98,20 +170,24 @@ pub fn __gesf2(a: f32, b: f32) callconv(.C) i32 { return @bitCast(i32, float); } +pub fn __cmpsf2(a: f32, b: f32) callconv(.C) i32 { + return @call(.{ .modifier = .always_inline }, __lesf2, .{ a, b }); +} + pub fn __eqsf2(a: f32, b: f32) callconv(.C) i32 { - return __lesf2(a, b); + return @call(.{ .modifier = .always_inline }, __lesf2, .{ a, b }); } pub fn __ltsf2(a: f32, b: f32) callconv(.C) i32 { - return __lesf2(a, b); + return @call(.{ .modifier = .always_inline }, __lesf2, .{ a, b }); } pub fn __nesf2(a: f32, b: f32) callconv(.C) i32 { - return __lesf2(a, b); + return @call(.{ .modifier = .always_inline }, __lesf2, .{ a, b }); } pub fn __gtsf2(a: f32, b: f32) callconv(.C) i32 { - return __gesf2(a, b); + return @call(.{ .modifier = .always_inline }, __gesf2, .{ a, b }); } // Comparison between f64 @@ -128,20 +204,24 @@ pub fn __gedf2(a: f64, b: f64) callconv(.C) i32 { return @bitCast(i32, float); } +pub fn __cmpdf2(a: f64, b: f64) callconv(.C) i32 { + return @call(.{ .modifier = .always_inline }, __ledf2, .{ a, b }); +} + pub fn __eqdf2(a: f64, b: f64) callconv(.C) i32 { - return __ledf2(a, b); + return @call(.{ .modifier = .always_inline }, __ledf2, .{ a, b }); } pub fn __ltdf2(a: f64, b: f64) callconv(.C) i32 { - return __ledf2(a, b); + return @call(.{ .modifier = .always_inline }, __ledf2, .{ a, b }); } pub fn __nedf2(a: f64, b: f64) callconv(.C) i32 { - return __ledf2(a, b); + return @call(.{ .modifier = .always_inline }, __ledf2, .{ a, b }); } pub fn __gtdf2(a: f64, b: f64) callconv(.C) i32 { - return __gedf2(a, b); + return @call(.{ .modifier = .always_inline }, __gedf2, .{ a, b }); } // Comparison between f80 @@ -196,19 +276,19 @@ pub fn __gexf2(a: f80, b: f80) callconv(.C) i32 { } pub fn __eqxf2(a: f80, b: f80) callconv(.C) i32 { - return __lexf2(a, b); + return @call(.{ .modifier = .always_inline }, __lexf2, .{ a, b }); } pub fn __ltxf2(a: f80, b: f80) callconv(.C) i32 { - return __lexf2(a, b); + return @call(.{ .modifier = .always_inline }, __lexf2, .{ a, b }); } pub fn __nexf2(a: f80, b: f80) callconv(.C) i32 { - return __lexf2(a, b); + return @call(.{ .modifier = .always_inline }, __lexf2, .{ a, b }); } pub fn __gtxf2(a: f80, b: f80) callconv(.C) i32 { - return __gexf2(a, b); + return @call(.{ .modifier = .always_inline }, __gexf2, .{ a, b }); } // Comparison between f128 @@ -225,20 +305,48 @@ pub fn __getf2(a: f128, b: f128) callconv(.C) i32 { return @bitCast(i32, float); } +pub fn __cmptf2(a: f128, b: f128) callconv(.C) i32 { + return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b }); +} + pub fn __eqtf2(a: f128, b: f128) callconv(.C) i32 { - return __letf2(a, b); + return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b }); } pub fn __lttf2(a: f128, b: f128) callconv(.C) i32 { - return __letf2(a, b); + return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b }); } pub fn __netf2(a: f128, b: f128) callconv(.C) i32 { - return __letf2(a, b); + return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b }); } pub fn __gttf2(a: f128, b: f128) callconv(.C) i32 { - return __getf2(a, b); + return @call(.{ .modifier = .always_inline }, __getf2, .{ a, b }); +} + +pub fn __eqkf2(a: f128, b: f128) callconv(.C) i32 { + return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b }); +} + +pub fn __nekf2(a: f128, b: f128) callconv(.C) i32 { + return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b }); +} + +pub fn __gekf2(a: f128, b: f128) callconv(.C) i32 { + return @call(.{ .modifier = .always_inline }, __getf2, .{ a, b }); +} + +pub fn __ltkf2(a: f128, b: f128) callconv(.C) i32 { + return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b }); +} + +pub fn __lekf2(a: f128, b: f128) callconv(.C) i32 { + return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b }); +} + +pub fn __gtkf2(a: f128, b: f128) callconv(.C) i32 { + return @call(.{ .modifier = .always_inline }, __getf2, .{ a, b }); } // Unordered comparison between f32/f64/f128 @@ -258,6 +366,10 @@ pub fn __unordtf2(a: f128, b: f128) callconv(.C) i32 { return unordcmp(f128, a, b); } +pub fn __unordkf2(a: f128, b: f128) callconv(.C) i32 { + return @call(.{ .modifier = .always_inline }, __unordtf2, .{ a, b }); +} + // ARM EABI intrinsics pub fn __aeabi_fcmpeq(a: f32, b: f32) callconv(.AAPCS) i32 { diff --git a/lib/compiler_rt/cos.zig b/lib/compiler_rt/cos.zig index e01f458243..22df0a707d 100644 --- a/lib/compiler_rt/cos.zig +++ b/lib/compiler_rt/cos.zig @@ -1,11 +1,30 @@ const std = @import("std"); +const builtin = @import("builtin"); +const arch = builtin.cpu.arch; const math = std.math; const expect = std.testing.expect; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; 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 = linkage }); + @export(cosf, .{ .name = "cosf", .linkage = linkage }); + @export(cos, .{ .name = "cos", .linkage = linkage }); + @export(__cosx, .{ .name = "__cosx", .linkage = linkage }); + @export(cosq, .{ .name = "cosq", .linkage = linkage }); + @export(cosl, .{ .name = "cosl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(cosf128, .{ .name = "cosf128", .linkage = linkage }); + } + } +} + pub fn __cosh(a: f16) callconv(.C) f16 { // TODO: more efficient implementation return @floatCast(f16, cosf(a)); @@ -107,6 +126,10 @@ pub fn cosq(a: f128) callconv(.C) f128 { return cos(@floatCast(f64, a)); } +pub fn cosf128(a: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, cosq, .{a}); +} + pub fn cosl(x: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __cosh(x), diff --git a/lib/compiler_rt/count0bits.zig b/lib/compiler_rt/count0bits.zig index 1f6d28ae0b..386a5c9657 100644 --- a/lib/compiler_rt/count0bits.zig +++ b/lib/compiler_rt/count0bits.zig @@ -1,5 +1,20 @@ const std = @import("std"); const builtin = @import("builtin"); +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__clzsi2, .{ .name = "__clzsi2", .linkage = linkage }); + @export(__clzdi2, .{ .name = "__clzdi2", .linkage = linkage }); + @export(__clzti2, .{ .name = "__clzti2", .linkage = linkage }); + @export(__ctzsi2, .{ .name = "__ctzsi2", .linkage = linkage }); + @export(__ctzdi2, .{ .name = "__ctzdi2", .linkage = linkage }); + @export(__ctzti2, .{ .name = "__ctzti2", .linkage = linkage }); + @export(__ffssi2, .{ .name = "__ffssi2", .linkage = linkage }); + @export(__ffsdi2, .{ .name = "__ffsdi2", .linkage = linkage }); + @export(__ffsti2, .{ .name = "__ffsti2", .linkage = linkage }); +} // clz - count leading zeroes // - clzXi2 for unoptimized little and big endian diff --git a/lib/compiler_rt/divdf3.zig b/lib/compiler_rt/divdf3.zig index 137f5c02f9..6d626272b5 100644 --- a/lib/compiler_rt/divdf3.zig +++ b/lib/compiler_rt/divdf3.zig @@ -4,6 +4,24 @@ const std = @import("std"); const builtin = @import("builtin"); +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; + +const common = @import("common.zig"); +const normalize = common.normalize; +const wideMultiply = common.wideMultiply; +pub const panic = common.panic; + +comptime { + @export(__divdf3, .{ .name = "__divdf3", .linkage = linkage }); + + if (!is_test) { + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_ddiv, .{ .name = "__aeabi_ddiv", .linkage = linkage }); + } + } +} pub fn __divdf3(a: f64, b: f64) callconv(.C) f64 { @setRuntimeSafety(builtin.is_test); @@ -202,125 +220,6 @@ pub fn __divdf3(a: f64, b: f64) callconv(.C) f64 { } } -pub fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void { - @setRuntimeSafety(builtin.is_test); - switch (Z) { - u32 => { - // 32x32 --> 64 bit multiply - const product = @as(u64, a) * @as(u64, b); - hi.* = @truncate(u32, product >> 32); - lo.* = @truncate(u32, product); - }, - u64 => { - const S = struct { - fn loWord(x: u64) u64 { - return @truncate(u32, x); - } - fn hiWord(x: u64) u64 { - return @truncate(u32, x >> 32); - } - }; - // 64x64 -> 128 wide multiply for platforms that don't have such an operation; - // many 64-bit platforms have this operation, but they tend to have hardware - // floating-point, so we don't bother with a special case for them here. - // Each of the component 32x32 -> 64 products - const plolo: u64 = S.loWord(a) * S.loWord(b); - const plohi: u64 = S.loWord(a) * S.hiWord(b); - const philo: u64 = S.hiWord(a) * S.loWord(b); - const phihi: u64 = S.hiWord(a) * S.hiWord(b); - // Sum terms that contribute to lo in a way that allows us to get the carry - const r0: u64 = S.loWord(plolo); - const r1: u64 = S.hiWord(plolo) +% S.loWord(plohi) +% S.loWord(philo); - lo.* = r0 +% (r1 << 32); - // Sum terms contributing to hi with the carry from lo - hi.* = S.hiWord(plohi) +% S.hiWord(philo) +% S.hiWord(r1) +% phihi; - }, - u128 => { - const Word_LoMask = @as(u64, 0x00000000ffffffff); - const Word_HiMask = @as(u64, 0xffffffff00000000); - const Word_FullMask = @as(u64, 0xffffffffffffffff); - const S = struct { - fn Word_1(x: u128) u64 { - return @truncate(u32, x >> 96); - } - fn Word_2(x: u128) u64 { - return @truncate(u32, x >> 64); - } - fn Word_3(x: u128) u64 { - return @truncate(u32, x >> 32); - } - fn Word_4(x: u128) u64 { - return @truncate(u32, x); - } - }; - // 128x128 -> 256 wide multiply for platforms that don't have such an operation; - // many 64-bit platforms have this operation, but they tend to have hardware - // floating-point, so we don't bother with a special case for them here. - - const product11: u64 = S.Word_1(a) * S.Word_1(b); - const product12: u64 = S.Word_1(a) * S.Word_2(b); - const product13: u64 = S.Word_1(a) * S.Word_3(b); - const product14: u64 = S.Word_1(a) * S.Word_4(b); - const product21: u64 = S.Word_2(a) * S.Word_1(b); - const product22: u64 = S.Word_2(a) * S.Word_2(b); - const product23: u64 = S.Word_2(a) * S.Word_3(b); - const product24: u64 = S.Word_2(a) * S.Word_4(b); - const product31: u64 = S.Word_3(a) * S.Word_1(b); - const product32: u64 = S.Word_3(a) * S.Word_2(b); - const product33: u64 = S.Word_3(a) * S.Word_3(b); - const product34: u64 = S.Word_3(a) * S.Word_4(b); - const product41: u64 = S.Word_4(a) * S.Word_1(b); - const product42: u64 = S.Word_4(a) * S.Word_2(b); - const product43: u64 = S.Word_4(a) * S.Word_3(b); - const product44: u64 = S.Word_4(a) * S.Word_4(b); - - const sum0: u128 = @as(u128, product44); - const sum1: u128 = @as(u128, product34) +% - @as(u128, product43); - const sum2: u128 = @as(u128, product24) +% - @as(u128, product33) +% - @as(u128, product42); - const sum3: u128 = @as(u128, product14) +% - @as(u128, product23) +% - @as(u128, product32) +% - @as(u128, product41); - const sum4: u128 = @as(u128, product13) +% - @as(u128, product22) +% - @as(u128, product31); - const sum5: u128 = @as(u128, product12) +% - @as(u128, product21); - const sum6: u128 = @as(u128, product11); - - const r0: u128 = (sum0 & Word_FullMask) +% - ((sum1 & Word_LoMask) << 32); - const r1: u128 = (sum0 >> 64) +% - ((sum1 >> 32) & Word_FullMask) +% - (sum2 & Word_FullMask) +% - ((sum3 << 32) & Word_HiMask); - - lo.* = r0 +% (r1 << 64); - hi.* = (r1 >> 64) +% - (sum1 >> 96) +% - (sum2 >> 64) +% - (sum3 >> 32) +% - sum4 +% - (sum5 << 32) +% - (sum6 << 64); - }, - else => @compileError("unsupported"), - } -} - -pub fn normalize(comptime T: type, significand: *std.meta.Int(.unsigned, @typeInfo(T).Float.bits)) i32 { - @setRuntimeSafety(builtin.is_test); - const Z = std.meta.Int(.unsigned, @typeInfo(T).Float.bits); - const integerBit = @as(Z, 1) << std.math.floatFractionalBits(T); - - const shift = @clz(Z, significand.*) - @clz(Z, integerBit); - significand.* <<= @intCast(std.math.Log2Int(Z), shift); - return @as(i32, 1) - shift; -} - pub fn __aeabi_ddiv(a: f64, b: f64) callconv(.AAPCS) f64 { @setRuntimeSafety(false); return @call(.{ .modifier = .always_inline }, __divdf3, .{ a, b }); diff --git a/lib/compiler_rt/divsf3.zig b/lib/compiler_rt/divsf3.zig index 5e7dc7bb44..a0c1590eb3 100644 --- a/lib/compiler_rt/divsf3.zig +++ b/lib/compiler_rt/divsf3.zig @@ -4,6 +4,23 @@ const std = @import("std"); const builtin = @import("builtin"); +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; + +const common = @import("common.zig"); +const normalize = common.normalize; +pub const panic = common.panic; + +comptime { + @export(__divsf3, .{ .name = "__divsf3", .linkage = linkage }); + + if (!is_test) { + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_fdiv, .{ .name = "__aeabi_fdiv", .linkage = linkage }); + } + } +} pub fn __divsf3(a: f32, b: f32) callconv(.C) f32 { @setRuntimeSafety(builtin.is_test); @@ -184,17 +201,6 @@ pub fn __divsf3(a: f32, b: f32) callconv(.C) f32 { } } -fn normalize(comptime T: type, significand: *std.meta.Int(.unsigned, @typeInfo(T).Float.bits)) i32 { - @setRuntimeSafety(builtin.is_test); - const Z = std.meta.Int(.unsigned, @typeInfo(T).Float.bits); - const significandBits = std.math.floatMantissaBits(T); - const implicitBit = @as(Z, 1) << significandBits; - - const shift = @clz(Z, significand.*) - @clz(Z, implicitBit); - significand.* <<= @intCast(std.math.Log2Int(Z), shift); - return 1 - shift; -} - pub fn __aeabi_fdiv(a: f32, b: f32) callconv(.AAPCS) f32 { @setRuntimeSafety(false); return @call(.{ .modifier = .always_inline }, __divsf3, .{ a, b }); diff --git a/lib/compiler_rt/divtf3.zig b/lib/compiler_rt/divtf3.zig index fc26c60266..436db41dc2 100644 --- a/lib/compiler_rt/divtf3.zig +++ b/lib/compiler_rt/divtf3.zig @@ -1,8 +1,27 @@ const std = @import("std"); const builtin = @import("builtin"); +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; -const normalize = @import("divdf3.zig").normalize; -const wideMultiply = @import("divdf3.zig").wideMultiply; +const common = @import("common.zig"); +const normalize = common.normalize; +const wideMultiply = common.wideMultiply; +pub const panic = common.panic; + +comptime { + @export(__divtf3, .{ .name = "__divtf3", .linkage = linkage }); + + if (!is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(__divkf3, .{ .name = "__divkf3", .linkage = linkage }); + } + } +} + +pub fn __divkf3(a: f128, b: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, __divtf3, .{ a, b }); +} pub fn __divtf3(a: f128, b: f128) callconv(.C) f128 { @setRuntimeSafety(builtin.is_test); diff --git a/lib/compiler_rt/divti3.zig b/lib/compiler_rt/divti3.zig index 41286c3414..20da8d3e1d 100644 --- a/lib/compiler_rt/divti3.zig +++ b/lib/compiler_rt/divti3.zig @@ -1,5 +1,31 @@ -const udivmod = @import("udivmod.zig").udivmod; +const std = @import("std"); const builtin = @import("builtin"); +const udivmod = @import("udivmod.zig").udivmod; +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + if (builtin.os.tag == .windows) { + switch (arch) { + .i386 => { + @export(__divti3, .{ .name = "__divti3", .linkage = linkage }); + }, + .x86_64 => { + // The "ti" functions must use Vector(2, u64) parameter types to adhere to the ABI + // that LLVM expects compiler-rt to have. + @export(__divti3_windows_x86_64, .{ .name = "__divti3", .linkage = linkage }); + }, + else => {}, + } + if (arch.isAARCH64()) { + @export(__divti3, .{ .name = "__divti3", .linkage = linkage }); + } + } else { + @export(__divti3, .{ .name = "__divti3", .linkage = linkage }); + } +} pub fn __divti3(a: i128, b: i128) callconv(.C) i128 { @setRuntimeSafety(builtin.is_test); diff --git a/lib/compiler_rt/divxf3.zig b/lib/compiler_rt/divxf3.zig index 5f5ed667ec..56811dfc8f 100644 --- a/lib/compiler_rt/divxf3.zig +++ b/lib/compiler_rt/divxf3.zig @@ -1,7 +1,17 @@ const std = @import("std"); const builtin = @import("builtin"); -const normalize = @import("divdf3.zig").normalize; -const wideMultiply = @import("divdf3.zig").wideMultiply; +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; + +const common = @import("common.zig"); +const normalize = common.normalize; +const wideMultiply = common.wideMultiply; +pub const panic = common.panic; + +comptime { + @export(__divxf3, .{ .name = "__divxf3", .linkage = linkage }); +} pub fn __divxf3(a: f80, b: f80) callconv(.C) f80 { @setRuntimeSafety(builtin.is_test); diff --git a/lib/compiler_rt/emutls.zig b/lib/compiler_rt/emutls.zig index e6aa8930e9..7483177e0f 100644 --- a/lib/compiler_rt/emutls.zig +++ b/lib/compiler_rt/emutls.zig @@ -6,6 +6,8 @@ const std = @import("std"); const builtin = @import("builtin"); +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; const abort = std.os.abort; const assert = std.debug.assert; @@ -16,7 +18,9 @@ const expect = std.testing.expect; const gcc_word = usize; comptime { - assert(builtin.link_libc); + if (builtin.link_libc and builtin.os.tag == .openbsd) { + @export(__emutls_get_address, .{ .name = "__emutls_get_address", .linkage = linkage }); + } } /// public entrypoint for generated code using EmulatedTLS @@ -319,6 +323,8 @@ const emutls_control = extern struct { }; test "simple_allocator" { + if (!builtin.link_libc or builtin.os.tag != .openbsd) return error.SkipZigTest; + var data1: *[64]u8 = simple_allocator.alloc([64]u8); defer simple_allocator.free(data1); for (data1) |*c| { @@ -333,6 +339,8 @@ test "simple_allocator" { } test "__emutls_get_address zeroed" { + if (!builtin.link_libc or builtin.os.tag != .openbsd) return error.SkipZigTest; + var ctl = emutls_control.init(usize, null); try expect(ctl.object.index == 0); @@ -352,6 +360,8 @@ test "__emutls_get_address zeroed" { } test "__emutls_get_address with default_value" { + if (!builtin.link_libc or builtin.os.tag != .openbsd) return error.SkipZigTest; + var value: usize = 5678; // default value var ctl = emutls_control.init(usize, &value); try expect(ctl.object.index == 0); @@ -370,6 +380,8 @@ test "__emutls_get_address with default_value" { } test "test default_value with differents sizes" { + if (!builtin.link_libc or builtin.os.tag != .openbsd) return error.SkipZigTest; + const testType = struct { fn _testType(comptime T: type, value: T) !void { var def: T = value; diff --git a/lib/compiler_rt/exp.zig b/lib/compiler_rt/exp.zig index a2c5d0e550..c7f6c95da6 100644 --- a/lib/compiler_rt/exp.zig +++ b/lib/compiler_rt/exp.zig @@ -5,8 +5,27 @@ // 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 math = std.math; const expect = std.testing.expect; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__exph, .{ .name = "__exph", .linkage = linkage }); + @export(expf, .{ .name = "expf", .linkage = linkage }); + @export(exp, .{ .name = "exp", .linkage = linkage }); + @export(__expx, .{ .name = "__expx", .linkage = linkage }); + @export(expq, .{ .name = "expq", .linkage = linkage }); + @export(expl, .{ .name = "expl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(expf128, .{ .name = "expf128", .linkage = linkage }); + } + } +} pub fn __exph(a: f16) callconv(.C) f16 { // TODO: more efficient implementation @@ -182,6 +201,10 @@ pub fn expq(a: f128) callconv(.C) f128 { return exp(@floatCast(f64, a)); } +pub fn expf128(a: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, expq, .{a}); +} + pub fn expl(x: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __exph(x), diff --git a/lib/compiler_rt/exp2.zig b/lib/compiler_rt/exp2.zig index cbcb53c99f..614df2cec0 100644 --- a/lib/compiler_rt/exp2.zig +++ b/lib/compiler_rt/exp2.zig @@ -5,8 +5,27 @@ // https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c const std = @import("std"); +const builtin = @import("builtin"); +const arch = builtin.cpu.arch; const math = std.math; const expect = std.testing.expect; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__exp2h, .{ .name = "__exp2h", .linkage = linkage }); + @export(exp2f, .{ .name = "exp2f", .linkage = linkage }); + @export(exp2, .{ .name = "exp2", .linkage = linkage }); + @export(__exp2x, .{ .name = "__exp2x", .linkage = linkage }); + @export(exp2q, .{ .name = "exp2q", .linkage = linkage }); + @export(exp2l, .{ .name = "exp2l", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(exp2f128, .{ .name = "exp2f128", .linkage = linkage }); + } + } +} pub fn __exp2h(x: f16) callconv(.C) f16 { // TODO: more efficient implementation @@ -149,6 +168,10 @@ pub fn exp2q(x: f128) callconv(.C) f128 { return exp2(@floatCast(f64, x)); } +pub fn exp2f128(x: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, exp2q, .{x}); +} + pub fn exp2l(x: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __exp2h(x), diff --git a/lib/compiler_rt/extendXfYf2.zig b/lib/compiler_rt/extendXfYf2.zig index 8622fe1513..bb21e5f681 100644 --- a/lib/compiler_rt/extendXfYf2.zig +++ b/lib/compiler_rt/extendXfYf2.zig @@ -1,7 +1,31 @@ const std = @import("std"); const builtin = @import("builtin"); const is_test = builtin.is_test; -const native_arch = builtin.cpu.arch; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__extenddftf2, .{ .name = "__extenddftf2", .linkage = linkage }); + @export(__extendsftf2, .{ .name = "__extendsftf2", .linkage = linkage }); + @export(__extendhfsf2, .{ .name = "__extendhfsf2", .linkage = linkage }); + @export(__extendhftf2, .{ .name = "__extendhftf2", .linkage = linkage }); + @export(__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = linkage }); + + if (!is_test) { + @export(__gnu_h2f_ieee, .{ .name = "__gnu_h2f_ieee", .linkage = linkage }); + + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_f2d, .{ .name = "__aeabi_f2d", .linkage = linkage }); + @export(__aeabi_h2f, .{ .name = "__aeabi_h2f", .linkage = linkage }); + } + + if (arch.isPPC() or arch.isPPC64()) { + @export(__extendsfkf2, .{ .name = "__extendsfkf2", .linkage = linkage }); + @export(__extenddfkf2, .{ .name = "__extenddfkf2", .linkage = linkage }); + } + } +} pub fn __extendsfdf2(a: f32) callconv(.C) f64 { return extendXfYf2(f64, f32, @bitCast(u32, a)); @@ -11,18 +35,30 @@ pub fn __extenddftf2(a: f64) callconv(.C) f128 { return extendXfYf2(f128, f64, @bitCast(u64, a)); } +pub fn __extenddfkf2(a: f64) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, __extenddftf2, .{a}); +} + pub fn __extendsftf2(a: f32) callconv(.C) f128 { return extendXfYf2(f128, f32, @bitCast(u32, a)); } +pub fn __extendsfkf2(a: f32) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, __extendsftf2, .{a}); +} + // AArch64 is the only ABI (at the moment) to support f16 arguments without the // need for extending them to wider fp types. -pub const F16T = if (native_arch.isAARCH64()) f16 else u16; +pub const F16T = if (arch.isAARCH64()) f16 else u16; pub fn __extendhfsf2(a: F16T) callconv(.C) f32 { return extendXfYf2(f32, f16, @bitCast(u16, a)); } +pub fn __gnu_h2f_ieee(a: F16T) callconv(.C) f32 { + return @call(.{ .modifier = .always_inline }, __extendhfsf2, .{a}); +} + pub fn __extendhftf2(a: F16T) callconv(.C) f128 { return extendXfYf2(f128, f16, @bitCast(u16, a)); } diff --git a/lib/compiler_rt/extend_f80.zig b/lib/compiler_rt/extend_f80.zig index e68fb5fcf8..fe5a38fc68 100644 --- a/lib/compiler_rt/extend_f80.zig +++ b/lib/compiler_rt/extend_f80.zig @@ -1,21 +1,30 @@ const std = @import("std"); const builtin = @import("builtin"); const is_test = builtin.is_test; -const native_arch = builtin.cpu.arch; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__extendhfxf2, .{ .name = "__extendhfxf2", .linkage = linkage }); + @export(__extendsfxf2, .{ .name = "__extendsfxf2", .linkage = linkage }); + @export(__extenddfxf2, .{ .name = "__extenddfxf2", .linkage = linkage }); + @export(__extendxftf2, .{ .name = "__extendxftf2", .linkage = linkage }); +} // AArch64 is the only ABI (at the moment) to support f16 arguments without the // need for extending them to wider fp types. -pub const F16T = if (native_arch.isAARCH64()) f16 else u16; +const F16T = if (arch.isAARCH64()) f16 else u16; -pub fn __extendhfxf2(a: F16T) callconv(.C) f80 { +fn __extendhfxf2(a: F16T) callconv(.C) f80 { return extendF80(f16, @bitCast(u16, a)); } -pub fn __extendsfxf2(a: f32) callconv(.C) f80 { +fn __extendsfxf2(a: f32) callconv(.C) f80 { return extendF80(f32, @bitCast(u32, a)); } -pub fn __extenddfxf2(a: f64) callconv(.C) f80 { +fn __extenddfxf2(a: f64) callconv(.C) f80 { return extendF80(f64, @bitCast(u64, a)); } @@ -86,7 +95,7 @@ inline fn extendF80(comptime src_t: type, a: std.meta.Int(.unsigned, @typeInfo(s return std.math.make_f80(dst); } -pub fn __extendxftf2(a: f80) callconv(.C) f128 { +fn __extendxftf2(a: f80) callconv(.C) f128 { @setRuntimeSafety(builtin.is_test); const src_int_bit: u64 = 0x8000000000000000; diff --git a/lib/compiler_rt/fabs.zig b/lib/compiler_rt/fabs.zig index 396fdd46b7..afe231f098 100644 --- a/lib/compiler_rt/fabs.zig +++ b/lib/compiler_rt/fabs.zig @@ -1,4 +1,23 @@ const std = @import("std"); +const builtin = @import("builtin"); +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__fabsh, .{ .name = "__fabsh", .linkage = linkage }); + @export(fabsf, .{ .name = "fabsf", .linkage = linkage }); + @export(fabs, .{ .name = "fabs", .linkage = linkage }); + @export(__fabsx, .{ .name = "__fabsx", .linkage = linkage }); + @export(fabsq, .{ .name = "fabsq", .linkage = linkage }); + @export(fabsl, .{ .name = "fabsl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(fabsf128, .{ .name = "fabsf128", .linkage = linkage }); + } + } +} pub fn __fabsh(a: f16) callconv(.C) f16 { return generic_fabs(a); @@ -20,6 +39,10 @@ pub fn fabsq(a: f128) callconv(.C) f128 { return generic_fabs(a); } +pub fn fabsf128(a: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, fabsq, .{a}); +} + pub fn fabsl(x: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __fabsh(x), diff --git a/lib/compiler_rt/fixXfYi.zig b/lib/compiler_rt/fixXfYi.zig index 01832ec56f..c568bba366 100644 --- a/lib/compiler_rt/fixXfYi.zig +++ b/lib/compiler_rt/fixXfYi.zig @@ -1,7 +1,79 @@ const std = @import("std"); +const builtin = @import("builtin"); const math = std.math; const Log2Int = math.Log2Int; -const is_test = @import("builtin").is_test; +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + // Float -> Integral Conversion + + // Conversion from f32 + @export(__fixsfsi, .{ .name = "__fixsfsi", .linkage = linkage }); + @export(__fixunssfsi, .{ .name = "__fixunssfsi", .linkage = linkage }); + + @export(__fixsfdi, .{ .name = "__fixsfdi", .linkage = linkage }); + @export(__fixunssfdi, .{ .name = "__fixunssfdi", .linkage = linkage }); + + @export(__fixsfti, .{ .name = "__fixsfti", .linkage = linkage }); + @export(__fixunssfti, .{ .name = "__fixunssfti", .linkage = linkage }); + + // Conversion from f64 + @export(__fixdfsi, .{ .name = "__fixdfsi", .linkage = linkage }); + @export(__fixunsdfsi, .{ .name = "__fixunsdfsi", .linkage = linkage }); + + @export(__fixdfdi, .{ .name = "__fixdfdi", .linkage = linkage }); + @export(__fixunsdfdi, .{ .name = "__fixunsdfdi", .linkage = linkage }); + + @export(__fixdfti, .{ .name = "__fixdfti", .linkage = linkage }); + @export(__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = linkage }); + + // Conversion from f80 + @export(__fixxfsi, .{ .name = "__fixxfsi", .linkage = linkage }); + @export(__fixunsxfsi, .{ .name = "__fixunsxfsi", .linkage = linkage }); + + @export(__fixxfdi, .{ .name = "__fixxfdi", .linkage = linkage }); + @export(__fixunsxfdi, .{ .name = "__fixunsxfdi", .linkage = linkage }); + + @export(__fixxfti, .{ .name = "__fixxfti", .linkage = linkage }); + @export(__fixunsxfti, .{ .name = "__fixunsxfti", .linkage = linkage }); + + // Conversion from f128 + @export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = linkage }); + @export(__fixunstfsi, .{ .name = "__fixunstfsi", .linkage = linkage }); + + @export(__fixtfdi, .{ .name = "__fixtfdi", .linkage = linkage }); + @export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = linkage }); + + @export(__fixtfti, .{ .name = "__fixtfti", .linkage = linkage }); + @export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = linkage }); + + if (!is_test) { + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_f2ulz, .{ .name = "__aeabi_f2ulz", .linkage = linkage }); + @export(__aeabi_d2ulz, .{ .name = "__aeabi_d2ulz", .linkage = linkage }); + + @export(__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = linkage }); + @export(__aeabi_d2lz, .{ .name = "__aeabi_d2lz", .linkage = linkage }); + + @export(__aeabi_d2uiz, .{ .name = "__aeabi_d2uiz", .linkage = linkage }); + + @export(__aeabi_f2uiz, .{ .name = "__aeabi_f2uiz", .linkage = linkage }); + + @export(__aeabi_f2iz, .{ .name = "__aeabi_f2iz", .linkage = linkage }); + @export(__aeabi_d2iz, .{ .name = "__aeabi_d2iz", .linkage = linkage }); + } + + if (arch.isPPC() or arch.isPPC64()) { + @export(__fixkfdi, .{ .name = "__fixkfdi", .linkage = linkage }); + @export(__fixkfsi, .{ .name = "__fixkfsi", .linkage = linkage }); + @export(__fixunskfsi, .{ .name = "__fixunskfsi", .linkage = linkage }); + @export(__fixunskfdi, .{ .name = "__fixunskfdi", .linkage = linkage }); + } + } +} pub inline fn fixXfYi(comptime I: type, a: anytype) I { @setRuntimeSafety(is_test); @@ -163,18 +235,34 @@ pub fn __fixtfsi(a: f128) callconv(.C) i32 { return fixXfYi(i32, a); } +pub fn __fixkfsi(a: f128) callconv(.C) i32 { + return __fixtfsi(a); +} + pub fn __fixunstfsi(a: f128) callconv(.C) u32 { return fixXfYi(u32, a); } +pub fn __fixunskfsi(a: f128) callconv(.C) u32 { + return @call(.{ .modifier = .always_inline }, __fixunstfsi, .{a}); +} + pub fn __fixtfdi(a: f128) callconv(.C) i64 { return fixXfYi(i64, a); } +pub fn __fixkfdi(a: f128) callconv(.C) i64 { + return @call(.{ .modifier = .always_inline }, __fixtfdi, .{a}); +} + pub fn __fixunstfdi(a: f128) callconv(.C) u64 { return fixXfYi(u64, a); } +pub fn __fixunskfdi(a: f128) callconv(.C) u64 { + return @call(.{ .modifier = .always_inline }, __fixunstfdi, .{a}); +} + pub fn __fixtfti(a: f128) callconv(.C) i128 { return fixXfYi(i128, a); } diff --git a/lib/compiler_rt/floatXiYf.zig b/lib/compiler_rt/floatXiYf.zig index 068413f715..25f5743491 100644 --- a/lib/compiler_rt/floatXiYf.zig +++ b/lib/compiler_rt/floatXiYf.zig @@ -1,8 +1,77 @@ const builtin = @import("builtin"); -const is_test = builtin.is_test; const std = @import("std"); const math = std.math; const expect = std.testing.expect; +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + // Integral -> Float Conversion + + // Conversion to f32 + @export(__floatsisf, .{ .name = "__floatsisf", .linkage = linkage }); + @export(__floatunsisf, .{ .name = "__floatunsisf", .linkage = linkage }); + + @export(__floatundisf, .{ .name = "__floatundisf", .linkage = linkage }); + @export(__floatdisf, .{ .name = "__floatdisf", .linkage = linkage }); + + @export(__floattisf, .{ .name = "__floattisf", .linkage = linkage }); + @export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = linkage }); + + // Conversion to f64 + @export(__floatsidf, .{ .name = "__floatsidf", .linkage = linkage }); + @export(__floatunsidf, .{ .name = "__floatunsidf", .linkage = linkage }); + + @export(__floatdidf, .{ .name = "__floatdidf", .linkage = linkage }); + @export(__floatundidf, .{ .name = "__floatundidf", .linkage = linkage }); + + @export(__floattidf, .{ .name = "__floattidf", .linkage = linkage }); + @export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = linkage }); + + // Conversion to f80 + @export(__floatsixf, .{ .name = "__floatsixf", .linkage = linkage }); + @export(__floatunsixf, .{ .name = "__floatunsixf", .linkage = linkage }); + + @export(__floatdixf, .{ .name = "__floatdixf", .linkage = linkage }); + @export(__floatundixf, .{ .name = "__floatundixf", .linkage = linkage }); + + @export(__floattixf, .{ .name = "__floattixf", .linkage = linkage }); + @export(__floatuntixf, .{ .name = "__floatuntixf", .linkage = linkage }); + + // Conversion to f128 + @export(__floatsitf, .{ .name = "__floatsitf", .linkage = linkage }); + @export(__floatunsitf, .{ .name = "__floatunsitf", .linkage = linkage }); + + @export(__floatditf, .{ .name = "__floatditf", .linkage = linkage }); + @export(__floatunditf, .{ .name = "__floatunditf", .linkage = linkage }); + + @export(__floattitf, .{ .name = "__floattitf", .linkage = linkage }); + @export(__floatuntitf, .{ .name = "__floatuntitf", .linkage = linkage }); + + if (!is_test) { + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_i2d, .{ .name = "__aeabi_i2d", .linkage = linkage }); + @export(__aeabi_l2d, .{ .name = "__aeabi_l2d", .linkage = linkage }); + @export(__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = linkage }); + @export(__aeabi_ui2d, .{ .name = "__aeabi_ui2d", .linkage = linkage }); + @export(__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = linkage }); + @export(__aeabi_ui2f, .{ .name = "__aeabi_ui2f", .linkage = linkage }); + @export(__aeabi_ul2f, .{ .name = "__aeabi_ul2f", .linkage = linkage }); + + @export(__aeabi_i2f, .{ .name = "__aeabi_i2f", .linkage = linkage }); + } + + if (arch.isPPC() or arch.isPPC64()) { + @export(__floatsikf, .{ .name = "__floatsikf", .linkage = linkage }); + @export(__floatdikf, .{ .name = "__floatdikf", .linkage = linkage }); + @export(__floatundikf, .{ .name = "__floatundikf", .linkage = linkage }); + @export(__floatunsikf, .{ .name = "__floatunsikf", .linkage = linkage }); + @export(__floatuntikf, .{ .name = "__floatuntikf", .linkage = linkage }); + } + } +} pub fn floatXiYf(comptime T: type, x: anytype) T { @setRuntimeSafety(is_test); @@ -163,18 +232,34 @@ pub fn __floatsitf(a: i32) callconv(.C) f128 { return floatXiYf(f128, a); } +pub fn __floatsikf(a: i32) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, __floatsitf, .{a}); +} + pub fn __floatunsitf(a: u32) callconv(.C) f128 { return floatXiYf(f128, a); } +pub fn __floatunsikf(a: u32) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, __floatunsitf, .{a}); +} + pub fn __floatditf(a: i64) callconv(.C) f128 { return floatXiYf(f128, a); } +pub fn __floatdikf(a: i64) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, __floatditf, .{a}); +} + pub fn __floatunditf(a: u64) callconv(.C) f128 { return floatXiYf(f128, a); } +pub fn __floatundikf(a: u64) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, __floatunditf, .{a}); +} + pub fn __floattitf(a: i128) callconv(.C) f128 { return floatXiYf(f128, a); } @@ -183,6 +268,10 @@ pub fn __floatuntitf(a: u128) callconv(.C) f128 { return floatXiYf(f128, a); } +pub fn __floatuntikf(a: u128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, __floatuntitf, .{a}); +} + // Conversion to f32 pub fn __aeabi_ui2f(arg: u32) callconv(.AAPCS) f32 { return floatXiYf(f32, arg); diff --git a/lib/compiler_rt/floor.zig b/lib/compiler_rt/floor.zig index 783898fca7..f4b1c2fea4 100644 --- a/lib/compiler_rt/floor.zig +++ b/lib/compiler_rt/floor.zig @@ -5,8 +5,27 @@ // https://git.musl-libc.org/cgit/musl/tree/src/math/floor.c const std = @import("std"); +const builtin = @import("builtin"); const math = std.math; const expect = std.testing.expect; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__floorh, .{ .name = "__floorh", .linkage = linkage }); + @export(floorf, .{ .name = "floorf", .linkage = linkage }); + @export(floor, .{ .name = "floor", .linkage = linkage }); + @export(__floorx, .{ .name = "__floorx", .linkage = linkage }); + @export(floorq, .{ .name = "floorq", .linkage = linkage }); + @export(floorl, .{ .name = "floorl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(floorf128, .{ .name = "floorf128", .linkage = linkage }); + } + } +} pub fn __floorh(x: f16) callconv(.C) f16 { var u = @bitCast(u16, x); @@ -141,6 +160,10 @@ pub fn floorq(x: f128) callconv(.C) f128 { } } +pub fn floorf128(x: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, floorq, .{x}); +} + pub fn floorl(x: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __floorh(x), diff --git a/lib/compiler_rt/fma.zig b/lib/compiler_rt/fma.zig index b121db212c..98e77e536c 100644 --- a/lib/compiler_rt/fma.zig +++ b/lib/compiler_rt/fma.zig @@ -6,8 +6,27 @@ // https://git.musl-libc.org/cgit/musl/tree/src/math/fma.c const std = @import("std"); +const builtin = @import("builtin"); const math = std.math; const expect = std.testing.expect; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__fmah, .{ .name = "__fmah", .linkage = linkage }); + @export(fmaf, .{ .name = "fmaf", .linkage = linkage }); + @export(fma, .{ .name = "fma", .linkage = linkage }); + @export(__fmax, .{ .name = "__fmax", .linkage = linkage }); + @export(fmaq, .{ .name = "fmaq", .linkage = linkage }); + @export(fmal, .{ .name = "fmal", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(fmaf128, .{ .name = "fmaf128", .linkage = linkage }); + } + } +} pub fn __fmah(x: f16, y: f16, z: f16) callconv(.C) f16 { // TODO: more efficient implementation @@ -135,6 +154,10 @@ pub fn fmaq(x: f128, y: f128, z: f128) callconv(.C) f128 { } } +pub fn fmaf128(x: f128, y: f128, z: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, fmaq, .{ x, y, z }); +} + pub fn fmal(x: c_longdouble, y: c_longdouble, z: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __fmah(x, y, z), diff --git a/lib/compiler_rt/fmax.zig b/lib/compiler_rt/fmax.zig index defc935afc..50c2ab5269 100644 --- a/lib/compiler_rt/fmax.zig +++ b/lib/compiler_rt/fmax.zig @@ -1,5 +1,24 @@ const std = @import("std"); +const builtin = @import("builtin"); const math = std.math; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__fmaxh, .{ .name = "__fmaxh", .linkage = linkage }); + @export(fmaxf, .{ .name = "fmaxf", .linkage = linkage }); + @export(fmax, .{ .name = "fmax", .linkage = linkage }); + @export(__fmaxx, .{ .name = "__fmaxx", .linkage = linkage }); + @export(fmaxq, .{ .name = "fmaxq", .linkage = linkage }); + @export(fmaxl, .{ .name = "fmaxl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(fmaxf128, .{ .name = "fmaxf128", .linkage = linkage }); + } + } +} pub fn __fmaxh(x: f16, y: f16) callconv(.C) f16 { return generic_fmax(f16, x, y); @@ -21,6 +40,10 @@ pub fn fmaxq(x: f128, y: f128) callconv(.C) f128 { return generic_fmax(f128, x, y); } +pub fn fmaxf128(x: f128, y: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, fmaxq, .{ x, y }); +} + pub fn fmaxl(x: c_longdouble, y: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __fmaxh(x, y), diff --git a/lib/compiler_rt/fmin.zig b/lib/compiler_rt/fmin.zig index e93300bd4b..b4960d0544 100644 --- a/lib/compiler_rt/fmin.zig +++ b/lib/compiler_rt/fmin.zig @@ -1,5 +1,24 @@ const std = @import("std"); +const builtin = @import("builtin"); const math = std.math; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__fminh, .{ .name = "__fminh", .linkage = linkage }); + @export(fminf, .{ .name = "fminf", .linkage = linkage }); + @export(fmin, .{ .name = "fmin", .linkage = linkage }); + @export(__fminx, .{ .name = "__fminx", .linkage = linkage }); + @export(fminq, .{ .name = "fminq", .linkage = linkage }); + @export(fminl, .{ .name = "fminl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(fminf128, .{ .name = "fminf128", .linkage = linkage }); + } + } +} pub fn __fminh(x: f16, y: f16) callconv(.C) f16 { return generic_fmin(f16, x, y); @@ -21,6 +40,10 @@ pub fn fminq(x: f128, y: f128) callconv(.C) f128 { return generic_fmin(f128, x, y); } +pub fn fminf128(x: f128, y: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, fminq, .{ x, y }); +} + pub fn fminl(x: c_longdouble, y: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __fminh(x, y), diff --git a/lib/compiler_rt/fmod.zig b/lib/compiler_rt/fmod.zig index 5d413ca37d..0f4c088777 100644 --- a/lib/compiler_rt/fmod.zig +++ b/lib/compiler_rt/fmod.zig @@ -2,7 +2,27 @@ const builtin = @import("builtin"); const std = @import("std"); const math = std.math; const assert = std.debug.assert; -const normalize = @import("divdf3.zig").normalize; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; + +const common = @import("common.zig"); +const normalize = common.normalize; +pub const panic = common.panic; + +comptime { + @export(__fmodh, .{ .name = "__fmodh", .linkage = linkage }); + @export(fmodf, .{ .name = "fmodf", .linkage = linkage }); + @export(fmod, .{ .name = "fmod", .linkage = linkage }); + @export(__fmodx, .{ .name = "__fmodx", .linkage = linkage }); + @export(fmodq, .{ .name = "fmodq", .linkage = linkage }); + @export(fmodl, .{ .name = "fmodl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(fmodf128, .{ .name = "fmodf128", .linkage = linkage }); + } + } +} pub fn __fmodh(x: f16, y: f16) callconv(.C) f16 { // TODO: more efficient implementation @@ -237,6 +257,10 @@ pub fn fmodq(a: f128, b: f128) callconv(.C) f128 { return amod; } +pub fn fmodf128(a: f128, b: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, fmodq, .{ a, b }); +} + pub fn fmodl(a: c_longdouble, b: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __fmodh(a, b), diff --git a/lib/compiler_rt/int.zig b/lib/compiler_rt/int.zig index 0f3400d37e..447f867267 100644 --- a/lib/compiler_rt/int.zig +++ b/lib/compiler_rt/int.zig @@ -4,9 +4,36 @@ const std = @import("std"); const testing = std.testing; const maxInt = std.math.maxInt; const minInt = std.math.minInt; +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; const udivmod = @import("udivmod.zig").udivmod; +comptime { + @export(__udivmoddi4, .{ .name = "__udivmoddi4", .linkage = linkage }); + @export(__mulsi3, .{ .name = "__mulsi3", .linkage = linkage }); + @export(__divmoddi4, .{ .name = "__divmoddi4", .linkage = linkage }); + @export(__divsi3, .{ .name = "__divsi3", .linkage = linkage }); + @export(__divdi3, .{ .name = "__divdi3", .linkage = linkage }); + @export(__udivsi3, .{ .name = "__udivsi3", .linkage = linkage }); + @export(__udivdi3, .{ .name = "__udivdi3", .linkage = linkage }); + @export(__modsi3, .{ .name = "__modsi3", .linkage = linkage }); + @export(__moddi3, .{ .name = "__moddi3", .linkage = linkage }); + @export(__umodsi3, .{ .name = "__umodsi3", .linkage = linkage }); + @export(__umoddi3, .{ .name = "__umoddi3", .linkage = linkage }); + @export(__divmodsi4, .{ .name = "__divmodsi4", .linkage = linkage }); + @export(__udivmodsi4, .{ .name = "__udivmodsi4", .linkage = linkage }); + + if (!is_test) { + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_idiv, .{ .name = "__aeabi_idiv", .linkage = linkage }); + @export(__aeabi_uidiv, .{ .name = "__aeabi_uidiv", .linkage = linkage }); + } + } +} + pub fn __divmoddi4(a: i64, b: i64, rem: *i64) callconv(.C) i64 { @setRuntimeSafety(builtin.is_test); @@ -187,6 +214,10 @@ pub fn __divsi3(n: i32, d: i32) callconv(.C) i32 { return @bitCast(i32, (res ^ sign) -% sign); } +pub fn __aeabi_idiv(n: i32, d: i32) callconv(.C) i32 { + return @call(.{ .modifier = .always_inline }, __divsi3, .{ n, d }); +} + test "test_divsi3" { const cases = [_][3]i32{ [_]i32{ 0, 1, 0 }, @@ -253,6 +284,10 @@ pub fn __udivsi3(n: u32, d: u32) callconv(.C) u32 { return q; } +pub fn __aeabi_uidiv(n: u32, d: u32) callconv(.C) u32 { + return @call(.{ .modifier = .always_inline }, __udivsi3, .{ n, d }); +} + test "test_udivsi3" { const cases = [_][3]u32{ [_]u32{ 0x00000000, 0x00000001, 0x00000000 }, diff --git a/lib/compiler_rt/log.zig b/lib/compiler_rt/log.zig index 6e705dae60..991c94ef27 100644 --- a/lib/compiler_rt/log.zig +++ b/lib/compiler_rt/log.zig @@ -5,8 +5,27 @@ // https://git.musl-libc.org/cgit/musl/tree/src/math/ln.c const std = @import("std"); +const builtin = @import("builtin"); const math = std.math; const testing = std.testing; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__logh, .{ .name = "__logh", .linkage = linkage }); + @export(logf, .{ .name = "logf", .linkage = linkage }); + @export(log, .{ .name = "log", .linkage = linkage }); + @export(__logx, .{ .name = "__logx", .linkage = linkage }); + @export(logq, .{ .name = "logq", .linkage = linkage }); + @export(logl, .{ .name = "logl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(logf128, .{ .name = "logf128", .linkage = linkage }); + } + } +} pub fn __logh(a: f16) callconv(.C) f16 { // TODO: more efficient implementation @@ -131,6 +150,10 @@ pub fn logq(a: f128) callconv(.C) f128 { return log(@floatCast(f64, a)); } +pub fn logf128(a: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, logq, .{a}); +} + pub fn logl(x: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __logh(x), diff --git a/lib/compiler_rt/log10.zig b/lib/compiler_rt/log10.zig index 47499d2739..8031879761 100644 --- a/lib/compiler_rt/log10.zig +++ b/lib/compiler_rt/log10.zig @@ -5,9 +5,28 @@ // 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 testing = std.testing; const maxInt = std.math.maxInt; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__log10h, .{ .name = "__log10h", .linkage = linkage }); + @export(log10f, .{ .name = "log10f", .linkage = linkage }); + @export(log10, .{ .name = "log10", .linkage = linkage }); + @export(__log10x, .{ .name = "__log10x", .linkage = linkage }); + @export(log10q, .{ .name = "log10q", .linkage = linkage }); + @export(log10l, .{ .name = "log10l", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(log10f128, .{ .name = "log10f128", .linkage = linkage }); + } + } +} pub fn __log10h(a: f16) callconv(.C) f16 { // TODO: more efficient implementation @@ -159,6 +178,10 @@ pub fn log10q(a: f128) callconv(.C) f128 { return log10(@floatCast(f64, a)); } +pub fn log10f128(a: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, log10q, .{a}); +} + pub fn log10l(x: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __log10h(x), diff --git a/lib/compiler_rt/log2.zig b/lib/compiler_rt/log2.zig index aa294b33fd..d2a1dd1189 100644 --- a/lib/compiler_rt/log2.zig +++ b/lib/compiler_rt/log2.zig @@ -5,9 +5,28 @@ // https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c const std = @import("std"); +const builtin = @import("builtin"); const math = std.math; const expect = std.testing.expect; const maxInt = std.math.maxInt; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__log2h, .{ .name = "__log2h", .linkage = linkage }); + @export(log2f, .{ .name = "log2f", .linkage = linkage }); + @export(log2, .{ .name = "log2", .linkage = linkage }); + @export(__log2x, .{ .name = "__log2x", .linkage = linkage }); + @export(log2q, .{ .name = "log2q", .linkage = linkage }); + @export(log2l, .{ .name = "log2l", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(log2f128, .{ .name = "log2f128", .linkage = linkage }); + } + } +} pub fn __log2h(a: f16) callconv(.C) f16 { // TODO: more efficient implementation @@ -151,6 +170,10 @@ pub fn log2q(a: f128) callconv(.C) f128 { return log2(@floatCast(f64, a)); } +pub fn log2f128(a: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, log2q, .{a}); +} + pub fn log2l(x: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __log2h(x), diff --git a/lib/compiler_rt/modti3.zig b/lib/compiler_rt/modti3.zig index 42cbda9627..a0bd2615d4 100644 --- a/lib/compiler_rt/modti3.zig +++ b/lib/compiler_rt/modti3.zig @@ -2,9 +2,34 @@ // // https://github.com/llvm/llvm-project/blob/2ffb1b0413efa9a24eb3c49e710e36f92e2cb50b/compiler-rt/lib/builtins/modti3.c -const udivmod = @import("udivmod.zig").udivmod; +const std = @import("std"); const builtin = @import("builtin"); -const compiler_rt = @import("../compiler_rt.zig"); +const udivmod = @import("udivmod.zig").udivmod; +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + if (builtin.os.tag == .windows) { + switch (arch) { + .i386 => { + @export(__modti3, .{ .name = "__modti3", .linkage = linkage }); + }, + .x86_64 => { + // The "ti" functions must use Vector(2, u64) parameter types to adhere to the ABI + // that LLVM expects compiler-rt to have. + @export(__modti3_windows_x86_64, .{ .name = "__modti3", .linkage = linkage }); + }, + else => {}, + } + if (arch.isAARCH64()) { + @export(__modti3, .{ .name = "__modti3", .linkage = linkage }); + } + } else { + @export(__modti3, .{ .name = "__modti3", .linkage = linkage }); + } +} pub fn __modti3(a: i128, b: i128) callconv(.C) i128 { @setRuntimeSafety(builtin.is_test); diff --git a/lib/compiler_rt/mulXf3.zig b/lib/compiler_rt/mulXf3.zig index 147efd0ab5..dc6ac98407 100644 --- a/lib/compiler_rt/mulXf3.zig +++ b/lib/compiler_rt/mulXf3.zig @@ -5,8 +5,32 @@ const std = @import("std"); const math = std.math; const builtin = @import("builtin"); -const compiler_rt = @import("../compiler_rt.zig"); +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; +comptime { + @export(__mulsf3, .{ .name = "__mulsf3", .linkage = linkage }); + @export(__muldf3, .{ .name = "__muldf3", .linkage = linkage }); + @export(__mulxf3, .{ .name = "__mulxf3", .linkage = linkage }); + @export(__multf3, .{ .name = "__multf3", .linkage = linkage }); + + if (!is_test) { + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_fmul, .{ .name = "__aeabi_fmul", .linkage = linkage }); + @export(__aeabi_dmul, .{ .name = "__aeabi_dmul", .linkage = linkage }); + } + + if (arch.isPPC() or arch.isPPC64()) { + @export(__mulkf3, .{ .name = "__mulkf3", .linkage = linkage }); + } + } +} + +pub fn __mulkf3(a: f128, b: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, __multf3, .{ a, b }); +} pub fn __multf3(a: f128, b: f128) callconv(.C) f128 { return mulXf3(f128, a, b); } @@ -30,7 +54,7 @@ pub fn __aeabi_dmul(a: f64, b: f64) callconv(.C) f64 { return @call(.{ .modifier = .always_inline }, __muldf3, .{ a, b }); } -fn mulXf3(comptime T: type, a: T, b: T) T { +pub fn mulXf3(comptime T: type, a: T, b: T) T { @setRuntimeSafety(builtin.is_test); const typeWidth = @typeInfo(T).Float.bits; const significandBits = math.floatMantissaBits(T); diff --git a/lib/compiler_rt/muldi3.zig b/lib/compiler_rt/muldi3.zig index f0d857e1e9..8f317adee4 100644 --- a/lib/compiler_rt/muldi3.zig +++ b/lib/compiler_rt/muldi3.zig @@ -1,7 +1,20 @@ const std = @import("std"); const builtin = @import("builtin"); -const is_test = builtin.is_test; const native_endian = builtin.cpu.arch.endian(); +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__muldi3, .{ .name = "__muldi3", .linkage = linkage }); + + if (!is_test) { + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_lmul, .{ .name = "__aeabi_lmul", .linkage = linkage }); + } + } +} // Ported from // https://github.com/llvm/llvm-project/blob/llvmorg-9.0.0/compiler-rt/lib/builtins/muldi3.c @@ -20,7 +33,11 @@ const dwords = extern union { }, }; -fn __muldsi3(a: u32, b: u32) i64 { +pub fn __aeabi_lmul(a: i64, b: i64) callconv(.C) i64 { + return @call(.{ .modifier = .always_inline }, __muldi3, .{ a, b }); +} + +pub fn __muldsi3(a: u32, b: u32) i64 { @setRuntimeSafety(is_test); const bits_in_word_2 = @sizeOf(i32) * 8 / 2; diff --git a/lib/compiler_rt/mulo.zig b/lib/compiler_rt/mulo.zig index 78590e5ce1..4fd99351bc 100644 --- a/lib/compiler_rt/mulo.zig +++ b/lib/compiler_rt/mulo.zig @@ -1,6 +1,15 @@ -const builtin = @import("builtin"); const std = @import("std"); +const builtin = @import("builtin"); const math = std.math; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__mulosi4, .{ .name = "__mulosi4", .linkage = linkage }); + @export(__mulodi4, .{ .name = "__mulodi4", .linkage = linkage }); + @export(__muloti4, .{ .name = "__muloti4", .linkage = linkage }); +} // mulo - multiplication overflow // * return a*%b. diff --git a/lib/compiler_rt/multi3.zig b/lib/compiler_rt/multi3.zig index a088dbcf9e..838cc3f1df 100644 --- a/lib/compiler_rt/multi3.zig +++ b/lib/compiler_rt/multi3.zig @@ -1,13 +1,33 @@ -const compiler_rt = @import("../compiler_rt.zig"); const std = @import("std"); const builtin = @import("builtin"); +const arch = builtin.cpu.arch; const is_test = builtin.is_test; const native_endian = builtin.cpu.arch.endian(); +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; // Ported from git@github.com:llvm-project/llvm-project-20170507.git // ae684fad6d34858c014c94da69c15e7774a633c3 // 2018-08-13 +comptime { + if (builtin.os.tag == .windows) { + switch (arch) { + .i386 => { + @export(__multi3, .{ .name = "__multi3", .linkage = linkage }); + }, + .x86_64 => { + // The "ti" functions must use Vector(2, u64) parameter types to adhere to the ABI + // that LLVM expects compiler-rt to have. + @export(__multi3_windows_x86_64, .{ .name = "__multi3", .linkage = linkage }); + }, + else => {}, + } + } else { + @export(__multi3, .{ .name = "__multi3", .linkage = linkage }); + } +} + pub fn __multi3(a: i128, b: i128) callconv(.C) i128 { @setRuntimeSafety(is_test); const x = twords{ .all = a }; @@ -25,7 +45,7 @@ pub fn __multi3_windows_x86_64(a: v128, b: v128) callconv(.C) v128 { })); } -fn __mulddi3(a: u64, b: u64) i128 { +pub fn __mulddi3(a: u64, b: u64) i128 { const bits_in_dword_2 = (@sizeOf(i64) * 8) / 2; const lower_mask = ~@as(u64, 0) >> bits_in_dword_2; var r: twords = undefined; diff --git a/lib/compiler_rt/negXf2.zig b/lib/compiler_rt/negXf2.zig index 06528b7570..f33336f965 100644 --- a/lib/compiler_rt/negXf2.zig +++ b/lib/compiler_rt/negXf2.zig @@ -1,4 +1,21 @@ const std = @import("std"); +const builtin = @import("builtin"); +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__negsf2, .{ .name = "__negsf2", .linkage = linkage }); + @export(__negdf2, .{ .name = "__negdf2", .linkage = linkage }); + + if (!is_test) { + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_fneg, .{ .name = "__aeabi_fneg", .linkage = linkage }); + @export(__aeabi_dneg, .{ .name = "__aeabi_dneg", .linkage = linkage }); + } + } +} pub fn __negsf2(a: f32) callconv(.C) f32 { return negXf2(f32, a); diff --git a/lib/compiler_rt/negXi2.zig b/lib/compiler_rt/negXi2.zig index 15102b5df7..0ab5a93f62 100644 --- a/lib/compiler_rt/negXi2.zig +++ b/lib/compiler_rt/negXi2.zig @@ -1,5 +1,14 @@ const std = @import("std"); const builtin = @import("builtin"); +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__negsi2, .{ .name = "__negsi2", .linkage = linkage }); + @export(__negdi2, .{ .name = "__negdi2", .linkage = linkage }); + @export(__negti2, .{ .name = "__negti2", .linkage = linkage }); +} // neg - negate (the number) // - negXi2 for unoptimized little and big endian diff --git a/lib/compiler_rt/negv.zig b/lib/compiler_rt/negv.zig index 09abb040d5..b9198dd380 100644 --- a/lib/compiler_rt/negv.zig +++ b/lib/compiler_rt/negv.zig @@ -1,6 +1,17 @@ // negv - negate oVerflow // * @panic, if result can not be represented // - negvXi4_generic for unoptimized version +const std = @import("std"); +const builtin = @import("builtin"); +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__negvsi2, .{ .name = "__negvsi2", .linkage = linkage }); + @export(__negvdi2, .{ .name = "__negvdi2", .linkage = linkage }); + @export(__negvti2, .{ .name = "__negvti2", .linkage = linkage }); +} // assume -0 == 0 is gracefully handled by the hardware inline fn negvXi(comptime ST: type, a: ST) ST { diff --git a/lib/compiler_rt/os_version_check.zig b/lib/compiler_rt/os_version_check.zig index 55617dec75..53f332b13e 100644 --- a/lib/compiler_rt/os_version_check.zig +++ b/lib/compiler_rt/os_version_check.zig @@ -1,5 +1,17 @@ -const testing = @import("std").testing; +const std = @import("std"); +const testing = std.testing; const builtin = @import("builtin"); +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + if (builtin.os.tag.isDarwin()) { + @export(IsPlatformVersionAtLeast.__isPlatformVersionAtLeast, .{ + .name = "__isPlatformVersionAtLeast", + .linkage = linkage, + }); + } +} // Ported from llvm-project 13.0.0 d7b669b3a30345cfcdb2fde2af6f48aa4b94845d // @@ -16,34 +28,36 @@ const builtin = @import("builtin"); // the newer codepath, which merely calls out to the Darwin _availability_version_check API which is // available on macOS 10.15+, iOS 13+, tvOS 13+ and watchOS 6+. -inline fn constructVersion(major: u32, minor: u32, subminor: u32) u32 { - return ((major & 0xffff) << 16) | ((minor & 0xff) << 8) | (subminor & 0xff); -} +const IsPlatformVersionAtLeast = struct { + inline fn constructVersion(major: u32, minor: u32, subminor: u32) u32 { + return ((major & 0xffff) << 16) | ((minor & 0xff) << 8) | (subminor & 0xff); + } -// Darwin-only -pub fn __isPlatformVersionAtLeast(platform: u32, major: u32, minor: u32, subminor: u32) callconv(.C) i32 { - const build_version = dyld_build_version_t{ - .platform = platform, - .version = constructVersion(major, minor, subminor), + // Darwin-only + fn __isPlatformVersionAtLeast(platform: u32, major: u32, minor: u32, subminor: u32) callconv(.C) i32 { + const build_version = dyld_build_version_t{ + .platform = platform, + .version = constructVersion(major, minor, subminor), + }; + return @boolToInt(_availability_version_check(1, &[_]dyld_build_version_t{build_version})); + } + + // _availability_version_check darwin API support. + const dyld_platform_t = u32; + const dyld_build_version_t = extern struct { + platform: dyld_platform_t, + version: u32, }; - return @boolToInt(_availability_version_check(1, &[_]dyld_build_version_t{build_version})); -} - -// _availability_version_check darwin API support. -const dyld_platform_t = u32; -const dyld_build_version_t = extern struct { - platform: dyld_platform_t, - version: u32, + // Darwin-only + extern "c" fn _availability_version_check(count: u32, versions: [*c]const dyld_build_version_t) bool; }; -// Darwin-only -extern "c" fn _availability_version_check(count: u32, versions: [*c]const dyld_build_version_t) bool; test "isPlatformVersionAtLeast" { - if (!builtin.os.tag.isDarwin()) return error.SkipZigTest; + if (!comptime builtin.os.tag.isDarwin()) return error.SkipZigTest; // Note: this test depends on the actual host OS version since it is merely calling into the // native Darwin API. const macos_platform_constant = 1; - try testing.expect(__isPlatformVersionAtLeast(macos_platform_constant, 10, 0, 15) == 1); - try testing.expect(__isPlatformVersionAtLeast(macos_platform_constant, 99, 0, 0) == 0); + try testing.expect(IsPlatformVersionAtLeast.__isPlatformVersionAtLeast(macos_platform_constant, 10, 0, 15) == 1); + try testing.expect(IsPlatformVersionAtLeast.__isPlatformVersionAtLeast(macos_platform_constant, 99, 0, 0) == 0); } diff --git a/lib/compiler_rt/parity.zig b/lib/compiler_rt/parity.zig index ae634b0790..4f03e32244 100644 --- a/lib/compiler_rt/parity.zig +++ b/lib/compiler_rt/parity.zig @@ -1,5 +1,14 @@ const std = @import("std"); const builtin = @import("builtin"); +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__paritysi2, .{ .name = "__paritysi2", .linkage = linkage }); + @export(__paritydi2, .{ .name = "__paritydi2", .linkage = linkage }); + @export(__parityti2, .{ .name = "__parityti2", .linkage = linkage }); +} // parity - if number of bits set is even => 0, else => 1 // - pariytXi2_generic for big and little endian diff --git a/lib/compiler_rt/popcount.zig b/lib/compiler_rt/popcount.zig index 362b232fb8..6fa88cbfc6 100644 --- a/lib/compiler_rt/popcount.zig +++ b/lib/compiler_rt/popcount.zig @@ -1,5 +1,14 @@ const builtin = @import("builtin"); const std = @import("std"); +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__popcountsi2, .{ .name = "__popcountsi2", .linkage = linkage }); + @export(__popcountdi2, .{ .name = "__popcountdi2", .linkage = linkage }); + @export(__popcountti2, .{ .name = "__popcountti2", .linkage = linkage }); +} // popcount - population count // counts the number of 1 bits diff --git a/lib/compiler_rt/round.zig b/lib/compiler_rt/round.zig index 4f3266e00c..ddd651885a 100644 --- a/lib/compiler_rt/round.zig +++ b/lib/compiler_rt/round.zig @@ -5,8 +5,27 @@ // https://git.musl-libc.org/cgit/musl/tree/src/math/round.c const std = @import("std"); +const builtin = @import("builtin"); const math = std.math; const expect = std.testing.expect; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__roundh, .{ .name = "__roundh", .linkage = linkage }); + @export(roundf, .{ .name = "roundf", .linkage = linkage }); + @export(round, .{ .name = "round", .linkage = linkage }); + @export(__roundx, .{ .name = "__roundx", .linkage = linkage }); + @export(roundq, .{ .name = "roundq", .linkage = linkage }); + @export(roundl, .{ .name = "roundl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(roundf128, .{ .name = "roundf128", .linkage = linkage }); + } + } +} pub fn __roundh(x: f16) callconv(.C) f16 { // TODO: more efficient implementation @@ -123,6 +142,10 @@ pub fn roundq(x_: f128) callconv(.C) f128 { } } +pub fn roundf128(x_: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, roundq, .{x_}); +} + pub fn roundl(x: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __roundh(x), diff --git a/lib/compiler_rt/shift.zig b/lib/compiler_rt/shift.zig index edcf246daf..031d5368ad 100644 --- a/lib/compiler_rt/shift.zig +++ b/lib/compiler_rt/shift.zig @@ -1,13 +1,35 @@ const std = @import("std"); +const builtin = @import("builtin"); const Log2Int = std.math.Log2Int; -const native_endian = @import("builtin").cpu.arch.endian(); +const native_endian = builtin.cpu.arch.endian(); +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__ashldi3, .{ .name = "__ashldi3", .linkage = linkage }); + @export(__ashlti3, .{ .name = "__ashlti3", .linkage = linkage }); + @export(__ashrdi3, .{ .name = "__ashrdi3", .linkage = linkage }); + @export(__ashrti3, .{ .name = "__ashrti3", .linkage = linkage }); + @export(__lshrdi3, .{ .name = "__lshrdi3", .linkage = linkage }); + @export(__lshrti3, .{ .name = "__lshrti3", .linkage = linkage }); + + if (!is_test) { + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_llsl, .{ .name = "__aeabi_llsl", .linkage = linkage }); + @export(__aeabi_lasr, .{ .name = "__aeabi_lasr", .linkage = linkage }); + @export(__aeabi_llsr, .{ .name = "__aeabi_llsr", .linkage = linkage }); + } + } +} fn Dwords(comptime T: type, comptime signed_half: bool) type { return extern union { - pub const bits = @divExact(@typeInfo(T).Int.bits, 2); - pub const HalfTU = std.meta.Int(.unsigned, bits); - pub const HalfTS = std.meta.Int(.signed, bits); - pub const HalfT = if (signed_half) HalfTS else HalfTU; + const bits = @divExact(@typeInfo(T).Int.bits, 2); + const HalfTU = std.meta.Int(.unsigned, bits); + const HalfTS = std.meta.Int(.signed, bits); + const HalfT = if (signed_half) HalfTS else HalfTU; all: T, s: if (native_endian == .Little) @@ -19,7 +41,7 @@ fn Dwords(comptime T: type, comptime signed_half: bool) type { // Arithmetic shift left // Precondition: 0 <= b < bits_in_dword -pub inline fn ashlXi3(comptime T: type, a: T, b: i32) T { +inline fn ashlXi3(comptime T: type, a: T, b: i32) T { const dwords = Dwords(T, false); const S = Log2Int(dwords.HalfT); @@ -42,7 +64,7 @@ pub inline fn ashlXi3(comptime T: type, a: T, b: i32) T { // Arithmetic shift right // Precondition: 0 <= b < T.bit_count -pub inline fn ashrXi3(comptime T: type, a: T, b: i32) T { +inline fn ashrXi3(comptime T: type, a: T, b: i32) T { const dwords = Dwords(T, true); const S = Log2Int(dwords.HalfT); @@ -69,7 +91,7 @@ pub inline fn ashrXi3(comptime T: type, a: T, b: i32) T { // Logical shift right // Precondition: 0 <= b < T.bit_count -pub inline fn lshrXi3(comptime T: type, a: T, b: i32) T { +inline fn lshrXi3(comptime T: type, a: T, b: i32) T { const dwords = Dwords(T, false); const S = Log2Int(dwords.HalfT); diff --git a/lib/compiler_rt/sin.zig b/lib/compiler_rt/sin.zig index 20259bc309..9766b2d541 100644 --- a/lib/compiler_rt/sin.zig +++ b/lib/compiler_rt/sin.zig @@ -5,13 +5,32 @@ // 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 expect = std.testing.expect; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; 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 = linkage }); + @export(sinf, .{ .name = "sinf", .linkage = linkage }); + @export(sin, .{ .name = "sin", .linkage = linkage }); + @export(__sinx, .{ .name = "__sinx", .linkage = linkage }); + @export(sinq, .{ .name = "sinq", .linkage = linkage }); + @export(sinl, .{ .name = "sinl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(sinf128, .{ .name = "sinf128", .linkage = linkage }); + } + } +} + pub fn __sinh(x: f16) callconv(.C) f16 { // TODO: more efficient implementation return @floatCast(f16, sinf(x)); @@ -111,6 +130,10 @@ pub fn sinq(x: f128) callconv(.C) f128 { return sin(@floatCast(f64, x)); } +pub fn sinf128(x: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, sinq, .{x}); +} + pub fn sinl(x: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __sinh(x), diff --git a/lib/compiler_rt/sincos.zig b/lib/compiler_rt/sincos.zig index 8bc5b83ee5..da68022f89 100644 --- a/lib/compiler_rt/sincos.zig +++ b/lib/compiler_rt/sincos.zig @@ -1,10 +1,27 @@ const std = @import("std"); +const builtin = @import("builtin"); +const arch = builtin.cpu.arch; const math = std.math; -const sin = @import("sin.zig"); -const cos = @import("cos.zig"); const trig = @import("trig.zig"); const rem_pio2 = @import("rem_pio2.zig").rem_pio2; const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__sincosh, .{ .name = "__sincosh", .linkage = linkage }); + @export(sincosf, .{ .name = "sincosf", .linkage = linkage }); + @export(sincos, .{ .name = "sincos", .linkage = linkage }); + @export(__sincosx, .{ .name = "__sincosx", .linkage = linkage }); + @export(sincosq, .{ .name = "sincosq", .linkage = linkage }); + @export(sincosl, .{ .name = "sincosl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(sincosf128, .{ .name = "sincosf128", .linkage = linkage }); + } + } +} pub fn __sincosh(x: f16, r_sin: *f16, r_cos: *f16) callconv(.C) void { // TODO: more efficient implementation @@ -181,6 +198,10 @@ pub fn sincosq(x: f128, r_sin: *f128, r_cos: *f128) callconv(.C) void { r_cos.* = small_cos; } +pub fn sincosf128(x: f128, r_sin: *f128, r_cos: *f128) callconv(.C) void { + return @call(.{ .modifier = .always_inline }, sincosq, .{ x, r_sin, r_cos }); +} + pub fn sincosl(x: c_longdouble, r_sin: *c_longdouble, r_cos: *c_longdouble) callconv(.C) void { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __sincosh(x, r_sin, r_cos), @@ -192,7 +213,7 @@ pub fn sincosl(x: c_longdouble, r_sin: *c_longdouble, r_cos: *c_longdouble) call } } -const rem_pio2_generic = @compileError("TODO"); +pub const rem_pio2_generic = @compileError("TODO"); /// Ported from musl sincosl.c. Needs the following dependencies to be complete: /// * rem_pio2_generic ported from __rem_pio2l.c diff --git a/lib/compiler_rt/sparc.zig b/lib/compiler_rt/sparc.zig index 3b33afd29a..f96ba4b41a 100644 --- a/lib/compiler_rt/sparc.zig +++ b/lib/compiler_rt/sparc.zig @@ -3,6 +3,40 @@ const std = @import("std"); const builtin = @import("builtin"); +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + if (arch.isSPARC()) { + // SPARC systems use a different naming scheme + @export(_Qp_add, .{ .name = "_Qp_add", .linkage = linkage }); + @export(_Qp_div, .{ .name = "_Qp_div", .linkage = linkage }); + @export(_Qp_mul, .{ .name = "_Qp_mul", .linkage = linkage }); + @export(_Qp_sub, .{ .name = "_Qp_sub", .linkage = linkage }); + + @export(_Qp_cmp, .{ .name = "_Qp_cmp", .linkage = linkage }); + @export(_Qp_feq, .{ .name = "_Qp_feq", .linkage = linkage }); + @export(_Qp_fne, .{ .name = "_Qp_fne", .linkage = linkage }); + @export(_Qp_flt, .{ .name = "_Qp_flt", .linkage = linkage }); + @export(_Qp_fle, .{ .name = "_Qp_fle", .linkage = linkage }); + @export(_Qp_fgt, .{ .name = "_Qp_fgt", .linkage = linkage }); + @export(_Qp_fge, .{ .name = "_Qp_fge", .linkage = linkage }); + + @export(_Qp_itoq, .{ .name = "_Qp_itoq", .linkage = linkage }); + @export(_Qp_uitoq, .{ .name = "_Qp_uitoq", .linkage = linkage }); + @export(_Qp_xtoq, .{ .name = "_Qp_xtoq", .linkage = linkage }); + @export(_Qp_uxtoq, .{ .name = "_Qp_uxtoq", .linkage = linkage }); + @export(_Qp_stoq, .{ .name = "_Qp_stoq", .linkage = linkage }); + @export(_Qp_dtoq, .{ .name = "_Qp_dtoq", .linkage = linkage }); + @export(_Qp_qtoi, .{ .name = "_Qp_qtoi", .linkage = linkage }); + @export(_Qp_qtoui, .{ .name = "_Qp_qtoui", .linkage = linkage }); + @export(_Qp_qtox, .{ .name = "_Qp_qtox", .linkage = linkage }); + @export(_Qp_qtoux, .{ .name = "_Qp_qtoux", .linkage = linkage }); + @export(_Qp_qtos, .{ .name = "_Qp_qtos", .linkage = linkage }); + @export(_Qp_qtod, .{ .name = "_Qp_qtod", .linkage = linkage }); + } +} // The SPARC Architecture Manual, Version 9: // A.13 Floating-Point Compare diff --git a/lib/compiler_rt/sqrt.zig b/lib/compiler_rt/sqrt.zig index 8d43949f99..ec62ff3d39 100644 --- a/lib/compiler_rt/sqrt.zig +++ b/lib/compiler_rt/sqrt.zig @@ -1,5 +1,24 @@ const std = @import("std"); +const builtin = @import("builtin"); +const arch = builtin.cpu.arch; const math = std.math; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__sqrth, .{ .name = "__sqrth", .linkage = linkage }); + @export(sqrtf, .{ .name = "sqrtf", .linkage = linkage }); + @export(sqrt, .{ .name = "sqrt", .linkage = linkage }); + @export(__sqrtx, .{ .name = "__sqrtx", .linkage = linkage }); + @export(sqrtq, .{ .name = "sqrtq", .linkage = linkage }); + @export(sqrtl, .{ .name = "sqrtl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(sqrtf128, .{ .name = "sqrtf128", .linkage = linkage }); + } + } +} pub fn __sqrth(x: f16) callconv(.C) f16 { // TODO: more efficient implementation @@ -236,6 +255,10 @@ pub fn sqrtl(x: c_longdouble) callconv(.C) c_longdouble { } } +pub fn sqrtf128(x: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, sqrtq, .{x}); +} + test "sqrtf" { const V = [_]f32{ 0.0, diff --git a/lib/compiler_rt/stack_probe.zig b/lib/compiler_rt/stack_probe.zig index 90919dcbb8..5ebb851825 100644 --- a/lib/compiler_rt/stack_probe.zig +++ b/lib/compiler_rt/stack_probe.zig @@ -1,4 +1,43 @@ -const native_arch = @import("builtin").cpu.arch; +const std = @import("std"); +const builtin = @import("builtin"); +const os_tag = builtin.os.tag; +const arch = builtin.cpu.arch; +const abi = builtin.abi; +const is_test = builtin.is_test; + +const is_gnu = abi.isGnu(); +const is_mingw = os_tag == .windows and is_gnu; + +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +const strong_linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Strong; +pub const panic = @import("common.zig").panic; + +comptime { + if (builtin.os.tag == .windows) { + // Default stack-probe functions emitted by LLVM + if (is_mingw) { + @export(_chkstk, .{ .name = "_alloca", .linkage = strong_linkage }); + @export(___chkstk_ms, .{ .name = "___chkstk_ms", .linkage = strong_linkage }); + } else if (!builtin.link_libc) { + // This symbols are otherwise exported by MSVCRT.lib + @export(_chkstk, .{ .name = "_chkstk", .linkage = strong_linkage }); + @export(__chkstk, .{ .name = "__chkstk", .linkage = strong_linkage }); + } + + if (arch.isAARCH64()) { + @export(__chkstk, .{ .name = "__chkstk", .linkage = strong_linkage }); + } + } + + switch (arch) { + .i386, + .x86_64, + => { + @export(zig_probe_stack, .{ .name = "__zig_probe_stack", .linkage = linkage }); + }, + else => {}, + } +} // Zig's own stack-probe routine (available only on x86 and x86_64) pub fn zig_probe_stack() callconv(.Naked) void { @@ -8,7 +47,7 @@ pub fn zig_probe_stack() callconv(.Naked) void { // invalid so let's update it on the go, otherwise we'll get a segfault // instead of triggering the stack growth. - switch (native_arch) { + switch (arch) { .x86_64 => { // %rax = probe length, %rsp = stack pointer asm volatile ( @@ -60,7 +99,7 @@ pub fn zig_probe_stack() callconv(.Naked) void { fn win_probe_stack_only() void { @setRuntimeSafety(false); - switch (native_arch) { + switch (arch) { .x86_64 => { asm volatile ( \\ push %%rcx @@ -105,7 +144,7 @@ fn win_probe_stack_only() void { }, else => {}, } - if (comptime native_arch.isAARCH64()) { + if (comptime arch.isAARCH64()) { // NOTE: page size hardcoded to 4096 for now asm volatile ( \\ lsl x16, x15, #4 @@ -127,7 +166,7 @@ fn win_probe_stack_only() void { fn win_probe_stack_adjust_sp() void { @setRuntimeSafety(false); - switch (native_arch) { + switch (arch) { .x86_64 => { asm volatile ( \\ push %%rcx @@ -201,9 +240,9 @@ pub fn _chkstk() callconv(.Naked) void { } pub fn __chkstk() callconv(.Naked) void { @setRuntimeSafety(false); - if (comptime native_arch.isAARCH64()) { + if (comptime arch.isAARCH64()) { @call(.{ .modifier = .always_inline }, win_probe_stack_only, .{}); - } else switch (native_arch) { + } else switch (arch) { .i386 => @call(.{ .modifier = .always_inline }, win_probe_stack_adjust_sp, .{}), .x86_64 => @call(.{ .modifier = .always_inline }, win_probe_stack_only, .{}), else => unreachable, diff --git a/lib/compiler_rt/subo.zig b/lib/compiler_rt/subo.zig index af28c6eead..c2b73a599d 100644 --- a/lib/compiler_rt/subo.zig +++ b/lib/compiler_rt/subo.zig @@ -1,4 +1,14 @@ +const std = @import("std"); const builtin = @import("builtin"); +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__subosi4, .{ .name = "__subosi4", .linkage = linkage }); + @export(__subodi4, .{ .name = "__subodi4", .linkage = linkage }); + @export(__suboti4, .{ .name = "__suboti4", .linkage = linkage }); +} // subo - subtract overflow // * return a-%b. diff --git a/lib/compiler_rt/tan.zig b/lib/compiler_rt/tan.zig index d37022d918..c03c3e8649 100644 --- a/lib/compiler_rt/tan.zig +++ b/lib/compiler_rt/tan.zig @@ -6,6 +6,7 @@ // https://golang.org/src/math/tan.go const std = @import("std"); +const builtin = @import("builtin"); const math = std.math; const expect = std.testing.expect; @@ -13,6 +14,25 @@ const kernel = @import("trig.zig"); const rem_pio2 = @import("rem_pio2.zig").rem_pio2; const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__tanh, .{ .name = "__tanh", .linkage = linkage }); + @export(tanf, .{ .name = "tanf", .linkage = linkage }); + @export(tan, .{ .name = "tan", .linkage = linkage }); + @export(__tanx, .{ .name = "__tanx", .linkage = linkage }); + @export(tanq, .{ .name = "tanq", .linkage = linkage }); + @export(tanl, .{ .name = "tanl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(tanf128, .{ .name = "tanf128", .linkage = linkage }); + } + } +} + pub fn __tanh(x: f16) callconv(.C) f16 { // TODO: more efficient implementation return @floatCast(f16, tanf(x)); @@ -96,6 +116,10 @@ pub fn tanq(x: f128) callconv(.C) f128 { return tan(@floatCast(f64, x)); } +pub fn tanf128(x: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, tanq, .{x}); +} + pub fn tanl(x: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __tanh(x), diff --git a/lib/compiler_rt/trunc.zig b/lib/compiler_rt/trunc.zig index d00df60d99..c377a86666 100644 --- a/lib/compiler_rt/trunc.zig +++ b/lib/compiler_rt/trunc.zig @@ -5,8 +5,27 @@ // https://git.musl-libc.org/cgit/musl/tree/src/math/trunc.c const std = @import("std"); +const builtin = @import("builtin"); const math = std.math; const expect = std.testing.expect; +const arch = builtin.cpu.arch; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__trunch, .{ .name = "__trunch", .linkage = linkage }); + @export(truncf, .{ .name = "truncf", .linkage = linkage }); + @export(trunc, .{ .name = "trunc", .linkage = linkage }); + @export(__truncx, .{ .name = "__truncx", .linkage = linkage }); + @export(truncq, .{ .name = "truncq", .linkage = linkage }); + @export(truncl, .{ .name = "truncl", .linkage = linkage }); + + if (!builtin.is_test) { + if (arch.isPPC() or arch.isPPC64()) { + @export(truncf128, .{ .name = "truncf128", .linkage = linkage }); + } + } +} pub fn __trunch(x: f16) callconv(.C) f16 { // TODO: more efficient implementation @@ -81,6 +100,10 @@ pub fn truncq(x: f128) callconv(.C) f128 { } } +pub fn truncf128(x: f128) callconv(.C) f128 { + return @call(.{ .modifier = .always_inline }, truncq, .{x}); +} + pub fn truncl(x: c_longdouble) callconv(.C) c_longdouble { switch (@typeInfo(c_longdouble).Float.bits) { 16 => return __trunch(x), diff --git a/lib/compiler_rt/truncXfYf2.zig b/lib/compiler_rt/truncXfYf2.zig index bf324269a6..77fabcbd75 100644 --- a/lib/compiler_rt/truncXfYf2.zig +++ b/lib/compiler_rt/truncXfYf2.zig @@ -1,17 +1,49 @@ const std = @import("std"); const builtin = @import("builtin"); -const native_arch = builtin.cpu.arch; +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__truncdfhf2, .{ .name = "__truncdfhf2", .linkage = linkage }); + @export(__trunctfhf2, .{ .name = "__trunctfhf2", .linkage = linkage }); + @export(__trunctfdf2, .{ .name = "__trunctfdf2", .linkage = linkage }); + @export(__trunctfsf2, .{ .name = "__trunctfsf2", .linkage = linkage }); + + @export(__truncdfsf2, .{ .name = "__truncdfsf2", .linkage = linkage }); + @export(__truncsfhf2, .{ .name = "__truncsfhf2", .linkage = linkage }); + + if (!is_test) { + @export(__gnu_f2h_ieee, .{ .name = "__gnu_f2h_ieee", .linkage = linkage }); + + if (arch.isARM() or arch.isThumb()) { + @export(__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = linkage }); + @export(__aeabi_f2h, .{ .name = "__aeabi_f2h", .linkage = linkage }); + @export(__aeabi_d2f, .{ .name = "__aeabi_d2f", .linkage = linkage }); + } + + if (arch.isPPC() or arch.isPPC64()) { + @export(__trunckfsf2, .{ .name = "__trunckfsf2", .linkage = linkage }); + @export(__trunckfdf2, .{ .name = "__trunckfdf2", .linkage = linkage }); + } + } +} // AArch64 is the only ABI (at the moment) to support f16 arguments without the // need for extending them to wider fp types. // TODO remove this; do this type selection in the language rather than // here in compiler-rt. -pub const F16T = if (native_arch.isAARCH64()) f16 else u16; +const F16T = if (arch.isAARCH64()) f16 else u16; pub fn __truncsfhf2(a: f32) callconv(.C) F16T { return @bitCast(F16T, truncXfYf2(f16, f32, a)); } +pub fn __gnu_f2h_ieee(a: f32) callconv(.C) F16T { + return @call(.{ .modifier = .always_inline }, __truncsfhf2, .{a}); +} + pub fn __truncdfhf2(a: f64) callconv(.C) F16T { return @bitCast(F16T, truncXfYf2(f16, f64, a)); } @@ -24,10 +56,18 @@ pub fn __trunctfsf2(a: f128) callconv(.C) f32 { return truncXfYf2(f32, f128, a); } +pub fn __trunckfsf2(a: f128) callconv(.C) f32 { + return truncXfYf2(f32, f128, a); +} + pub fn __trunctfdf2(a: f128) callconv(.C) f64 { return truncXfYf2(f64, f128, a); } +pub fn __trunckfdf2(a: f128) callconv(.C) f64 { + return truncXfYf2(f64, f128, a); +} + pub fn __truncdfsf2(a: f64) callconv(.C) f32 { return truncXfYf2(f32, f64, a); } diff --git a/lib/compiler_rt/trunc_f80.zig b/lib/compiler_rt/trunc_f80.zig index 107874aeeb..43f113ea42 100644 --- a/lib/compiler_rt/trunc_f80.zig +++ b/lib/compiler_rt/trunc_f80.zig @@ -1,11 +1,21 @@ const std = @import("std"); const builtin = @import("builtin"); -const native_arch = builtin.cpu.arch; +const arch = builtin.cpu.arch; const testing = std.testing; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + @export(__truncxfhf2, .{ .name = "__truncxfhf2", .linkage = linkage }); + @export(__truncxfsf2, .{ .name = "__truncxfsf2", .linkage = linkage }); + @export(__truncxfdf2, .{ .name = "__truncxfdf2", .linkage = linkage }); + @export(__trunctfxf2, .{ .name = "__trunctfxf2", .linkage = linkage }); +} // AArch64 is the only ABI (at the moment) to support f16 arguments without the // need for extending them to wider fp types. -pub const F16T = if (native_arch.isAARCH64()) f16 else u16; +const F16T = if (arch.isAARCH64()) f16 else u16; pub fn __truncxfhf2(a: f80) callconv(.C) F16T { return @bitCast(F16T, trunc(f16, a)); diff --git a/lib/compiler_rt/udivmodti4.zig b/lib/compiler_rt/udivmodti4.zig index be9ed8237b..3bad0c822e 100644 --- a/lib/compiler_rt/udivmodti4.zig +++ b/lib/compiler_rt/udivmodti4.zig @@ -1,13 +1,35 @@ -const udivmod = @import("udivmod.zig").udivmod; +const std = @import("std"); const builtin = @import("builtin"); -const compiler_rt = @import("../compiler_rt.zig"); +const udivmod = @import("udivmod.zig").udivmod; +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + if (builtin.os.tag == .windows) { + switch (arch) { + .i386 => { + @export(__udivmodti4, .{ .name = "__udivmodti4", .linkage = linkage }); + }, + .x86_64 => { + // The "ti" functions must use Vector(2, u64) parameter types to adhere to the ABI + // that LLVM expects compiler-rt to have. + @export(__udivmodti4_windows_x86_64, .{ .name = "__udivmodti4", .linkage = linkage }); + }, + else => {}, + } + } else { + @export(__udivmodti4, .{ .name = "__udivmodti4", .linkage = linkage }); + } +} pub fn __udivmodti4(a: u128, b: u128, maybe_rem: ?*u128) callconv(.C) u128 { @setRuntimeSafety(builtin.is_test); return udivmod(u128, a, b, maybe_rem); } -const v128 = @import("std").meta.Vector(2, u64); +const v128 = std.meta.Vector(2, u64); pub fn __udivmodti4_windows_x86_64(a: v128, b: v128, maybe_rem: ?*u128) callconv(.C) v128 { @setRuntimeSafety(builtin.is_test); return @bitCast(v128, udivmod(u128, @bitCast(u128, a), @bitCast(u128, b), maybe_rem)); diff --git a/lib/compiler_rt/udivti3.zig b/lib/compiler_rt/udivti3.zig index 52afa0420f..f12b215c59 100644 --- a/lib/compiler_rt/udivti3.zig +++ b/lib/compiler_rt/udivti3.zig @@ -1,13 +1,39 @@ -const udivmodti4 = @import("udivmodti4.zig"); +const std = @import("std"); const builtin = @import("builtin"); +const udivmod = @import("udivmod.zig").udivmod; +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + if (builtin.os.tag == .windows) { + switch (arch) { + .i386 => { + @export(__udivti3, .{ .name = "__udivti3", .linkage = linkage }); + }, + .x86_64 => { + // The "ti" functions must use Vector(2, u64) parameter types to adhere to the ABI + // that LLVM expects compiler-rt to have. + @export(__udivti3_windows_x86_64, .{ .name = "__udivti3", .linkage = linkage }); + }, + else => {}, + } + if (arch.isAARCH64()) { + @export(__udivti3, .{ .name = "__udivti3", .linkage = linkage }); + } + } else { + @export(__udivti3, .{ .name = "__udivti3", .linkage = linkage }); + } +} pub fn __udivti3(a: u128, b: u128) callconv(.C) u128 { @setRuntimeSafety(builtin.is_test); - return udivmodti4.__udivmodti4(a, b, null); + return udivmod(u128, a, b, null); } -const v128 = @import("std").meta.Vector(2, u64); +const v128 = std.meta.Vector(2, u64); pub fn __udivti3_windows_x86_64(a: v128, b: v128) callconv(.C) v128 { @setRuntimeSafety(builtin.is_test); - return udivmodti4.__udivmodti4_windows_x86_64(a, b, null); + return @bitCast(v128, udivmod(u128, @bitCast(u128, a), @bitCast(u128, b), null)); } diff --git a/lib/compiler_rt/umodti3.zig b/lib/compiler_rt/umodti3.zig index 29eb572892..aef2ba434d 100644 --- a/lib/compiler_rt/umodti3.zig +++ b/lib/compiler_rt/umodti3.zig @@ -1,15 +1,40 @@ -const udivmodti4 = @import("udivmodti4.zig"); +const std = @import("std"); const builtin = @import("builtin"); -const compiler_rt = @import("../compiler_rt.zig"); +const udivmod = @import("udivmod.zig").udivmod; +const arch = builtin.cpu.arch; +const is_test = builtin.is_test; +const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak; +pub const panic = @import("common.zig").panic; + +comptime { + if (builtin.os.tag == .windows) { + switch (arch) { + .i386 => { + @export(__umodti3, .{ .name = "__umodti3", .linkage = linkage }); + }, + .x86_64 => { + // The "ti" functions must use Vector(2, u64) parameter types to adhere to the ABI + // that LLVM expects compiler-rt to have. + @export(__umodti3_windows_x86_64, .{ .name = "__umodti3", .linkage = linkage }); + }, + else => {}, + } + if (arch.isAARCH64()) { + @export(__umodti3, .{ .name = "__umodti3", .linkage = linkage }); + } + } else { + @export(__umodti3, .{ .name = "__umodti3", .linkage = linkage }); + } +} pub fn __umodti3(a: u128, b: u128) callconv(.C) u128 { @setRuntimeSafety(builtin.is_test); var r: u128 = undefined; - _ = udivmodti4.__udivmodti4(a, b, &r); + _ = udivmod(u128, a, b, &r); return r; } -const v128 = @import("std").meta.Vector(2, u64); +const v128 = std.meta.Vector(2, u64); pub fn __umodti3_windows_x86_64(a: v128, b: v128) callconv(.C) v128 { return @bitCast(v128, @call(.{ .modifier = .always_inline }, __umodti3, .{ @bitCast(u128, a), diff --git a/src/Compilation.zig b/src/Compilation.zig index 54d87faa7b..0cd40a7001 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -23,6 +23,7 @@ const mingw = @import("mingw.zig"); const libunwind = @import("libunwind.zig"); const libcxx = @import("libcxx.zig"); const wasi_libc = @import("wasi_libc.zig"); +const compiler_rt = @import("compiler_rt.zig"); const fatal = @import("main.zig").fatal; const clangMain = @import("main.zig").clangMain; const Module = @import("Module.zig"); @@ -131,7 +132,7 @@ libssp_static_lib: ?CRTFile = null, libc_static_lib: ?CRTFile = null, /// Populated when we build the libcompiler_rt static library. A Job to build this is placed in the queue /// and resolved before calling linker.flush(). -compiler_rt_static_lib: ?CRTFile = null, +compiler_rt_static_lib: compiler_rt.CompilerRtLib = .{}, /// Populated when we build the compiler_rt_obj object. A Job to build this is placed in the queue /// and resolved before calling linker.flush(). compiler_rt_obj: ?CRTFile = null, @@ -175,7 +176,7 @@ pub const CRTFile = struct { lock: Cache.Lock, full_object_path: []const u8, - fn deinit(self: *CRTFile, gpa: Allocator) void { + pub fn deinit(self: *CRTFile, gpa: Allocator) void { self.lock.release(); gpa.free(self.full_object_path); self.* = undefined; @@ -1978,9 +1979,7 @@ pub fn destroy(self: *Compilation) void { if (self.libcxxabi_static_lib) |*crt_file| { crt_file.deinit(gpa); } - if (self.compiler_rt_static_lib) |*crt_file| { - crt_file.deinit(gpa); - } + self.compiler_rt_static_lib.deinit(gpa); if (self.compiler_rt_obj) |*crt_file| { crt_file.deinit(gpa); } @@ -3138,11 +3137,9 @@ fn processOneJob(comp: *Compilation, job: Job) !void { const named_frame = tracy.namedFrame("compiler_rt_lib"); defer named_frame.end(); - comp.buildOutputFromZig( - "compiler_rt.zig", - .Lib, + compiler_rt.buildCompilerRtLib( + comp, &comp.compiler_rt_static_lib, - .compiler_rt, ) catch |err| switch (err) { error.OutOfMemory => return error.OutOfMemory, error.SubCompilationFailed => return, // error reported already @@ -4897,7 +4894,7 @@ pub fn updateSubCompilation(sub_compilation: *Compilation) !void { } } -fn buildOutputFromZig( +pub fn buildOutputFromZig( comp: *Compilation, src_basename: []const u8, output_mode: std.builtin.OutputMode, @@ -4914,7 +4911,15 @@ fn buildOutputFromZig( .root_src_path = src_basename, }; defer main_pkg.deinitTable(comp.gpa); - const root_name = src_basename[0 .. src_basename.len - std.fs.path.extension(src_basename).len]; + + const root_name = root_name: { + const basename = if (std.fs.path.dirname(src_basename)) |dirname| + src_basename[dirname.len + 1 ..] + else + src_basename; + const root_name = basename[0 .. basename.len - std.fs.path.extension(basename).len]; + break :root_name root_name; + }; const target = comp.getTarget(); const bin_basename = try std.zig.binNameAlloc(comp.gpa, .{ .root_name = root_name, diff --git a/src/compiler_rt.zig b/src/compiler_rt.zig new file mode 100644 index 0000000000..82b482daa8 --- /dev/null +++ b/src/compiler_rt.zig @@ -0,0 +1,186 @@ +const std = @import("std"); +const builtin = @import("builtin"); +const Allocator = std.mem.Allocator; +const mem = std.mem; +const tracy = @import("tracy.zig"); +const trace = tracy.trace; + +const Compilation = @import("Compilation.zig"); +const CRTFile = Compilation.CRTFile; +const LinkObject = Compilation.LinkObject; +const Package = @import("Package.zig"); + +pub const CompilerRtLib = struct { + crt_object_files: [sources.len]?CRTFile = undefined, + crt_lib_file: ?CRTFile = null, + + pub fn deinit(crt_lib: *CompilerRtLib, gpa: Allocator) void { + for (crt_lib.crt_object_files) |*crt_file| { + if (crt_file.*) |*cf| { + cf.deinit(gpa); + } + } + if (crt_lib.crt_lib_file) |*crt_file| { + crt_file.deinit(gpa); + } + } +}; + +pub fn buildCompilerRtLib(comp: *Compilation, compiler_rt_lib: *CompilerRtLib) !void { + const tracy_trace = trace(@src()); + defer tracy_trace.end(); + + var progress: std.Progress = .{ .dont_print_on_dumb = true }; + var progress_node = progress.start("Compile Compiler-RT", sources.len + 1); + defer progress_node.end(); + if (comp.color == .off) progress.terminal = null; + + progress_node.activate(); + + var link_objects: [sources.len]LinkObject = undefined; + for (sources) |source, i| { + var obj_progress_node = progress_node.start(source, 0); + obj_progress_node.activate(); + defer obj_progress_node.end(); + + try comp.buildOutputFromZig(source, .Obj, &compiler_rt_lib.crt_object_files[i], .compiler_rt); + link_objects[i] = .{ + .path = compiler_rt_lib.crt_object_files[i].?.full_object_path, + .must_link = true, + }; + } + + const root_name = "compiler_rt"; + + var lib_progress_node = progress_node.start(root_name, 0); + lib_progress_node.activate(); + defer lib_progress_node.end(); + + const target = comp.getTarget(); + const basename = try std.zig.binNameAlloc(comp.gpa, .{ + .root_name = root_name, + .target = target, + .output_mode = .Lib, + }); + errdefer comp.gpa.free(basename); + + // TODO: This is extracted into a local variable to work around a stage1 miscompilation. + const emit_bin = Compilation.EmitLoc{ + .directory = null, // Put it in the cache directory. + .basename = basename, + }; + const sub_compilation = try Compilation.create(comp.gpa, .{ + .local_cache_directory = comp.global_cache_directory, + .global_cache_directory = comp.global_cache_directory, + .zig_lib_directory = comp.zig_lib_directory, + .cache_mode = .whole, + .target = target, + .root_name = root_name, + .main_pkg = null, + .output_mode = .Lib, + .link_mode = .Static, + .function_sections = true, + .thread_pool = comp.thread_pool, + .libc_installation = comp.bin_file.options.libc_installation, + .emit_bin = emit_bin, + .optimize_mode = comp.compilerRtOptMode(), + .want_sanitize_c = false, + .want_stack_check = false, + .want_red_zone = comp.bin_file.options.red_zone, + .omit_frame_pointer = comp.bin_file.options.omit_frame_pointer, + .want_valgrind = false, + .want_tsan = false, + .want_pic = comp.bin_file.options.pic, + .want_pie = comp.bin_file.options.pie, + .want_lto = comp.bin_file.options.lto, + .emit_h = null, + .strip = comp.compilerRtStrip(), + .is_native_os = comp.bin_file.options.is_native_os, + .is_native_abi = comp.bin_file.options.is_native_abi, + .self_exe_path = comp.self_exe_path, + .link_objects = &link_objects, + .verbose_cc = comp.verbose_cc, + .verbose_link = comp.bin_file.options.verbose_link, + .verbose_air = comp.verbose_air, + .verbose_llvm_ir = comp.verbose_llvm_ir, + .verbose_cimport = comp.verbose_cimport, + .verbose_llvm_cpu_features = comp.verbose_llvm_cpu_features, + .clang_passthrough_mode = comp.clang_passthrough_mode, + .skip_linker_dependencies = true, + .parent_compilation_link_libc = comp.bin_file.options.link_libc, + }); + defer sub_compilation.destroy(); + + try sub_compilation.updateSubCompilation(); + + compiler_rt_lib.crt_lib_file = .{ + .full_object_path = try sub_compilation.bin_file.options.emit.?.directory.join(comp.gpa, &[_][]const u8{ + sub_compilation.bin_file.options.emit.?.sub_path, + }), + .lock = sub_compilation.bin_file.toOwnedLock(), + }; +} + +const sources = &[_][]const u8{ + "compiler_rt/atomics.zig", + "compiler_rt/sin.zig", + "compiler_rt/cos.zig", + "compiler_rt/sincos.zig", + "compiler_rt/ceil.zig", + "compiler_rt/exp.zig", + "compiler_rt/exp2.zig", + "compiler_rt/fabs.zig", + "compiler_rt/floor.zig", + "compiler_rt/fma.zig", + "compiler_rt/fmax.zig", + "compiler_rt/fmin.zig", + "compiler_rt/fmod.zig", + "compiler_rt/log.zig", + "compiler_rt/log10.zig", + "compiler_rt/log2.zig", + "compiler_rt/round.zig", + "compiler_rt/sqrt.zig", + "compiler_rt/tan.zig", + "compiler_rt/trunc.zig", + "compiler_rt/extendXfYf2.zig", + "compiler_rt/extend_f80.zig", + "compiler_rt/compareXf2.zig", + "compiler_rt/stack_probe.zig", + "compiler_rt/divti3.zig", + "compiler_rt/modti3.zig", + "compiler_rt/multi3.zig", + "compiler_rt/udivti3.zig", + "compiler_rt/udivmodti4.zig", + "compiler_rt/umodti3.zig", + "compiler_rt/truncXfYf2.zig", + "compiler_rt/trunc_f80.zig", + "compiler_rt/addXf3.zig", + "compiler_rt/mulXf3.zig", + "compiler_rt/divsf3.zig", + "compiler_rt/divdf3.zig", + "compiler_rt/divxf3.zig", + "compiler_rt/divtf3.zig", + "compiler_rt/floatXiYf.zig", + "compiler_rt/fixXfYi.zig", + "compiler_rt/count0bits.zig", + "compiler_rt/parity.zig", + "compiler_rt/popcount.zig", + "compiler_rt/bswap.zig", + "compiler_rt/int.zig", + "compiler_rt/shift.zig", + "compiler_rt/negXi2.zig", + "compiler_rt/muldi3.zig", + "compiler_rt/absv.zig", + "compiler_rt/negv.zig", + "compiler_rt/addo.zig", + "compiler_rt/subo.zig", + "compiler_rt/mulo.zig", + "compiler_rt/cmp.zig", + "compiler_rt/negXf2.zig", + "compiler_rt/os_version_check.zig", + "compiler_rt/emutls.zig", + "compiler_rt/arm.zig", + "compiler_rt/aulldiv.zig", + "compiler_rt/sparc.zig", + "compiler_rt/clear_cache.zig", +}; diff --git a/src/link/Coff.zig b/src/link/Coff.zig index 37ec8d0758..4ab7cee6e1 100644 --- a/src/link/Coff.zig +++ b/src/link/Coff.zig @@ -1354,7 +1354,7 @@ fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Node) ! } // MSVC compiler_rt is missing some stuff, so we build it unconditionally but // and rely on weak linkage to allow MSVC compiler_rt functions to override ours. - if (comp.compiler_rt_static_lib) |lib| { + if (comp.compiler_rt_static_lib.crt_lib_file) |lib| { try argv.append(lib.full_object_path); } } diff --git a/src/link/Elf.zig b/src/link/Elf.zig index e0f114acd4..046aa2ec0a 100644 --- a/src/link/Elf.zig +++ b/src/link/Elf.zig @@ -1272,7 +1272,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v const stack_size = self.base.options.stack_size_override orelse 16777216; const allow_shlib_undefined = self.base.options.allow_shlib_undefined orelse !self.base.options.is_native_os; const compiler_rt_path: ?[]const u8 = blk: { - if (comp.compiler_rt_static_lib) |x| break :blk x.full_object_path; + if (comp.compiler_rt_static_lib.crt_lib_file) |x| break :blk x.full_object_path; if (comp.compiler_rt_obj) |x| break :blk x.full_object_path; break :blk null; }; diff --git a/src/link/MachO.zig b/src/link/MachO.zig index a4d14b985f..780b4b0483 100644 --- a/src/link/MachO.zig +++ b/src/link/MachO.zig @@ -738,7 +738,7 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No try positionals.append(p); } - if (comp.compiler_rt_static_lib) |lib| { + if (comp.compiler_rt_static_lib.crt_lib_file) |lib| { try positionals.append(lib.full_object_path); } diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig index ee2ed19ed5..30a1c49794 100644 --- a/src/link/Wasm.zig +++ b/src/link/Wasm.zig @@ -2255,7 +2255,7 @@ fn linkWithLLD(self: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) ! const is_obj = self.base.options.output_mode == .Obj; const compiler_rt_path: ?[]const u8 = if (self.base.options.include_compiler_rt and !is_obj) - comp.compiler_rt_static_lib.?.full_object_path + comp.compiler_rt_static_lib.crt_lib_file.?.full_object_path else null; diff --git a/src/musl.zig b/src/musl.zig index d061addc9a..68b524b415 100644 --- a/src/musl.zig +++ b/src/musl.zig @@ -4,7 +4,6 @@ const mem = std.mem; const path = std.fs.path; const assert = std.debug.assert; -const target_util = @import("target.zig"); const Compilation = @import("Compilation.zig"); const build_options = @import("build_options");