Commit 05afb3f358e6c9fc8ae3ba9f3b135dc93f5d9aad | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-11-23 22:49:13-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-01-09 14:40:44-07:00
log	05afb3f358e6c9fc8ae3ba9f3b135dc93f5d9aad
tree	c99747d2ab8c127995f65d321d41f31f4ad35051
parent	703552e253757db994b20533526f2a5d0826a193

Merge pull request #13632 from ziglang/cbe

5 files changed, 377 insertions(+), 84 deletions(-)

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

lib/zig.h+148-4

...	...	@@ -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); \
...	...	@@ -846,10 +992,8 @@ static inline zig_u8 zig_bit_reverse_u8(zig_u8 val, zig_u8 bits) {
846	992	full_res = __builtin_bitreverse8(val);
847	993	#else
848	994	static zig_u8 const lut[0x10] = {
849		0b0000, 0b1000, 0b0100, 0b1100,
850		0b0010, 0b1010, 0b0110, 0b1110,
851		0b0001, 0b1001, 0b0101, 0b1101,
852		0b0011, 0b1011, 0b0111, 0b1111,
	995	0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
	996	0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf
853	997	};
854	998	full_res = lut[val >> 0 & 0xF] << 4 \| lut[val >> 4 & 0xF] << 0;
855	999	#endif

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 => Op{ .ternary = " < " },
	5251	.Float => op: {
	5252	const float_bits = scalar_ty.floatBits(target);
	5253	break :op 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 => Op{ .ternary = " > " },
	5263	.Float => op: {
	5264	const float_bits = scalar_ty.floatBits(target);
	5265	break :op 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 => Op{ .infix = " += " },
	5275	.Float => op: {
	5276	const float_bits = scalar_ty.floatBits(target);
	5277	break :op 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 => Op{ .infix = " *= " },
	5287	.Float => op: {
	5288	const float_bits = scalar_ty.floatBits(target);
	5289	break :op 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

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

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