diff --git a/lib/std/special/compiler_rt.zig b/lib/std/special/compiler_rt.zig index 3ef2bf4747..4397165981 100644 --- a/lib/std/special/compiler_rt.zig +++ b/lib/std/special/compiler_rt.zig @@ -41,8 +41,8 @@ comptime { const __extendhfxf2 = @import("compiler_rt/extend_f80.zig").__extendhfxf2; @export(__extendhfxf2, .{ .name = "__extendhfxf2", .linkage = linkage }); - const __extendffxf2 = @import("compiler_rt/extend_f80.zig").__extendffxf2; - @export(__extendffxf2, .{ .name = "__extendffxf2", .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; @@ -105,26 +105,6 @@ comptime { @export(__extendhfsf2, .{ .name = "__gnu_h2f_ieee", .linkage = linkage }); } - // Integral 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 }); - if (builtin.os.tag == .windows) { // Default stack-probe functions emitted by LLVM if (is_mingw) { @@ -214,8 +194,8 @@ comptime { const __truncxfhf2 = @import("compiler_rt/trunc_f80.zig").__truncxfhf2; @export(__truncxfhf2, .{ .name = "__truncxfhf2", .linkage = linkage }); - const __truncxfff2 = @import("compiler_rt/trunc_f80.zig").__truncxfff2; - @export(__truncxfff2, .{ .name = "__truncxfff2", .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; @@ -274,20 +254,7 @@ comptime { const __divtf3 = @import("compiler_rt/divtf3.zig").__divtf3; @export(__divtf3, .{ .name = "__divtf3", .linkage = linkage }); - // Integral bit manipulation - 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 }); - + // 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; @@ -306,21 +273,18 @@ comptime { @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; @@ -429,13 +393,26 @@ comptime { @export(__isPlatformVersionAtLeast, .{ .name = "__isPlatformVersionAtLeast", .linkage = linkage }); } - // Integral arithmetic + // 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; @@ -463,7 +440,7 @@ comptime { const __udivmodsi4 = @import("compiler_rt/int.zig").__udivmodsi4; @export(__udivmodsi4, .{ .name = "__udivmodsi4", .linkage = linkage }); - // Integral arithmetic with trapping overflow + // 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; @@ -477,9 +454,27 @@ comptime { const __negvti2 = @import("compiler_rt/negv.zig").__negvti2; @export(__negvti2, .{ .name = "__negvti2", .linkage = linkage }); - // missing: Integral arithmetic which returns if overflow + // 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 }); - // Integral comparison + // Integer Comparison // (a < b) => 0 // (a == b) => 1 // (a > b) => 2 diff --git a/lib/std/special/compiler_rt/README.md b/lib/std/special/compiler_rt/README.md index bc853f2958..7115a5756f 100644 --- a/lib/std/special/compiler_rt/README.md +++ b/lib/std/special/compiler_rt/README.md @@ -1,15 +1,267 @@ -This compiler-rt library is ported from [LLVM](http://compiler-rt.llvm.org/). +If hardware lacks basic or specialized functionality, compiler-rt adds such functionality +for basic arithmetic(s). +One such example is 64-bit integer multiplication on 32-bit x86. -It's needed because LLVM emits library calls to compiler-rt when hardware lacks -functionality, for example, 64-bit integer multiplication on 32-bit x86. +Goals: +1. zig as linker for object files produced by other compilers + => `function compatibility` to compiler-rt and libgcc for same-named functions + * compatibility conflict between compiler-rt and libgcc: prefer compiler-rt +2. `symbol-level compatibility` low-priority compared to emitted calls by llvm + * symbol-level compatibility: libgcc even lower priority +3. add zig-specific language runtime features, see #7265 + * example: arbitrary bit width integer arithmetic + * lower to call those functions for e.g. multiplying two i12345 numbers together + * proper naming + documention for standardizing (allow languages to follow our exmaple) + +Current status (tracking libgcc documentation): +- Integer library routines => almost implemented +- Soft float library routines => only f80 routines missing +- Decimal float library routines => unimplemented (~120 functions) +- Fixed-point fractional library routines => unimplemented (~300 functions) +- Exception handling routines => unclear, if supported (~32+x undocumented functions) +- Miscellaneous routines => unclear, if supported (cache control and stack function) +- No zig-specific language runtime features in compiler-rt yet This library is automatically built as-needed for the compilation target and then statically linked and therefore is a transparent dependency for the programmer. +For details see `../compiler_rt.zig`. -Any bugs should be solved by trying to duplicate the bug upstream. - * If the bug exists upstream, get it fixed with the LLVM team and then port - the fix downstream to Zig. - * If the bug only exists in Zig, something went wrong porting the code, - and you can run the C code and Zig code side by side in a debugger - to figure out what's happening differently. +The routines in this folder are listed below. +Routines are annotated as `type source routine // description`, with `routine` +being the name used in aforementioned `compiler_rt.zig`. +`dev` means deviating from compiler_rt, `port` ported, `source` is the +information source for the implementation, `none` means unimplemented. +Some examples for the naming convention are: +- dev source name_routine, name_routine2 various implementations for performance, simplicity etc +- port llvm compiler-rt library routines from [LLVM](http://compiler-rt.llvm.org/) + * LLVM emits library calls to compiler-rt, if the hardware lacks functionality +- port musl libc routines from [musl](https://musl.libc.org/) +If the library or information source is uncommon, use the entry `other` for `source`. +Please do not break the search by inserting entries in another format than `impl space source`. + +Bugs should be solved by trying to duplicate the bug upstream, if possible. + * If the bug exists upstream, get it fixed upstream and port the fix downstream to Zig. + * If the bug only exists in Zig, use the corresponding C code and debug + both implementations side by side to figure out what is wrong. + +## Integer library routines + +#### Integer Bit operations +- dev HackersDelight __clzsi2 // count leading zeros +- dev HackersDelight __clzdi2 // count leading zeros +- dev HackersDelight __clzti2 // count leading zeros +- dev HackersDelight __ctzsi2 // count trailing zeros +- dev HackersDelight __ctzdi2 // count trailing zeros +- dev HackersDelight __ctzti2 // count trailing zeros +- dev __ctzsi2 __ffssi2 // find least significant 1 bit +- dev __ctzsi2 __ffsdi2 // find least significant 1 bit +- dev __ctzsi2 __ffsti2 // find least significant 1 bit +- dev BitTwiddlingHacks __paritysi2 // bit parity +- dev BitTwiddlingHacks __paritydi2 // bit parity +- dev BitTwiddlingHacks __parityti2 // bit parity +- dev TAOCP __popcountsi2 // bit population +- dev TAOCP __popcountdi2 // bit population +- dev TAOCP __popcountti2 // bit population +- dev other __bswapsi2 // a byteswapped +- dev other __bswapdi2 // a byteswapped +- dev other __bswapti2 // a byteswapped + +#### Integer Comparison +- port llvm __cmpsi2 // (aoutput=0, (a==b)=>output=1, (a>b)=>output=2 +- port llvm __cmpdi2 +- port llvm __cmpti2 +- port llvm __ucmpsi2 // (aoutput=0, (a==b)=>output=1, (a>b)=>output=2 +- port llvm __ucmpdi2 +- port llvm __ucmpti2 + +#### Integer Arithmetic +- none none __ashlsi3 // a << b unused in llvm, missing (e.g. used by rl78) +- port llvm __ashldi3 // a << b +- port llvm __ashlti3 // a << b +- none none __ashrsi3 // a >> b arithmetic (sign fill) missing (e.g. used by rl78) +- port llvm __ashrdi3 // a >> b arithmetic (sign fill) +- port llvm __ashrti3 // a >> b arithmetic (sign fill) +- none none __lshrsi3 // a >> b logical (zero fill) missing (e.g. used by rl78) +- port llvm __lshrdi3 // a >> b logical (zero fill) +- port llvm __lshrti3 // a >> b logical (zero fill) +- port llvm __negdi2 // -a symbol-level compatibility: libgcc +- port llvm __negti2 // -a unnecessary: unused in backends +- port llvm __mulsi3 // a * b signed +- port llvm __muldi3 // a * b signed +- port llvm __multi3 // a * b signed +- port llvm __divsi3 // a / b signed +- port llvm __divdi3 // a / b signed +- port llvm __divti3 // a / b signed +- port llvm __udivsi3 // a / b unsigned +- port llvm __udivdi3 // a / b unsigned +- port llvm __udivti3 // a / b unsigned +- port llvm __modsi3 // a % b signed +- port llvm __moddi3 // a % b signed +- port llvm __modti3 // a % b signed +- port llvm __umodsi3 // a % b unsigned +- port llvm __umoddi3 // a % b unsigned +- port llvm __umodti3 // a % b unsigned +- port llvm __udivmoddi4 // a / b, rem.* = a % b unsigned +- port llvm __udivmodti4 // a / b, rem.* = a % b unsigned +- port llvm __udivmodsi4 // a / b, rem.* = a % b unsigned +- port llvm __divmodsi4 // a / b, rem.* = a % b signed, ARM + +#### Integer Arithmetic with trapping overflow +- dev BitTwiddlingHacks __absvsi2 // abs(a) +- dev BitTwiddlingHacks __absvdi2 // abs(a) +- dev BitTwiddlingHacks __absvti2 // abs(a) +- port llvm __negvsi2 // -a symbol-level compatibility: libgcc +- port llvm __negvdi2 // -a unnecessary: unused in backends +- port llvm __negvti2 // -a +- TODO upstreaming __addvsi3..__mulvti3 after testing panics works +- dev HackersDelight __addvsi3 // a + b +- dev HackersDelight __addvdi3 // a + b +- dev HackersDelight __addvti3 // a + b +- dev HackersDelight __subvsi3 // a - b +- dev HackersDelight __subvdi3 // a - b +- dev HackersDelight __subvti3 // a - b +- dev HackersDelight __mulvsi3 // a * b +- dev HackersDelight __mulvdi3 // a * b +- dev HackersDelight __mulvti3 // a * b + +#### Integer Arithmetic which returns if overflow (would be faster without pointer) +- dev HackersDelight __addosi4 // a + b, overflow=>ov.*=1 else 0 +- dev HackersDelight __addodi4 // (completeness + performance, llvm does not use them) +- dev HackersDelight __addoti4 // +- dev HackersDelight __subosi4 // a - b, overflow=>ov.*=1 else 0 +- dev HackersDelight __subodi4 // (completeness + performance, llvm does not use them) +- dev HackersDelight __suboti4 // +- dev HackersDelight __mulosi4 // a * b, overflow=>ov.*=1 else 0 +- dev HackersDelight __mulodi4 // (required by llvm) +- dev HackersDelight __muloti4 // + +## Float library routines + +#### Float Conversion +- todo todo __extendsfdf2 // extend a f32 => f64 +- todo todo __extendsftf2 // extend a f32 => f128 +- dev llvm __extendsfxf2 // extend a f32 => f80 +- todo todo __extenddftf2 // extend a f64 => f128 +- dev llvm __extenddfxf2 // extend a f64 => f80 +- todo todo __truncdfsf2 // truncate a to narrower mode of return type, rounding towards zero +- todo todo __trunctfdf2 // +- todo todo __trunctfsf2 // +- dev llvm __truncxfsf2 // +- dev llvm __truncxfdf2 // +- todo todo __fixsfsi // convert a to i32, rounding towards zero +- todo todo __fixdfsi // +- todo todo __fixtfsi // +- none none __fixxfsi // missing +- todo todo __fixsfdi // convert a to i64, rounding towards zero +- todo todo __fixdfdi // +- todo todo __fixtfdi // +- none none __fixxfdi // missing +- todo todo __fixsfti // convert a to i128, rounding towards zero +- todo todo __fixdfti // +- todo todo __fixtfdi // +- none none __fixxfti // missing + +- __fixunssfsi // convert to u32, rounding towards zero. negative values become 0. +- __fixunsdfsi // +- __fixunstfsi // +- __fixunsxfsi // missing +- __fixunssfdi // convert to u64, rounding towards zero. negative values become 0. +- __fixunsdfdi // +- __fixunstfdi // +- __fixunsxfdi // missing +- __fixunssfti // convert to u128, rounding towards zero. negative values become 0. +- __fixunsdfti // +- __fixunstfdi // +- __fixunsxfti // missing + +- __floatsisf // convert i32 to floating point +- __floatsidf // +- __floatsitf // +- __floatsixf // missing +- __floatdisf // convert i64 to floating point +- __floatdidf // +- __floatditf // +- __floatdixf // missing +- __floattisf // convert i128 to floating point +- __floattidf // +- __floattixf // missing + +- __floatunsisf // convert i32 to floating point +- __floatunsidf // +- __floatunsitf // +- __floatunsixf // missing +- __floatundisf // convert i64 to floating point +- __floatundidf // +- __floatunditf // +- __floatundixf // missing +- __floatuntisf // convert i128 to floating point +- __floatuntidf // +- __floatuntitf // +- __floatuntixf // missing + +#### Float Comparison +- __cmpsf2 // return (a-1,(a==b)=>0,(a>b)=>1,Nan=>1 dont rely on this +- __cmpdf2 // exported from __lesf2, __ledf2, __letf2 (below) +- __cmptf2 // +- __unordsf2 // (input==NaN) => out!=0 else out=0, +- __unorddf2 // __only reliable for (input!=Nan)__ +- __unordtf2 // +- __eqsf2 // (a!=NaN) and (b!=Nan) and (a==b) => output=0 +- __eqdf2 // +- __eqtf2 // +- __nesf2 // (a==NaN) or (b==Nan) or (a!=b) => output!=0 +- __nedf2 // +- __netf2 // +- __gesf2 // (a!=Nan) and (b!=Nan) and (a>=b) => output>=0 +- __gedf2 // +- __getf2 // +- __ltsf2 // (a!=Nan) and (b!=Nan) and (a output<0 +- __ltdf2 // +- __lttf2 // +- __lesf2 // (a!=Nan) and (b!=Nan) and (a<=b) => output<=0 +- __ledf2 // +- __letf2 // +- __gtsf2 // (a!=Nan) and (b!=Nan) and (a>b) => output>0 +- __gtdf2 // +- __gttf2 // + +#### Float Arithmetic +- __addsf3 // a + b f32 +- __adddf3 // a + b f64 +- __addtf3 // a + b f128 +- __addxf3 // a + b f80 +- __aeabi_fadd // a + b f64 ARM: AAPCS +- __aeabi_dadd // a + b f64 ARM: AAPCS +- __subsf3 // a - b +- __subdf3 // a - b +- __subtf3 // a - b +- __subxf3 // a - b f80 +- __aeabi_fsub // a - b f64 ARM: AAPCS +- __aeabi_dsub // a - b f64 ARM: AAPCS +- __mulsf3 // a * b +- __muldf3 // a * b +- __multf3 // a * b +- __mulxf3 // a * b missing +- __divsf3 // a / b +- __divdf3 // a / b +- __divtf3 // a / b +- __divxf3 // a / b missing +- __negsf2 // -a symbol-level compatibility: libgcc uses this for the rl78 +- __negdf2 // -a unnecessary: can be lowered directly to a xor +- __negtf2 // -a +- __negxf2 // -a + +#### Floating point raised to integer power +- __powisf2 // unclear, if supported a ^ b +- __powidf2 // +- __powitf2 // +- __powixf2 // +- __mulsc3 // unsupported (a+ib) * (c+id) +- __muldc3 // +- __multc3 // +- __mulxc3 // +- __divsc3 // unsupported (a+ib) * / (c+id) +- __divdc3 // +- __divtc3 // +- __divxc3 // diff --git a/lib/std/special/compiler_rt/extend_f80.zig b/lib/std/special/compiler_rt/extend_f80.zig index 4686421db0..e68fb5fcf8 100644 --- a/lib/std/special/compiler_rt/extend_f80.zig +++ b/lib/std/special/compiler_rt/extend_f80.zig @@ -11,7 +11,7 @@ pub fn __extendhfxf2(a: F16T) callconv(.C) f80 { return extendF80(f16, @bitCast(u16, a)); } -pub fn __extendffxf2(a: f32) callconv(.C) f80 { +pub fn __extendsfxf2(a: f32) callconv(.C) f80 { return extendF80(f32, @bitCast(u32, a)); } diff --git a/lib/std/special/compiler_rt/trunc_f80.zig b/lib/std/special/compiler_rt/trunc_f80.zig index 19e8d44b86..88381a28ee 100644 --- a/lib/std/special/compiler_rt/trunc_f80.zig +++ b/lib/std/special/compiler_rt/trunc_f80.zig @@ -10,7 +10,7 @@ pub fn __truncxfhf2(a: f80) callconv(.C) F16T { return @bitCast(F16T, trunc(f16, a)); } -pub fn __truncxfff2(a: f80) callconv(.C) f32 { +pub fn __truncxfsf2(a: f80) callconv(.C) f32 { return trunc(f32, a); } diff --git a/src/stage1/codegen.cpp b/src/stage1/codegen.cpp index fffa834d1c..bfe58ae912 100644 --- a/src/stage1/codegen.cpp +++ b/src/stage1/codegen.cpp @@ -1641,7 +1641,7 @@ static LLVMValueRef gen_soft_f80_widen_or_shorten(CodeGen *g, ZigType *actual_ty break; case 32: return_type = g->builtin_types.entry_f32->llvm_type; - func_name = "__truncxfff2"; + func_name = "__truncxfsf2"; break; case 64: return_type = g->builtin_types.entry_f64->llvm_type; @@ -1670,7 +1670,7 @@ static LLVMValueRef gen_soft_f80_widen_or_shorten(CodeGen *g, ZigType *actual_ty break; case 32: param_type = g->builtin_types.entry_f32->llvm_type; - func_name = "__extendffxf2"; + func_name = "__extendsfxf2"; break; case 64: param_type = g->builtin_types.entry_f64->llvm_type;