Commit d85c0ba08048d3e729d535a6df7d095fb72c6677 | zig

author	Jacob Young <jacobly@ziglang.org> 2026-10-18 17:48:15-04:00
committer	Jacob Young <jacobly@ziglang.org> 2026-10-20 15:45:44-04:00
log	d85c0ba08048d3e729d535a6df7d095fb72c6677
tree	d8da7ea8c644103e397432518d3bf5d3e4599681
parent	c8bb44618a9c3c7bfff4a9f672a451fdeda1bb02

19 files changed, 33 insertions(+), 21 deletions(-)

lib/compiler_rt.zig+8

...	...	@@ -399,6 +399,14 @@ fn complexAbi(comptime Float: type, comptime float: type) type {
399	399	};
400	400	}
401	401
	402	pub const have_c_longdouble = if (builtin.target.cTypeBitSize(.longdouble)) \|bits\| switch (bits) {
	403	else => true,
	404	80 => switch (std.zig.target.compilerRtFloatAbi(&builtin.target, bits)) {
	405	.soft => false,
	406	.hard => true,
	407	},
	408	} else false;
	409
402	410	pub fn Complex(comptime Float: type) type {
403	411	return struct { real: Float, imag: Float };
404	412	}

lib/compiler_rt/cos.zig+4-2

...	...	@@ -25,8 +25,10 @@ comptime {
25	25	symbol(&cos, "cos");
26	26	symbol(&__cosx, "__cosx");
27	27	symbol(&cosq, "cosf128");
28		symbol(&cosl, "cosl");
29		symbol(&cosl, "__cosl"); // required by musl
	28	if (compiler_rt.have_c_longdouble) {
	29	symbol(&cosl, "cosl");
	30	symbol(&cosl, "__cosl"); // required by musl
	31	}
30	32	}
31	33
32	34	fn __cosh(x: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/exp.zig+1-1

...	...	@@ -22,7 +22,7 @@ comptime {
22	22	symbol(&exp, "exp");
23	23	symbol(&__expx, "__expx");
24	24	symbol(&expq, "expf128");
25		symbol(&expl, "expl");
	25	if (compiler_rt.have_c_longdouble) symbol(&expl, "expl");
26	26	}
27	27
28	28	fn __exph(x: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/exp2.zig+1-1

...	...	@@ -20,7 +20,7 @@ comptime {
20	20	symbol(&exp2, "exp2");
21	21	symbol(&__exp2x, "__exp2x");
22	22	symbol(&exp2q, "exp2f128");
23		symbol(&exp2l, "exp2l");
	23	if (compiler_rt.have_c_longdouble) symbol(&exp2l, "exp2l");
24	24	}
25	25
26	26	fn __exp2h(x: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/fabs.zig+1-1

...	...	@@ -10,7 +10,7 @@ comptime {
10	10	symbol(&fabs, "fabs");
11	11	symbol(&__fabsx, "__fabsx");
12	12	symbol(&fabsq, "fabsf128");
13		symbol(&fabsl, "fabsl");
	13	if (compiler_rt.have_c_longdouble) symbol(&fabsl, "fabsl");
14	14	}
15	15
16	16	fn __fabsh(a: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/floor_ceil.zig+2-2

...	...	@@ -24,7 +24,7 @@ comptime {
24	24	symbol(&floor, "floor");
25	25	symbol(&__floorx, "__floorx");
26	26	symbol(&floorq, "floorf128");
27		symbol(&floorl, "floorl");
	27	if (compiler_rt.have_c_longdouble) symbol(&floorl, "floorl");
28	28
29	29	// ceil
30	30	symbol(&__ceilh, "__ceilh");
...	...	@@ -32,7 +32,7 @@ comptime {
32	32	symbol(&ceil, "ceil");
33	33	symbol(&__ceilx, "__ceilx");
34	34	symbol(&ceilq, "ceilf128");
35		symbol(&ceill, "ceill");
	35	if (compiler_rt.have_c_longdouble) symbol(&ceill, "ceill");
36	36	}
37	37
38	38	fn __floorh(x: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/fma.zig+1-1

...	...	@@ -18,7 +18,7 @@ comptime {
18	18	symbol(&fma, "fma");
19	19	symbol(&__fmax, "__fmax");
20	20	symbol(&fmaq, "fmaf128");
21		symbol(&fmal, "fmal");
	21	if (compiler_rt.have_c_longdouble) symbol(&fmal, "fmal");
22	22	}
23	23
24	24	fn __fmah(x: compiler_rt.f16.Abi, y: compiler_rt.f16.Abi, z: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/fmax.zig+1-1

...	...	@@ -11,7 +11,7 @@ comptime {
11	11	symbol(&fmax, "fmax");
12	12	symbol(&__fmaxx, "__fmaxx");
13	13	symbol(&fmaxq, "fmaxf128");
14		symbol(&fmaxl, "fmaxl");
	14	if (compiler_rt.have_c_longdouble) symbol(&fmaxl, "fmaxl");
15	15	}
16	16
17	17	fn __fmaxh(x: compiler_rt.f16.Abi, y: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/fmin.zig+1-1

...	...	@@ -11,7 +11,7 @@ comptime {
11	11	symbol(&fmin, "fmin");
12	12	symbol(&__fminx, "__fminx");
13	13	symbol(&fminq, "fminf128");
14		symbol(&fminl, "fminl");
	14	if (compiler_rt.have_c_longdouble) symbol(&fminl, "fminl");
15	15	}
16	16
17	17	fn __fminh(x: compiler_rt.f16.Abi, y: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/fmod.zig+1-1

...	...	@@ -13,7 +13,7 @@ comptime {
13	13	symbol(&fmod, "fmod");
14	14	symbol(&__fmodx, "__fmodx");
15	15	symbol(&fmodq, "fmodf128");
16		symbol(&fmodl, "fmodl");
	16	if (compiler_rt.have_c_longdouble) symbol(&fmodl, "fmodl");
17	17	}
18	18
19	19	fn __fmodh(a: compiler_rt.f16.Abi, b: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/log.zig+1-1

...	...	@@ -19,7 +19,7 @@ comptime {
19	19	symbol(&log, "log");
20	20	symbol(&__logx, "__logx");
21	21	symbol(&logq, "logf128");
22		symbol(&logl, "logl");
	22	if (compiler_rt.have_c_longdouble) symbol(&logl, "logl");
23	23	}
24	24
25	25	fn __logh(a: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/log10.zig+1-1

...	...	@@ -19,7 +19,7 @@ comptime {
19	19	symbol(&log10, "log10");
20	20	symbol(&__log10x, "__log10x");
21	21	symbol(&log10q, "log10f128");
22		symbol(&log10l, "log10l");
	22	if (compiler_rt.have_c_longdouble) symbol(&log10l, "log10l");
23	23	}
24	24
25	25	fn __log10h(a: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/log2.zig+1-1

...	...	@@ -20,7 +20,7 @@ comptime {
20	20	symbol(&log2, "log2");
21	21	symbol(&__log2x, "__log2x");
22	22	symbol(&log2q, "log2f128");
23		symbol(&log2l, "log2l");
	23	if (compiler_rt.have_c_longdouble) symbol(&log2l, "log2l");
24	24	}
25	25
26	26	fn __log2h(a: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/round.zig+1-1

...	...	@@ -19,7 +19,7 @@ comptime {
19	19	symbol(&round, "round");
20	20	symbol(&__roundx, "__roundx");
21	21	symbol(&roundq, "roundf128");
22		symbol(&roundl, "roundl");
	22	if (compiler_rt.have_c_longdouble) symbol(&roundl, "roundl");
23	23	}
24	24
25	25	fn __roundh(x: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/sin.zig+4-2

...	...	@@ -25,8 +25,10 @@ comptime {
25	25	symbol(&sin, "sin");
26	26	symbol(&__sinx, "__sinx");
27	27	symbol(&sinq, "sinf128");
28		symbol(&sinl, "sinl");
29		symbol(&sinl, "__sinl"); // required by musl
	28	if (compiler_rt.have_c_longdouble) {
	29	symbol(&sinl, "sinl");
	30	symbol(&sinl, "__sinl"); // required by musl
	31	}
30	32	}
31	33
32	34	fn __sinh(x: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/sincos.zig+1-1

...	...	@@ -19,7 +19,7 @@ comptime {
19	19	symbol(&sincos, "sincos");
20	20	symbol(&sincosx, "__sincosx");
21	21	symbol(&sincosq, "sincosf128");
22		symbol(&sincosl, "sincosl");
	22	if (compiler_rt.have_c_longdouble) symbol(&sincosl, "sincosl");
23	23	}
24	24
25	25	fn sincosh(x: compiler_rt.f16.Abi, r_sin: compiler_rt.f16.Abi, r_cos: compiler_rt.f16.Abi) callconv(.c) void {

lib/compiler_rt/sqrt.zig+1-1

...	...	@@ -23,7 +23,7 @@ comptime {
23	23	} else if (compiler_rt.want_sparc32_abi) {
24	24	symbol(&sqrtq, "_Q_sqrt");
25	25	}
26		symbol(&sqrtl, "sqrtl");
	26	if (compiler_rt.have_c_longdouble) symbol(&sqrtl, "sqrtl");
27	27	}
28	28
29	29	fn __sqrth(x: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/tan.zig+1-1

...	...	@@ -29,7 +29,7 @@ comptime {
29	29	symbol(&tan, "tan");
30	30	symbol(&__tanx, "__tanx");
31	31	symbol(&tanq, "tanf128");
32		symbol(&tanl, "tanl");
	32	if (compiler_rt.have_c_longdouble) symbol(&tanl, "tanl");
33	33	}
34	34
35	35	fn __tanh(x: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {

lib/compiler_rt/trunc.zig+1-1

...	...	@@ -18,7 +18,7 @@ comptime {
18	18	symbol(&trunc, "trunc");
19	19	symbol(&__truncx, "__truncx");
20	20	symbol(&truncq, "truncf128");
21		symbol(&truncl, "truncl");
	21	if (compiler_rt.have_c_longdouble) symbol(&truncl, "truncl");
22	22	}
23	23
24	24	fn __trunch(x: compiler_rt.f16.Abi) callconv(.c) compiler_rt.f16.Abi {