Commit 4ec27a4e2508049ce0d9b6e3cc149c0403c7014b | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-11-22 23:33:58-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-11-22 23:33:58-07:00
log	4ec27a4e2508049ce0d9b6e3cc149c0403c7014b
tree	381f694dba4cd63b6de67ef3902e2bf54826fc85
parent	0b28133ec239d62fc0df7460ac8b8e12b08ee88f

C backend: implement vector reduce and overflow intrinsics

5 files changed, 375 insertions(+), 80 deletions(-)

lib
- zig.h
src
- codegen
  - c.zig
  - llvm.zig
- target.zig
test
- behavior
  - vector.zig

lib/zig.h+146

...	...	@@ -344,6 +344,12 @@ static inline zig_bool zig_addo_u32(zig_u32 *res, zig_u32 lhs, zig_u32 rhs, zig_
344	344	#endif
345	345	}
346	346
	347	static inline void zig_vaddo_u32(zig_u8 ov, zig_u32 res, int n,
	348	const zig_u32 lhs, const zig_u32 rhs, zig_u8 bits)
	349	{
	350	for (int i = 0; i < n; ++i) ov[i] = zig_addo_u32(&res[i], lhs[i], rhs[i], bits);
	351	}
	352
347	353	zig_extern zig_i32 __addosi4(zig_i32 lhs, zig_i32 rhs, zig_c_int *overflow);
348	354	static inline zig_bool zig_addo_i32(zig_i32 *res, zig_i32 lhs, zig_i32 rhs, zig_u8 bits) {
349	355	#if zig_has_builtin(add_overflow)
...	...	@@ -358,6 +364,12 @@ static inline zig_bool zig_addo_i32(zig_i32 *res, zig_i32 lhs, zig_i32 rhs, zig_
358	364	return overflow \|\| full_res < zig_minInt(i32, bits) \|\| full_res > zig_maxInt(i32, bits);
359	365	}
360	366
	367	static inline void zig_vaddo_i32(zig_u8 ov, zig_i32 res, int n,
	368	const zig_i32 lhs, const zig_i32 rhs, zig_u8 bits)
	369	{
	370	for (int i = 0; i < n; ++i) ov[i] = zig_addo_i32(&res[i], lhs[i], rhs[i], bits);
	371	}
	372
361	373	static inline zig_bool zig_addo_u64(zig_u64 *res, zig_u64 lhs, zig_u64 rhs, zig_u8 bits) {
362	374	#if zig_has_builtin(add_overflow)
363	375	zig_u64 full_res;
...	...	@@ -370,6 +382,12 @@ static inline zig_bool zig_addo_u64(zig_u64 *res, zig_u64 lhs, zig_u64 rhs, zig_
370	382	#endif
371	383	}
372	384
	385	static inline void zig_vaddo_u64(zig_u8 ov, zig_u64 res, int n,
	386	const zig_u64 lhs, const zig_u64 rhs, zig_u8 bits)
	387	{
	388	for (int i = 0; i < n; ++i) ov[i] = zig_addo_u64(&res[i], lhs[i], rhs[i], bits);
	389	}
	390
373	391	zig_extern zig_i64 __addodi4(zig_i64 lhs, zig_i64 rhs, zig_c_int *overflow);
374	392	static inline zig_bool zig_addo_i64(zig_i64 *res, zig_i64 lhs, zig_i64 rhs, zig_u8 bits) {
375	393	#if zig_has_builtin(add_overflow)
...	...	@@ -384,6 +402,12 @@ static inline zig_bool zig_addo_i64(zig_i64 *res, zig_i64 lhs, zig_i64 rhs, zig_
384	402	return overflow \|\| full_res < zig_minInt(i64, bits) \|\| full_res > zig_maxInt(i64, bits);
385	403	}
386	404
	405	static inline void zig_vaddo_i64(zig_u8 ov, zig_i64 res, int n,
	406	const zig_i64 lhs, const zig_i64 rhs, zig_u8 bits)
	407	{
	408	for (int i = 0; i < n; ++i) ov[i] = zig_addo_i64(&res[i], lhs[i], rhs[i], bits);
	409	}
	410
387	411	static inline zig_bool zig_addo_u8(zig_u8 *res, zig_u8 lhs, zig_u8 rhs, zig_u8 bits) {
388	412	#if zig_has_builtin(add_overflow)
389	413	zig_u8 full_res;
...	...	@@ -395,6 +419,12 @@ static inline zig_bool zig_addo_u8(zig_u8 *res, zig_u8 lhs, zig_u8 rhs, zig_u8 b
395	419	#endif
396	420	}
397	421
	422	static inline void zig_vaddo_u8(zig_u8 ov, zig_u8 res, int n,
	423	const zig_u8 lhs, const zig_u8 rhs, zig_u8 bits)
	424	{
	425	for (int i = 0; i < n; ++i) ov[i] = zig_addo_u8(&res[i], lhs[i], rhs[i], bits);
	426	}
	427
398	428	static inline zig_bool zig_addo_i8(zig_i8 *res, zig_i8 lhs, zig_i8 rhs, zig_u8 bits) {
399	429	#if zig_has_builtin(add_overflow)
400	430	zig_i8 full_res;
...	...	@@ -406,6 +436,12 @@ static inline zig_bool zig_addo_i8(zig_i8 *res, zig_i8 lhs, zig_i8 rhs, zig_u8 b
406	436	#endif
407	437	}
408	438
	439	static inline void zig_vaddo_i8(zig_u8 ov, zig_i8 res, int n,
	440	const zig_i8 lhs, const zig_i8 rhs, zig_u8 bits)
	441	{
	442	for (int i = 0; i < n; ++i) ov[i] = zig_addo_i8(&res[i], lhs[i], rhs[i], bits);
	443	}
	444
409	445	static inline zig_bool zig_addo_u16(zig_u16 *res, zig_u16 lhs, zig_u16 rhs, zig_u8 bits) {
410	446	#if zig_has_builtin(add_overflow)
411	447	zig_u16 full_res;
...	...	@@ -417,6 +453,12 @@ static inline zig_bool zig_addo_u16(zig_u16 *res, zig_u16 lhs, zig_u16 rhs, zig_
417	453	#endif
418	454	}
419	455
	456	static inline void zig_vaddo_u16(zig_u8 ov, zig_u16 res, int n,
	457	const zig_u16 lhs, const zig_u16 rhs, zig_u8 bits)
	458	{
	459	for (int i = 0; i < n; ++i) ov[i] = zig_addo_u16(&res[i], lhs[i], rhs[i], bits);
	460	}
	461
420	462	static inline zig_bool zig_addo_i16(zig_i16 *res, zig_i16 lhs, zig_i16 rhs, zig_u8 bits) {
421	463	#if zig_has_builtin(add_overflow)
422	464	zig_i16 full_res;
...	...	@@ -428,6 +470,12 @@ static inline zig_bool zig_addo_i16(zig_i16 *res, zig_i16 lhs, zig_i16 rhs, zig_
428	470	#endif
429	471	}
430	472
	473	static inline void zig_vaddo_i16(zig_u8 ov, zig_i16 res, int n,
	474	const zig_i16 lhs, const zig_i16 rhs, zig_u8 bits)
	475	{
	476	for (int i = 0; i < n; ++i) ov[i] = zig_addo_i16(&res[i], lhs[i], rhs[i], bits);
	477	}
	478
431	479	static inline zig_bool zig_subo_u32(zig_u32 *res, zig_u32 lhs, zig_u32 rhs, zig_u8 bits) {
432	480	#if zig_has_builtin(sub_overflow)
433	481	zig_u32 full_res;
...	...	@@ -440,6 +488,12 @@ static inline zig_bool zig_subo_u32(zig_u32 *res, zig_u32 lhs, zig_u32 rhs, zig_
440	488	#endif
441	489	}
442	490
	491	static inline void zig_vsubo_u32(zig_u8 ov, zig_u32 res, int n,
	492	const zig_u32 lhs, const zig_u32 rhs, zig_u8 bits)
	493	{
	494	for (int i = 0; i < n; ++i) ov[i] = zig_subo_u32(&res[i], lhs[i], rhs[i], bits);
	495	}
	496
443	497	zig_extern zig_i32 __subosi4(zig_i32 lhs, zig_i32 rhs, zig_c_int *overflow);
444	498	static inline zig_bool zig_subo_i32(zig_i32 *res, zig_i32 lhs, zig_i32 rhs, zig_u8 bits) {
445	499	#if zig_has_builtin(sub_overflow)
...	...	@@ -454,6 +508,12 @@ static inline zig_bool zig_subo_i32(zig_i32 *res, zig_i32 lhs, zig_i32 rhs, zig_
454	508	return overflow \|\| full_res < zig_minInt(i32, bits) \|\| full_res > zig_maxInt(i32, bits);
455	509	}
456	510
	511	static inline void zig_vsubo_i32(zig_u8 ov, zig_i32 res, int n,
	512	const zig_i32 lhs, const zig_i32 rhs, zig_u8 bits)
	513	{
	514	for (int i = 0; i < n; ++i) ov[i] = zig_subo_i32(&res[i], lhs[i], rhs[i], bits);
	515	}
	516
457	517	static inline zig_bool zig_subo_u64(zig_u64 *res, zig_u64 lhs, zig_u64 rhs, zig_u8 bits) {
458	518	#if zig_has_builtin(sub_overflow)
459	519	zig_u64 full_res;
...	...	@@ -466,6 +526,12 @@ static inline zig_bool zig_subo_u64(zig_u64 *res, zig_u64 lhs, zig_u64 rhs, zig_
466	526	#endif
467	527	}
468	528
	529	static inline void zig_vsubo_u64(zig_u8 ov, zig_u64 res, int n,
	530	const zig_u64 lhs, const zig_u64 rhs, zig_u8 bits)
	531	{
	532	for (int i = 0; i < n; ++i) ov[i] = zig_subo_u64(&res[i], lhs[i], rhs[i], bits);
	533	}
	534
469	535	zig_extern zig_i64 __subodi4(zig_i64 lhs, zig_i64 rhs, zig_c_int *overflow);
470	536	static inline zig_bool zig_subo_i64(zig_i64 *res, zig_i64 lhs, zig_i64 rhs, zig_u8 bits) {
471	537	#if zig_has_builtin(sub_overflow)
...	...	@@ -480,6 +546,12 @@ static inline zig_bool zig_subo_i64(zig_i64 *res, zig_i64 lhs, zig_i64 rhs, zig_
480	546	return overflow \|\| full_res < zig_minInt(i64, bits) \|\| full_res > zig_maxInt(i64, bits);
481	547	}
482	548
	549	static inline void zig_vsubo_i64(zig_u8 ov, zig_i64 res, int n,
	550	const zig_i64 lhs, const zig_i64 rhs, zig_u8 bits)
	551	{
	552	for (int i = 0; i < n; ++i) ov[i] = zig_subo_i64(&res[i], lhs[i], rhs[i], bits);
	553	}
	554
483	555	static inline zig_bool zig_subo_u8(zig_u8 *res, zig_u8 lhs, zig_u8 rhs, zig_u8 bits) {
484	556	#if zig_has_builtin(sub_overflow)
485	557	zig_u8 full_res;
...	...	@@ -491,6 +563,12 @@ static inline zig_bool zig_subo_u8(zig_u8 *res, zig_u8 lhs, zig_u8 rhs, zig_u8 b
491	563	#endif
492	564	}
493	565
	566	static inline void zig_vsubo_u8(zig_u8 ov, zig_u8 res, int n,
	567	const zig_u8 lhs, const zig_u8 rhs, zig_u8 bits)
	568	{
	569	for (int i = 0; i < n; ++i) ov[i] = zig_subo_u8(&res[i], lhs[i], rhs[i], bits);
	570	}
	571
494	572	static inline zig_bool zig_subo_i8(zig_i8 *res, zig_i8 lhs, zig_i8 rhs, zig_u8 bits) {
495	573	#if zig_has_builtin(sub_overflow)
496	574	zig_i8 full_res;
...	...	@@ -502,6 +580,13 @@ static inline zig_bool zig_subo_i8(zig_i8 *res, zig_i8 lhs, zig_i8 rhs, zig_u8 b
502	580	#endif
503	581	}
504	582
	583	static inline void zig_vsubo_i8(zig_u8 ov, zig_i8 res, int n,
	584	const zig_i8 lhs, const zig_i8 rhs, zig_u8 bits)
	585	{
	586	for (int i = 0; i < n; ++i) ov[i] = zig_subo_i8(&res[i], lhs[i], rhs[i], bits);
	587	}
	588
	589
505	590	static inline zig_bool zig_subo_u16(zig_u16 *res, zig_u16 lhs, zig_u16 rhs, zig_u8 bits) {
506	591	#if zig_has_builtin(sub_overflow)
507	592	zig_u16 full_res;
...	...	@@ -513,6 +598,13 @@ static inline zig_bool zig_subo_u16(zig_u16 *res, zig_u16 lhs, zig_u16 rhs, zig_
513	598	#endif
514	599	}
515	600
	601	static inline void zig_vsubo_u16(zig_u8 ov, zig_u16 res, int n,
	602	const zig_u16 lhs, const zig_u16 rhs, zig_u8 bits)
	603	{
	604	for (int i = 0; i < n; ++i) ov[i] = zig_subo_u16(&res[i], lhs[i], rhs[i], bits);
	605	}
	606
	607
516	608	static inline zig_bool zig_subo_i16(zig_i16 *res, zig_i16 lhs, zig_i16 rhs, zig_u8 bits) {
517	609	#if zig_has_builtin(sub_overflow)
518	610	zig_i16 full_res;
...	...	@@ -524,6 +616,12 @@ static inline zig_bool zig_subo_i16(zig_i16 *res, zig_i16 lhs, zig_i16 rhs, zig_
524	616	#endif
525	617	}
526	618
	619	static inline void zig_vsubo_i16(zig_u8 ov, zig_i16 res, int n,
	620	const zig_i16 lhs, const zig_i16 rhs, zig_u8 bits)
	621	{
	622	for (int i = 0; i < n; ++i) ov[i] = zig_subo_i16(&res[i], lhs[i], rhs[i], bits);
	623	}
	624
527	625	static inline zig_bool zig_mulo_u32(zig_u32 *res, zig_u32 lhs, zig_u32 rhs, zig_u8 bits) {
528	626	#if zig_has_builtin(mul_overflow)
529	627	zig_u32 full_res;
...	...	@@ -536,6 +634,12 @@ static inline zig_bool zig_mulo_u32(zig_u32 *res, zig_u32 lhs, zig_u32 rhs, zig_
536	634	#endif
537	635	}
538	636
	637	static inline void zig_vmulo_u32(zig_u8 ov, zig_u32 res, int n,
	638	const zig_u32 lhs, const zig_u32 rhs, zig_u8 bits)
	639	{
	640	for (int i = 0; i < n; ++i) ov[i] = zig_mulo_u32(&res[i], lhs[i], rhs[i], bits);
	641	}
	642
539	643	zig_extern zig_i32 __mulosi4(zig_i32 lhs, zig_i32 rhs, zig_c_int *overflow);
540	644	static inline zig_bool zig_mulo_i32(zig_i32 *res, zig_i32 lhs, zig_i32 rhs, zig_u8 bits) {
541	645	#if zig_has_builtin(mul_overflow)
...	...	@@ -550,6 +654,12 @@ static inline zig_bool zig_mulo_i32(zig_i32 *res, zig_i32 lhs, zig_i32 rhs, zig_
550	654	return overflow \|\| full_res < zig_minInt(i32, bits) \|\| full_res > zig_maxInt(i32, bits);
551	655	}
552	656
	657	static inline void zig_vmulo_i32(zig_u8 ov, zig_i32 res, int n,
	658	const zig_i32 lhs, const zig_i32 rhs, zig_u8 bits)
	659	{
	660	for (int i = 0; i < n; ++i) ov[i] = zig_mulo_i32(&res[i], lhs[i], rhs[i], bits);
	661	}
	662
553	663	static inline zig_bool zig_mulo_u64(zig_u64 *res, zig_u64 lhs, zig_u64 rhs, zig_u8 bits) {
554	664	#if zig_has_builtin(mul_overflow)
555	665	zig_u64 full_res;
...	...	@@ -562,6 +672,12 @@ static inline zig_bool zig_mulo_u64(zig_u64 *res, zig_u64 lhs, zig_u64 rhs, zig_
562	672	#endif
563	673	}
564	674
	675	static inline void zig_vmulo_u64(zig_u8 ov, zig_u64 res, int n,
	676	const zig_u64 lhs, const zig_u64 rhs, zig_u8 bits)
	677	{
	678	for (int i = 0; i < n; ++i) ov[i] = zig_mulo_u64(&res[i], lhs[i], rhs[i], bits);
	679	}
	680
565	681	zig_extern zig_i64 __mulodi4(zig_i64 lhs, zig_i64 rhs, zig_c_int *overflow);
566	682	static inline zig_bool zig_mulo_i64(zig_i64 *res, zig_i64 lhs, zig_i64 rhs, zig_u8 bits) {
567	683	#if zig_has_builtin(mul_overflow)
...	...	@@ -576,6 +692,12 @@ static inline zig_bool zig_mulo_i64(zig_i64 *res, zig_i64 lhs, zig_i64 rhs, zig_
576	692	return overflow \|\| full_res < zig_minInt(i64, bits) \|\| full_res > zig_maxInt(i64, bits);
577	693	}
578	694
	695	static inline void zig_vmulo_i64(zig_u8 ov, zig_i64 res, int n,
	696	const zig_i64 lhs, const zig_i64 rhs, zig_u8 bits)
	697	{
	698	for (int i = 0; i < n; ++i) ov[i] = zig_mulo_i64(&res[i], lhs[i], rhs[i], bits);
	699	}
	700
579	701	static inline zig_bool zig_mulo_u8(zig_u8 *res, zig_u8 lhs, zig_u8 rhs, zig_u8 bits) {
580	702	#if zig_has_builtin(mul_overflow)
581	703	zig_u8 full_res;
...	...	@@ -587,6 +709,12 @@ static inline zig_bool zig_mulo_u8(zig_u8 *res, zig_u8 lhs, zig_u8 rhs, zig_u8 b
587	709	#endif
588	710	}
589	711
	712	static inline void zig_vmulo_u8(zig_u8 ov, zig_u8 res, int n,
	713	const zig_u8 lhs, const zig_u8 rhs, zig_u8 bits)
	714	{
	715	for (int i = 0; i < n; ++i) ov[i] = zig_mulo_u8(&res[i], lhs[i], rhs[i], bits);
	716	}
	717
590	718	static inline zig_bool zig_mulo_i8(zig_i8 *res, zig_i8 lhs, zig_i8 rhs, zig_u8 bits) {
591	719	#if zig_has_builtin(mul_overflow)
592	720	zig_i8 full_res;
...	...	@@ -598,6 +726,12 @@ static inline zig_bool zig_mulo_i8(zig_i8 *res, zig_i8 lhs, zig_i8 rhs, zig_u8 b
598	726	#endif
599	727	}
600	728
	729	static inline void zig_vmulo_i8(zig_u8 ov, zig_i8 res, int n,
	730	const zig_i8 lhs, const zig_i8 rhs, zig_u8 bits)
	731	{
	732	for (int i = 0; i < n; ++i) ov[i] = zig_mulo_i8(&res[i], lhs[i], rhs[i], bits);
	733	}
	734
601	735	static inline zig_bool zig_mulo_u16(zig_u16 *res, zig_u16 lhs, zig_u16 rhs, zig_u8 bits) {
602	736	#if zig_has_builtin(mul_overflow)
603	737	zig_u16 full_res;
...	...	@@ -609,6 +743,12 @@ static inline zig_bool zig_mulo_u16(zig_u16 *res, zig_u16 lhs, zig_u16 rhs, zig_
609	743	#endif
610	744	}
611	745
	746	static inline void zig_vmulo_u16(zig_u8 ov, zig_u16 res, int n,
	747	const zig_u16 lhs, const zig_u16 rhs, zig_u8 bits)
	748	{
	749	for (int i = 0; i < n; ++i) ov[i] = zig_mulo_u16(&res[i], lhs[i], rhs[i], bits);
	750	}
	751
612	752	static inline zig_bool zig_mulo_i16(zig_i16 *res, zig_i16 lhs, zig_i16 rhs, zig_u8 bits) {
613	753	#if zig_has_builtin(mul_overflow)
614	754	zig_i16 full_res;
...	...	@@ -620,6 +760,12 @@ static inline zig_bool zig_mulo_i16(zig_i16 *res, zig_i16 lhs, zig_i16 rhs, zig_
620	760	#endif
621	761	}
622	762
	763	static inline void zig_vmulo_i16(zig_u8 ov, zig_i16 res, int n,
	764	const zig_i16 lhs, const zig_i16 rhs, zig_u8 bits)
	765	{
	766	for (int i = 0; i < n; ++i) ov[i] = zig_mulo_i16(&res[i], lhs[i], rhs[i], bits);
	767	}
	768
623	769	#define zig_int_builtins(w) \
624	770	static inline zig_u##w zig_shlw_u##w(zig_u##w lhs, zig_u8 rhs, zig_u8 bits) { \
625	771	return zig_wrap_u##w(zig_shl_u##w(lhs, rhs), bits); \

src/codegen/c.zig+182-24

...	...	@@ -18,6 +18,12 @@ const Air = @import("../Air.zig");
18	18	const Liveness = @import("../Liveness.zig");
19	19	const CType = @import("../type.zig").CType;
20	20
	21	const target_util = @import("../target.zig");
	22	const libcFloatPrefix = target_util.libcFloatPrefix;
	23	const libcFloatSuffix = target_util.libcFloatSuffix;
	24	const compilerRtFloatAbbrev = target_util.compilerRtFloatAbbrev;
	25	const compilerRtIntAbbrev = target_util.compilerRtIntAbbrev;
	26
21	27	const Mutability = enum { Const, ConstArgument, Mut };
22	28	const BigIntLimb = std.math.big.Limb;
23	29	const BigInt = std.math.big.int;
...	...	@@ -733,7 +739,7 @@ pub const DeclGen = struct {
733	739	try dg.fmtIntLiteral(ty.errorUnionSet(), val),
734	740	});
735	741	},
736		.Array => {
	742	.Array, .Vector => {
737	743	if (location != .Initializer) {
738	744	try writer.writeByte('(');
739	745	try dg.renderTypecast(writer, ty);
...	...	@@ -770,10 +776,10 @@ pub const DeclGen = struct {
770	776	.BoundFn,
771	777	.Opaque,
772	778	=> unreachable,
	779
773	780	.Fn,
774	781	.Frame,
775	782	.AnyFrame,
776		.Vector,
777	783	=> \|tag\| return dg.fail("TODO: C backend: implement value of type {s}", .{
778	784	@tagName(tag),
779	785	}),
...	...	@@ -922,7 +928,7 @@ pub const DeclGen = struct {
922	928	=> try dg.renderParentPtr(writer, val, ty),
923	929	else => unreachable,
924	930	},
925		.Array => {
	931	.Array, .Vector => {
926	932	if (location == .FunctionArgument) {
927	933	try writer.writeByte('(');
928	934	try dg.renderTypecast(writer, ty);
...	...	@@ -1200,7 +1206,6 @@ pub const DeclGen = struct {
1200	1206
1201	1207	.Frame,
1202	1208	.AnyFrame,
1203		.Vector,
1204	1209	=> \|tag\| return dg.fail("TODO: C backend: implement value of type {s}", .{
1205	1210	@tagName(tag),
1206	1211	}),
...	...	@@ -1746,7 +1751,7 @@ pub const DeclGen = struct {
1746	1751	if (t.isVolatilePtr()) try w.writeAll(" volatile");
1747	1752	return w.writeAll(" *");
1748	1753	},
1749		.Array => {
	1754	.Array, .Vector => {
1750	1755	var array_pl = Type.Payload.Array{ .base = .{ .tag = .array }, .data = .{
1751	1756	.len = t.arrayLenIncludingSentinel(),
1752	1757	.elem_type = t.childType(),
...	...	@@ -1859,7 +1864,6 @@ pub const DeclGen = struct {
1859	1864
1860	1865	.Frame,
1861	1866	.AnyFrame,
1862		.Vector,
1863	1867	=> \|tag\| return dg.fail("TODO: C backend: implement value of type {s}", .{
1864	1868	@tagName(tag),
1865	1869	}),
...	...	@@ -3180,25 +3184,43 @@ fn airOverflow(f: *Function, inst: Air.Inst.Index, operation: []const u8, info:
3180	3184	const rhs = try f.resolveInst(bin_op.rhs);
3181	3185
3182	3186	const inst_ty = f.air.typeOfIndex(inst);
3183		const scalar_ty = f.air.typeOf(bin_op.lhs).scalarType();
	3187	const vector_ty = f.air.typeOf(bin_op.lhs);
	3188	const scalar_ty = vector_ty.scalarType();
3184	3189	const w = f.object.writer();
3185	3190
3186	3191	const local = try f.allocLocal(inst_ty, .Mut);
3187	3192	try w.writeAll(";\n");
3188	3193
3189		try f.writeCValueMember(w, local, .{ .field = 1 });
3190		try w.writeAll(" = zig_");
3191		try w.writeAll(operation);
3192		try w.writeAll("o_");
3193		try f.object.dg.renderTypeForBuiltinFnName(w, scalar_ty);
3194		try w.writeAll("(&");
3195		try f.writeCValueMember(w, local, .{ .field = 0 });
3196		try w.writeAll(", ");
	3194	switch (vector_ty.zigTypeTag()) {
	3195	.Vector => {
	3196	try w.writeAll("zig_v");
	3197	try w.writeAll(operation);
	3198	try w.writeAll("o_");
	3199	try f.object.dg.renderTypeForBuiltinFnName(w, scalar_ty);
	3200	try w.writeAll("(");
	3201	try f.writeCValueMember(w, local, .{ .field = 1 });
	3202	try w.writeAll(", ");
	3203	try f.writeCValueMember(w, local, .{ .field = 0 });
	3204	try w.print(", {d}, ", .{vector_ty.vectorLen()});
	3205	},
	3206	else => {
	3207	try f.writeCValueMember(w, local, .{ .field = 1 });
	3208	try w.writeAll(" = zig_");
	3209	try w.writeAll(operation);
	3210	try w.writeAll("o_");
	3211	try f.object.dg.renderTypeForBuiltinFnName(w, scalar_ty);
	3212	try w.writeAll("(&");
	3213	try f.writeCValueMember(w, local, .{ .field = 0 });
	3214	try w.writeAll(", ");
	3215	},
	3216	}
	3217
3197	3218	try f.writeCValue(w, lhs, .FunctionArgument);
3198	3219	try w.writeAll(", ");
3199	3220	try f.writeCValue(w, rhs, .FunctionArgument);
3200	3221	try f.object.dg.renderBuiltinInfo(w, scalar_ty, info);
3201	3222	try w.writeAll(");\n");
	3223
3202	3224	return local;
3203	3225	}
3204	3226
...	...	@@ -5206,16 +5228,153 @@ fn airShuffle(f: *Function, inst: Air.Inst.Index) !CValue {
5206	5228	fn airReduce(f: *Function, inst: Air.Inst.Index) !CValue {
5207	5229	if (f.liveness.isUnused(inst)) return CValue.none;
5208	5230
5209		const inst_ty = f.air.typeOfIndex(inst);
	5231	const target = f.object.dg.module.getTarget();
	5232	const scalar_ty = f.air.typeOfIndex(inst);
5210	5233	const reduce = f.air.instructions.items(.data)[inst].reduce;
5211	5234	const operand = try f.resolveInst(reduce.operand);
	5235	const operand_ty = f.air.typeOf(reduce.operand);
	5236	const vector_len = operand_ty.vectorLen();
5212	5237	const writer = f.object.writer();
5213		const local = try f.allocLocal(inst_ty, .Const);
	5238
	5239	const Op = union(enum) {
	5240	call_fn: []const u8,
	5241	infix: []const u8,
	5242	ternary: []const u8,
	5243	};
	5244	var fn_name_buf: [64]u8 = undefined;
	5245	const op: Op = switch (reduce.operation) {
	5246	.And => .{ .infix = " &= " },
	5247	.Or => .{ .infix = " \|= " },
	5248	.Xor => .{ .infix = " ^= " },
	5249	.Min => switch (scalar_ty.zigTypeTag()) {
	5250	.Int => .{ .ternary = " < " },
	5251	.Float => op: {
	5252	const float_bits = scalar_ty.floatBits(target);
	5253	break :op .{
	5254	.call_fn = std.fmt.bufPrintZ(&fn_name_buf, "{s}fmin{s}", .{
	5255	libcFloatPrefix(float_bits), libcFloatSuffix(float_bits),
	5256	}) catch unreachable,
	5257	};
	5258	},
	5259	else => unreachable,
	5260	},
	5261	.Max => switch (scalar_ty.zigTypeTag()) {
	5262	.Int => .{ .ternary = " > " },
	5263	.Float => op: {
	5264	const float_bits = scalar_ty.floatBits(target);
	5265	break :op .{
	5266	.call_fn = std.fmt.bufPrintZ(&fn_name_buf, "{s}fmax{s}", .{
	5267	libcFloatPrefix(float_bits), libcFloatSuffix(float_bits),
	5268	}) catch unreachable,
	5269	};
	5270	},
	5271	else => unreachable,
	5272	},
	5273	.Add => switch (scalar_ty.zigTypeTag()) {
	5274	.Int => .{ .infix = " += " },
	5275	.Float => op: {
	5276	const float_bits = scalar_ty.floatBits(target);
	5277	break :op .{
	5278	.call_fn = std.fmt.bufPrintZ(&fn_name_buf, "__add{s}f3", .{
	5279	compilerRtFloatAbbrev(float_bits),
	5280	}) catch unreachable,
	5281	};
	5282	},
	5283	else => unreachable,
	5284	},
	5285	.Mul => switch (scalar_ty.zigTypeTag()) {
	5286	.Int => .{ .infix = " *= " },
	5287	.Float => op: {
	5288	const float_bits = scalar_ty.floatBits(target);
	5289	break :op .{
	5290	.call_fn = std.fmt.bufPrintZ(&fn_name_buf, "__mul{s}f3", .{
	5291	compilerRtFloatAbbrev(float_bits),
	5292	}) catch unreachable,
	5293	};
	5294	},
	5295	else => unreachable,
	5296	},
	5297	};
	5298
	5299	// Reduce a vector by repeatedly applying a function to produce an
	5300	// accumulated result.
	5301	//
	5302	// Equivalent to:
	5303	// reduce: {
	5304	// var i: usize = 0;
	5305	// var accum: T = init;
	5306	// while (i < vec.len) : (i += 1) {
	5307	// accum = func(accum, vec[i]);
	5308	// }
	5309	// break :reduce accum;
	5310	// }
	5311	const it = try f.allocLocal(Type.usize, .Mut);
	5312	try writer.writeAll(" = 0;\n");
	5313
	5314	const accum = try f.allocLocal(scalar_ty, .Mut);
5214	5315	try writer.writeAll(" = ");
5215	5316
5216		_ = operand;
5217		_ = local;
5218		return f.fail("TODO: C backend: implement airReduce", .{});
	5317	const init_val = switch (reduce.operation) {
	5318	.And, .Or, .Xor, .Add => "0",
	5319	.Min => switch (scalar_ty.zigTypeTag()) {
	5320	.Int => "TODO_intmax",
	5321	.Float => "TODO_nan",
	5322	else => unreachable,
	5323	},
	5324	.Max => switch (scalar_ty.zigTypeTag()) {
	5325	.Int => "TODO_intmin",
	5326	.Float => "TODO_nan",
	5327	else => unreachable,
	5328	},
	5329	.Mul => "1",
	5330	};
	5331	try writer.writeAll(init_val);
	5332	try writer.writeAll(";");
	5333	try f.object.indent_writer.insertNewline();
	5334	try writer.writeAll("for(;");
	5335	try f.writeCValue(writer, it, .Other);
	5336	try writer.print("<{d};++", .{vector_len});
	5337	try f.writeCValue(writer, it, .Other);
	5338	try writer.writeAll(") ");
	5339	try f.writeCValue(writer, accum, .Other);
	5340
	5341	switch (op) {
	5342	.call_fn => \|fn_name\| {
	5343	try writer.print(" = {s}(", .{fn_name});
	5344	try f.writeCValue(writer, accum, .FunctionArgument);
	5345	try writer.writeAll(", ");
	5346	try f.writeCValue(writer, operand, .Other);
	5347	try writer.writeAll("[");
	5348	try f.writeCValue(writer, it, .Other);
	5349	try writer.writeAll("])");
	5350	},
	5351	.infix => \|ass\| {
	5352	try writer.writeAll(ass);
	5353	try f.writeCValue(writer, operand, .Other);
	5354	try writer.writeAll("[");
	5355	try f.writeCValue(writer, it, .Other);
	5356	try writer.writeAll("]");
	5357	},
	5358	.ternary => \|cmp\| {
	5359	try writer.writeAll(" = ");
	5360	try f.writeCValue(writer, accum, .Other);
	5361	try writer.writeAll(cmp);
	5362	try f.writeCValue(writer, operand, .Other);
	5363	try writer.writeAll("[");
	5364	try f.writeCValue(writer, it, .Other);
	5365	try writer.writeAll("] ? ");
	5366	try f.writeCValue(writer, accum, .Other);
	5367	try writer.writeAll(" : ");
	5368	try f.writeCValue(writer, operand, .Other);
	5369	try writer.writeAll("[");
	5370	try f.writeCValue(writer, it, .Other);
	5371	try writer.writeAll("]");
	5372	},
	5373	}
	5374
	5375	try writer.writeAll(";\n");
	5376
	5377	return accum;
5219	5378	}
5220	5379
5221	5380	fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
...	...	@@ -5234,7 +5393,7 @@ fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
5234	5393	const local = try f.allocLocal(inst_ty, mutability);
5235	5394	try writer.writeAll(" = ");
5236	5395	switch (inst_ty.zigTypeTag()) {
5237		.Array => {
	5396	.Array, .Vector => {
5238	5397	const elem_ty = inst_ty.childType();
5239	5398	try writer.writeByte('{');
5240	5399	var empty = true;
...	...	@@ -5354,7 +5513,6 @@ fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
5354	5513	try writer.writeAll(";\n");
5355	5514	},
5356	5515	},
5357		.Vector => return f.fail("TODO: C backend: implement airAggregateInit for vectors", .{}),
5358	5516	else => unreachable,
5359	5517	}
5360	5518
...	...	@@ -5868,7 +6026,7 @@ fn lowerFnRetTy(ret_ty: Type, buffer: *LowerFnRetTyBuffer, target: std.Target) T
5868	6026
5869	6027	fn lowersToArray(ty: Type, target: std.Target) bool {
5870	6028	return switch (ty.zigTypeTag()) {
5871		.Array => return true,
	6029	.Array, .Vector => return true,
5872	6030	else => return ty.isAbiInt() and toCIntBits(@intCast(u32, ty.bitSize(target))) == null,
5873	6031	};
5874	6032	}
...	...	@@ -5877,7 +6035,7 @@ fn loweredArrayInfo(ty: Type, target: std.Target) ?Type.ArrayInfo {
5877	6035	if (!lowersToArray(ty, target)) return null;
5878	6036
5879	6037	switch (ty.zigTypeTag()) {
5880		.Array => return ty.arrayInfo(),
	6038	.Array, .Vector => return ty.arrayInfo(),
5881	6039	else => {
5882	6040	const abi_size = ty.abiSize(target);
5883	6041	const abi_align = ty.abiAlignment(target);

src/codegen/llvm.zig+7-44

...	...	@@ -16,7 +16,6 @@ const Package = @import("../Package.zig");
16	16	const TypedValue = @import("../TypedValue.zig");
17	17	const Air = @import("../Air.zig");
18	18	const Liveness = @import("../Liveness.zig");
19		const target_util = @import("../target.zig");
20	19	const Value = @import("../value.zig").Value;
21	20	const Type = @import("../type.zig").Type;
22	21	const LazySrcLoc = Module.LazySrcLoc;
...	...	@@ -27,6 +26,12 @@ const aarch64_c_abi = @import("../arch/aarch64/abi.zig");
27	26	const arm_c_abi = @import("../arch/arm/abi.zig");
28	27	const riscv_c_abi = @import("../arch/riscv64/abi.zig");
29	28
	29	const target_util = @import("../target.zig");
	30	const libcFloatPrefix = target_util.libcFloatPrefix;
	31	const libcFloatSuffix = target_util.libcFloatSuffix;
	32	const compilerRtFloatAbbrev = target_util.compilerRtFloatAbbrev;
	33	const compilerRtIntAbbrev = target_util.compilerRtIntAbbrev;
	34
30	35	const Error = error{ OutOfMemory, CodegenFail };
31	36
32	37	pub fn targetTriple(allocator: Allocator, target: std.Target) ![:0]u8 {
...	...	@@ -7328,46 +7333,6 @@ pub const FuncGen = struct {
7328	7333	};
7329	7334	}
7330	7335
7331		fn libcFloatPrefix(float_bits: u16) []const u8 {
7332		return switch (float_bits) {
7333		16, 80 => "__",
7334		32, 64, 128 => "",
7335		else => unreachable,
7336		};
7337		}
7338
7339		fn libcFloatSuffix(float_bits: u16) []const u8 {
7340		return switch (float_bits) {
7341		16 => "h", // Non-standard
7342		32 => "f",
7343		64 => "",
7344		80 => "x", // Non-standard
7345		128 => "q", // Non-standard (mimics convention in GCC libquadmath)
7346		else => unreachable,
7347		};
7348		}
7349
7350		fn compilerRtFloatAbbrev(float_bits: u16) []const u8 {
7351		return switch (float_bits) {
7352		16 => "h",
7353		32 => "s",
7354		64 => "d",
7355		80 => "x",
7356		128 => "t",
7357		else => unreachable,
7358		};
7359		}
7360
7361		fn compilerRtIntAbbrev(bits: u16) []const u8 {
7362		return switch (bits) {
7363		16 => "h",
7364		32 => "s",
7365		64 => "d",
7366		128 => "t",
7367		else => "o", // Non-standard
7368		};
7369		}
7370
7371	7336	/// Creates a floating point comparison by lowering to the appropriate
7372	7337	/// hardware instruction or softfloat routine for the target
7373	7338	fn buildFloatCmp(
...	...	@@ -9034,12 +8999,10 @@ pub const FuncGen = struct {
9034	8999	const target = self.dg.module.getTarget();
9035	9000
9036	9001	const reduce = self.air.instructions.items(.data)[inst].reduce;
9037		var operand = try self.resolveInst(reduce.operand);
	9002	const operand = try self.resolveInst(reduce.operand);
9038	9003	const operand_ty = self.air.typeOf(reduce.operand);
9039	9004	const scalar_ty = self.air.typeOfIndex(inst);
9040	9005
9041		// TODO handle the fast math setting
9042
9043	9006	switch (reduce.operation) {
9044	9007	.And => return self.builder.buildAndReduce(operand),
9045	9008	.Or => return self.builder.buildOrReduce(operand),

src/target.zig+40

...	...	@@ -729,3 +729,43 @@ pub fn supportsTailCall(target: std.Target, backend: std.builtin.CompilerBackend
729	729	else => return false,
730	730	}
731	731	}
	732
	733	pub fn libcFloatPrefix(float_bits: u16) []const u8 {
	734	return switch (float_bits) {
	735	16, 80 => "__",
	736	32, 64, 128 => "",
	737	else => unreachable,
	738	};
	739	}
	740
	741	pub fn libcFloatSuffix(float_bits: u16) []const u8 {
	742	return switch (float_bits) {
	743	16 => "h", // Non-standard
	744	32 => "f",
	745	64 => "",
	746	80 => "x", // Non-standard
	747	128 => "q", // Non-standard (mimics convention in GCC libquadmath)
	748	else => unreachable,
	749	};
	750	}
	751
	752	pub fn compilerRtFloatAbbrev(float_bits: u16) []const u8 {
	753	return switch (float_bits) {
	754	16 => "h",
	755	32 => "s",
	756	64 => "d",
	757	80 => "x",
	758	128 => "t",
	759	else => unreachable,
	760	};
	761	}
	762
	763	pub fn compilerRtIntAbbrev(bits: u16) []const u8 {
	764	return switch (bits) {
	765	16 => "h",
	766	32 => "s",
	767	64 => "d",
	768	128 => "t",
	769	else => "o", // Non-standard
	770	};
	771	}

test/behavior/vector.zig-12

...	...	@@ -13,7 +13,6 @@ test "implicit cast vector to array - bool" {
13	13	}
14	14
15	15	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
16		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
17	16	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
18	17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
19	18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -294,7 +293,6 @@ test "vector @splat" {
294	293
295	294	test "load vector elements via comptime index" {
296	295	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
297		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
298	296	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
299	297	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
300	298	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -317,7 +315,6 @@ test "load vector elements via comptime index" {
317	315
318	316	test "store vector elements via comptime index" {
319	317	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
320		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
321	318	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
322	319	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
323	320	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -346,7 +343,6 @@ test "store vector elements via comptime index" {
346	343
347	344	test "load vector elements via runtime index" {
348	345	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
349		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
350	346	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
351	347	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
352	348	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -369,7 +365,6 @@ test "load vector elements via runtime index" {
369	365
370	366	test "store vector elements via runtime index" {
371	367	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
372		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
373	368	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
374	369	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
375	370	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -393,7 +388,6 @@ test "store vector elements via runtime index" {
393	388
394	389	test "initialize vector which is a struct field" {
395	390	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
396		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
397	391	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
398	392	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
399	393	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -975,7 +969,6 @@ test "@addWithOverflow" {
975	969	return error.SkipZigTest;
976	970	}
977	971	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
978		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
979	972	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
980	973	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
981	974	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -1018,7 +1011,6 @@ test "@subWithOverflow" {
1018	1011	return error.SkipZigTest;
1019	1012	}
1020	1013	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1021		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1022	1014	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1023	1015	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1024	1016	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -1049,7 +1041,6 @@ test "@mulWithOverflow" {
1049	1041	return error.SkipZigTest;
1050	1042	}
1051	1043	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1052		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1053	1044	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1054	1045	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1055	1046	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -1072,7 +1063,6 @@ test "@shlWithOverflow" {
1072	1063	return error.SkipZigTest;
1073	1064	}
1074	1065	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1075		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1076	1066	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1077	1067	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1078	1068	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -1098,7 +1088,6 @@ test "alignment of vectors" {
1098	1088
1099	1089	test "loading the second vector from a slice of vectors" {
1100	1090	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1101		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1102	1091	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1103	1092	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1104	1093	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -1115,7 +1104,6 @@ test "loading the second vector from a slice of vectors" {
1115	1104
1116	1105	test "array of vectors is copied" {
1117	1106	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1118		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1119	1107	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1120	1108	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1121	1109	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO